Deploy cff9def from GitHub Actions

agent_runtime.py

@@ -39,6 +39,10 @@ class SessionRuntime:
     def command(self, name, args):
         return ""
 
+    def _prepare_approval(self, actions):
+        """Adapter hook for binding an approval to its displayed tool inputs."""
+        pass
+
     def _emit(self, **e):
         if e["type"] not in ("token", "reasoning"):
             log.info("session %s %s %s", self.id, e["type"], e.get("tool") or e.get("state") or "")
@@ -98,6 +102,11 @@ class SessionRuntime:
         self.usage = result.context_wrapper.usage
         if result.interruptions:
             self.state = result.to_state()
+            try:
+                self._prepare_approval(self.pending())
+            except Exception:
+                self.state = None
+                raise
             return dict(type="approval", actions=self.pending())
         self.state = None
         return dict(type="status", state="finished")

public_agent.py

@@ -4,6 +4,7 @@ internal demo. Only the data and result-store adapters differ in this deployment
 """
 from __future__ import annotations
 import asyncio
+import ast
 import json
 import os
 import queue
@@ -127,20 +128,30 @@ def describe(task='all'):
     return {'datasets':out}
 
 
+# RDFLib/pyparsing share parser state, including the first query's lazy setup.
+# Keep query evaluation and result materialization inside one process-wide lock.
+ONTOLOGY_QUERY_LOCK = threading.Lock()
+
+
 def ontology(query):
     if not isinstance(query,str) or len(query)>4000 or not re.search(r'\b(SELECT|ASK)\b',query,re.I) or re.search(r'\b(SERVICE|FROM|LOAD|INSERT|DELETE|CREATE|DROP|CLEAR|MOVE|COPY|ADD)\b',query,re.I):
         raise ValueError('Read-only local SELECT/ASK queries only')
     g=rdflib.Graph();d=rdflib.Namespace('urn:ontic:data:');o=rdflib.Namespace('urn:ontic:')
     g.bind('d',d);g.bind('ontic',o);g.bind('rdfs',rdflib.RDFS);g.bind('owl',rdflib.OWL);g.bind('xsd',rdflib.XSD)
     for key,spec in DATA.items():
+        *_,sm=tables(key)
+        policy_columns=sm.tables[key]['columns']
         t=d[key];g.add((t,rdflib.RDF.type,rdflib.OWL.Class));g.add((t,rdflib.RDFS.label,rdflib.Literal(spec['name'])))
         for i,title in enumerate(spec['sheets'][0]['columns']):
             c=d[f'{key}.column{i}'];g.add((c,rdflib.RDFS.domain,t));g.add((c,rdflib.RDFS.label,rdflib.Literal(title)))
             g.add((c,rdflib.RDFS.range,rdflib.XSD.string if i==0 else rdflib.XSD.double))
-            g.add((c,o.sensitivity,rdflib.Literal('none')))
-    r=g.query(query)
-    if r.type=='ASK':return {'answer':bool(r.askAnswer)}
-    return {'rows':[{str(v):str(row[v]) if row[v] is not None else None for v in r.vars} for row in list(r)[:100]]}
+            code='entity_id' if i==0 else f'c{i-1}'
+            sensitivity=policy_columns.get(code,{}).get('sensitivity','none')
+            g.add((c,o.sensitivity,rdflib.Literal(sensitivity)))
+    with ONTOLOGY_QUERY_LOCK:
+        r=g.query(query)
+        if r.type=='ASK':return {'answer':bool(r.askAnswer)}
+        return {'rows':[{str(v):str(row[v]) if row[v] is not None else None for v in r.vars} for row in list(r)[:100]]}
 
 
 def llm_features(task,n=4,token=None,requirements=""):
@@ -153,9 +164,12 @@ When the user names specific columns, use ONLY those columns and do not add othe
 Use only declared c0/c1/c2/c3 columns. Never use entity_id or labels.
 Format: {{"programs":[{{"name":"snake_case","path":["{task}"],"agg":"none","expr":"c0","window_days":null,"rationale":"한국어 근거"}}]}}.
 These are snapshots with no time history. agg must be none and window_days null.
+Rationale must describe the proposed input calculation, not an observed effect on risk. Do not claim feature importance, causal impact, probability amplification or measured interactions. For a ratio, keep the numerator and denominator in the same order as expr. Any usefulness claim is an unvalidated hypothesis.
 Include relevant source columns and optionally defensible arithmetic expressions if requested. No fictitious time aggregations or units. JSON object with programs array only.'''
     schema={'type':'object','properties':{'programs':{'type':'array','minItems':1,'maxItems':n,'items':{'type':'object','properties':{'name':{'type':'string'},'path':{'type':'array','items':{'type':'string','enum':[task]},'minItems':1,'maxItems':1},'agg':{'type':'string','enum':['none']},'expr':{'type':'string'},'window_days':{'type':'null'},'rationale':{'type':'string'}},'required':['name','path','agg','expr','window_days','rationale'],'additionalProperties':False}}},'required':['programs'],'additionalProperties':False}
-    response=OpenAI(base_url=base,api_key=key,timeout=120,max_retries=0).chat.completions.create(model=MODEL,response_format={'type':'json_schema','json_schema':{'name':'feature_programs','schema':schema}},messages=[{'role':'system','content':'You propose ontology-constrained feature programs. Return a JSON object containing programs.'},{'role':'user','content':prompt}],temperature=0,max_tokens=1800)
+    # This bounded structured subrequest needs final JSON, not a thinking trace
+    # that can exhaust its output budget. Keep the main agent's reasoning intact.
+    response=OpenAI(base_url=base,api_key=key,timeout=120,max_retries=0).chat.completions.create(model=MODEL,response_format={'type':'json_schema','json_schema':{'name':'feature_programs','schema':schema}},messages=[{'role':'system','content':'You propose ontology-constrained feature programs. Return a JSON object containing programs.'},{'role':'user','content':prompt}],temperature=0,max_tokens=1800,reasoning_effort='none')
     text=response.choices[0].message.content or ''
     try: programs=json.loads(text)['programs']
     except Exception:raise ValueError('Feature proposal was not a programs object; retry propose_features')
@@ -179,15 +193,82 @@ def columns(task):
     return {f'c{i}':title for i,title in enumerate(DATA[task]['sheets'][0]['columns'][1:5])}
 
 
-def restrict(task,result,text):
-    """Columns the user named are a hard constraint, not just a prompt instruction (2026-10-18 local QA: the LLM mixed in others)."""
-    named={f'c{i}' for i,title in enumerate(DATA[task]['sheets'][0]['columns'][1:5]) if title in (text or '')}
-    if not named:return result
-    for p in list(result['programs']):
-        extra=set(re.findall(r'\bc\d+\b',p['expr']))-named
-        if extra:result['programs'].remove(p);result['rejected'].append({'program':p,'reason':f'Uses columns the user did not request: {sorted(extra)}'})
-    if not result['programs']:raise ValueError(f'Every proposal used unrequested columns; propose again using only {sorted(named)}')
-    return result
+def column_policy(task,text,previous=()):
+    """Resolve explicit source-column constraints, including edits to a proposal.
+
+    This validates the user's column boundary; the LLM still proposes programs.
+    Relative exclusions apply to the previous proposal, not every dataset input.
+    """
+    text=text or '';cols=columns(task);aliases={v:k for k,v in cols.items()}|{k:k for k in cols}
+    pattern='|'.join(re.escape(x) for x in sorted(aliases,key=len,reverse=True))
+    mentions=[(m.start(),m.end(),aliases[m.group()]) for m in re.finditer(pattern,text)]
+    excluded=set()
+    protected=[m.span() for m in re.finditer(r'빼지\s*(?:말|않)|제외하지\s*(?:말|않)|제외\s*안\s*하|안\s*빼',text)]
+    negative=r'제외(?:해|하|한|할)?|빼(?:고|줘|서|면)?|말고|(?:사용|쓰|넣)지\s*(?:마|말|않)|사용하지\s*(?:마|말|않)|안\s*(?:쓰|사용|넣)'
+    negatives=[]
+    for match in re.finditer(negative,text):
+        if any(start<=match.start()<end for start,end in protected):continue
+        negatives.append(match)
+        before=[m for m in mentions if m[1]<=match.start() and match.start()-m[1]<=45
+                and not re.search(r'[.!?。\n]',text[m[1]:match.start()])]
+        if not before:continue
+        group=[before[-1]]
+        for candidate in reversed(before[:-1]):
+            if re.fullmatch(r'[\s,、·/&와과및이랑하고또는을를은는도만]+',text[candidate[1]:group[-1][0]]):group.append(candidate)
+            else:break
+        excluded.update(m[2] for m in group)
+    # Prefix phrasing names what to remove after the verb, e.g. "제외할 컬럼은 A".
+    for match in re.finditer(r'(?:제외할|제외하는|뺄|빼야\s*할)\s*(?:(?:입력|컬럼|열|변수|피처|기준)\s*)?(?:은|는|이|가)?\s*[:：]?\s*',text):
+        after=[m for m in mentions if m[0]>=match.end() and m[0]-match.end()<=45]
+        if not after:continue
+        group=[after[0]]
+        for candidate in after[1:]:
+            if re.fullmatch(r'[\s,、·/&와과및이랑하고또는을를은는도만]+',text[group[-1][1]:candidate[0]]):group.append(candidate)
+            else:break
+        excluded.update(m[2] for m in group)
+    named={m[2] for m in mentions};positive=named-excluded
+    prior=set(re.findall(r'\bc[0-3]\b',' '.join(p.get('expr','') for p in previous)))
+    relative=bool(re.search(r'나머지|남은|남겨|기존|이전|방금',text))
+    all_mentions=list(re.finditer(r'모든\s*(?:입력|컬럼|변수)|(?:입력|컬럼|변수)(?:을|를)?\s*(?:모두|전부)',text))
+    negated_all=any(any(a.end()<=m.start()<next((c[0] for c in mentions if c[0]>=a.end()),len(text)) for m in negatives) for a in all_mentions)
+    all_inputs=bool(all_mentions) and not negated_all
+    if all_inputs:allowed=set(cols)-excluded
+    elif negated_all:allowed=positive-excluded
+    elif excluded:allowed=(positive or prior or set(cols))-excluded
+    elif positive:allowed=positive
+    elif relative and prior:allowed=prior
+    else:allowed=None
+    if allowed is not None and not allowed:raise ValueError('No requested input columns remain; choose another input before proposing features')
+    return {'allowed':allowed,'excluded':excluded,'relative':relative}
+
+
+def restrict(task,result,text,previous=()):
+    """Enforce positive and negative column requirements independently of the LLM."""
+    policy=column_policy(task,text,previous);allowed=policy['allowed']
+    if allowed is None:return result
+    accepted=[];rejected=list(result.get('rejected',[]))
+    for program in result['programs']:
+        extra=set(re.findall(r'\bc\d+\b',program['expr']))-allowed
+        if extra:rejected.append({'program':program,'reason':f'Uses columns the user did not request: {sorted(extra)}'})
+        else:accepted.append(program)
+    if not accepted:raise ValueError(f'Every proposal used unrequested columns; propose again using only {sorted(allowed)}')
+    return dict(result,programs=accepted,rejected=rejected)
+
+
+def feature_definition(task,expr):
+    """Describe only validated arithmetic; a model rationale is not an effect."""
+    cols=columns(task)
+    try:node=ast.parse(expr,mode='eval').body
+    except SyntaxError:node=None
+    if isinstance(node,ast.Name) and node.id in cols:return '해당 컬럼의 원본 입력값'
+    if isinstance(node,ast.BinOp) and isinstance(node.left,ast.Name) and isinstance(node.right,ast.Name):
+        left,right=cols.get(node.left.id),cols.get(node.right.id)
+        if left and right:
+            if isinstance(node.op,ast.Div):return f'분자: {left} · 분모: {right}'
+            if isinstance(node.op,ast.Mult):return '두 입력값을 곱한 값'
+            if isinstance(node.op,ast.Add):return '두 입력값을 더한 값'
+            if isinstance(node.op,ast.Sub):return '앞 입력값에서 뒤 입력값을 뺀 값'
+    return '표시된 계산식을 원본 입력에 적용한 값'
 
 
 def observe(ctx,name,fn):
@@ -242,11 +323,23 @@ def show_view(ctx:RunContextWrapper,kind:Literal['schema','table','distribution'
 
 def describe_data(ctx:RunContextWrapper,task:Literal['all','churn','stockout','defect']='all',summary:str='')->str:
     """Read actual workbook schemas, column names, row counts, statistics and ontology. task: all|churn|stockout|defect. summary: short Korean status."""
-    return observe(ctx,'describe_data',lambda:describe(task))
+    out=observe(ctx,'describe_data',lambda:describe(task));data=json.loads(out)
+    if 'error' in data:return out
+    # The feature synthesizer has the executable mapping separately. Ordinary
+    # data questions need source names, not its internal c0/c1 aliases.
+    for dataset in data['datasets']:
+        dataset.pop('feature_mapping',None);dataset.pop('semantic_model',None)
+    return json.dumps(data,ensure_ascii=False)
 
 
 def query_ontology(ctx:RunContextWrapper,query:str,summary:str='')->str:
-    """Read the published synthetic ontology with local SELECT/ASK SPARQL. Prefixes ontic:,d:,rdfs:,owl:,xsd: are predefined. summary: Korean status."""
+    """Read local SELECT/ASK SPARQL. Prefixes ontic:,d:,rdfs:,owl:,xsd: are predefined.
+    Tables are d:churn, d:stockout, d:defect. Columns have rdfs:domain,
+    rdfs:label, rdfs:range and ontic:sensitivity; nullRate/distinct are absent.
+    Example: SELECT ?col ?label ?sensitivity WHERE { ?col rdfs:domain d:churn; rdfs:label ?label; ontic:sensitivity ?sensitivity }
+    To select an ID use FILTER(?col = d:churn.column0), never a bare ?col = ... triple.
+    summary: Korean status.
+    """
     return observe(ctx,'query_ontology',lambda:ontology(query))
 
 
@@ -254,22 +347,64 @@ def propose_features(ctx:RunContextWrapper,task:Literal['churn','stockout','defe
     """Use the LLM to synthesize feature programs, then validate against the ontology. task: churn|stockout|defect, n:1-8. summary: Korean status."""
     def run():
         if not 1<=n<=8:raise ValueError('n must be 1-8')
-        result=llm_features(task,n,ctx.context.id,requirements or ctx.context.request_text)
-        result=restrict(task,result,ctx.context.request_text)   # the LLM may rewrite requirements; the user's own words still bind
-        ctx.context.proposals[task]=result;return result
+        previous=ctx.context.proposals.get(task,{}).get('programs',[])
+        policy=column_policy(task,ctx.context.request_text,previous)
+        requested=requirements or ctx.context.request_text
+        if policy['relative'] and policy['allowed'] is not None:
+            requested+='\n이번 제안에 허용된 입력 컬럼은 '+', '.join(columns(task)[c] for c in sorted(policy['allowed']))+'뿐입니다. 다른 입력을 추가하지 마세요.'
+        result=llm_features(task,n,ctx.context.id,requested)
+        result=restrict(task,result,ctx.context.request_text,previous)   # the user's own edit still binds after LLM rewriting
+        if policy['allowed'] is not None:
+            result['input_boundary']={'source':'latest_user_request_and_previous_proposal',
+              'allowed_columns':[columns(task)[c] for c in sorted(policy['allowed'])],
+              'excluded_columns':[columns(task)[c] for c in sorted(policy['excluded'])],
+              'relative_to_previous_proposal':policy['relative'],
+              'note':'이 범위는 사용자 원문에서 검증했습니다. 입력이 하나만 남아도 원값이나 해당 입력만의 계산은 유효합니다. 다른 컬럼을 추가하려고 반복 제안하지 마세요. n은 최대 개수입니다.'}
+        result['definitions']={p['name']:feature_definition(task,p['expr']) for p in result['programs']}
+        result['rationale_status']='model_proposal_not_empirical_effect'
+        ctx.context.proposals[task]=result;ctx.context.proposal_task=task;return result
     return observe(ctx,'propose_features',run)
 
 
+def _execution_programs(session,task,names=None):
+    """Select the exact requested programs without widening the latest scope.
+
+    Invalid selections are rejected together; no valid subset executes silently.
+    The same check runs before SDK approval and again before feature execution.
+    """
+    proposal=session.proposals.get(task)
+    if not proposal:raise ValueError('Call propose_features first')
+    programs=proposal['programs']
+    if names is not None and (not isinstance(names,list) or any(not isinstance(name,str) for name in names)):
+        raise ValueError('Feature names must be a list of proposed names')
+    if names and (len(names)!=len(set(names)) or set(names)-{p['name'] for p in programs}):
+        raise ValueError('Unknown or duplicate proposed feature names')
+    selected=[p for p in programs if not names or p['name'] in names]
+    if not selected:raise ValueError('No approved feature programs')
+    allowed=column_policy(task,session.request_text,programs)['allowed']
+    def within_scope(program):
+        return allowed is None or not (set(re.findall(r'\bc\d+\b',program['expr']))-allowed)
+    invalid=[p['name'] for p in selected if not within_scope(p)]
+    if invalid:
+        remaining=[p['name'] for p in programs if within_scope(p)]
+        raise ValueError(f'Programs violate latest requested input columns: {invalid}. '
+                         f'Propose again or request fresh approval for remaining names: {remaining}')
+    return json.loads(json.dumps(selected,ensure_ascii=False))
+
+
+async def execution_needs_approval(ctx,arguments,call_id):
+    """Only valid selections reach approval; invalid ones emit tool errors."""
+    try:
+        _execution_programs(ctx.context,arguments.get('task'),arguments.get('names'))
+    except ValueError:
+        return False
+    return True
+
+
 def execute_features(ctx:RunContextWrapper,task:Literal['churn','stockout','defect'],names:list[str]|None=None,summary:str='')->str:
     """Execute proposed features after the system obtains user approval. Empty names means all accepted proposals. summary: Korean status."""
     def run():
-        s=ctx.context;proposal=s.proposals.get(task)
-        if not proposal:raise ValueError('Call propose_features first')
-        programs=proposal['programs']
-        if names:
-            if set(names)-{p['name'] for p in programs}:raise ValueError('Unknown proposed feature')
-            programs=[p for p in programs if p['name'] in names]
-        if not programs:raise ValueError('No approved feature programs')
+        s=ctx.context;programs=_execution_programs(s,task,names)
         frame,y,subjects,sm=tables(task)
         fps=[FeatureProgram.from_dict(p) for p in programs]
         for fp in fps:
@@ -312,30 +447,64 @@ def predict(ctx:RunContextWrapper,feat_id:str,summary:str='')->str:
         prob=tabfm(X[:len(y)],y,X[len(y):])
         rows=sorted([{'row':i,'subject':subject,'probability':float(p)} for i,(subject,p) in enumerate(zip(f['subjects'],prob))],key=lambda r:-r['probability'])
         run_id=secrets.token_hex(16)
+        if not rows:raise ValueError('Prediction did not return any target rows')
         result={'run_id':run_id,'task':f['task'],'features':[p['name'] for p in f['programs']],'programs':f['programs'],'predictions':rows,'validation':{'method':'stratified synthetic holdout, 72 train / 24 validation','auc':auc,'constant_baseline_auc':0.5,'baseline_probability':baseline},'seconds':round(time.monotonic()-started,3),'model':{'repo':'jingang/TabICL','checkpoint':CHECKPOINT,'output':'real_inference'},'columns':columns(f['task']),'caveat':'Synthetic validation only; target outcomes unknown. No causal interpretation or production accuracy claim.'}
+        # Attach the actual evidence before observe() emits the prediction and
+        # before the run is stored for publish_results(). The return value,
+        # result card and stored report must describe the same observation.
+        result['top_evidence']=_feature_evidence(f,rows[0]['row'])
         ctx.context.runs[run_id]=dict(result,feat_id=feat_id);return result
     out=observe(ctx,'predict',run);result=json.loads(out)
     if 'run_id' not in result:return out
-    # Evidence is part of every prediction, so the system attaches it for the top-risk row instead of relying on the LLM to call explain.
-    result['top_evidence']=json.loads(explain_once(ctx,result['run_id'],result['predictions'][0]['row']))
-    return json.dumps(result,ensure_ascii=False)
+    # Preserve predict -> explain ordering and one explain event per row.
+    explain_once(ctx,result['run_id'],result['predictions'][0]['row'])
+    return out
 
 
 def explain_once(ctx,run_id,row):
     """Emit evidence for a (run, row) once; a repeated request (e.g. the LLM after the automatic one) returns it silently."""
     seen=ctx.context.__dict__.setdefault('explained',{})
     if (run_id,row) in seen:return json.dumps(seen[run_id,row],ensure_ascii=False)
-    out=observe(ctx,'explain',lambda:evidence(ctx.context,run_id,row));data=json.loads(out)
+    stored=ctx.context.runs.get(run_id,{})
+    top=stored.get('top_evidence')
+    out=observe(ctx,'explain',lambda:top if isinstance(top,dict) and top.get('row')==row else evidence(ctx.context,run_id,row));data=json.loads(out)
     if 'error' not in data:seen[run_id,row]=data
     return out
 
 
+def _feature_evidence(f,row):
+    """Observed source inputs and computed features, without attribution claims."""
+    if row<0 or row>=len(f['subjects']):raise ValueError('Unknown target row')
+    target=DATA[f['task']]['sheets'][1]
+    names=columns(f['task'])
+    used={code for p in f['programs'] for code in re.findall(r'\bc[0-3]\b',p['expr'])}
+    inputs=[]
+    for i,(code,name) in enumerate(names.items()):
+        if code not in used:continue
+        values=[float(source[i+1]) for source in target['rows']]
+        value=values[row]
+        inputs.append({'column_code':code,'column':name,'value':value,'unit':None,
+                       'target_rank_ascending':1+sum(other<value for other in values),
+                       'target_tie_count':sum(other==value for other in values),
+                       'target_count':len(values),'target_min':min(values),'target_max':max(values)})
+    features=[]
+    for i,p in enumerate(f['programs']):
+        refs=set(re.findall(r'\bc[0-3]\b',p['expr']))
+        features.append({'feature':p['name'],'expr':p['expr'],
+                         'display_expr':re.sub(r'\bc[0-3]\b',lambda match:names[match.group()],p['expr']),
+                         'rationale':p['rationale'],'value':float(f['matrix'][len(f['labels'])+row,i]),
+                         'input_columns':[name for code,name in names.items() if code in refs],'unit':None})
+    return {'subject':f['subjects'][row],'row':row,'task':f['task'],'source_sheet':target['name'],
+            'input_values':inputs,'features':features,
+            'unit_description':'Dimensionless synthetic relative values; no physical units are defined.',
+            'caveat':'Observed source inputs and computed feature values, not causal effects or feature importance. '
+                     'Risk probability does not establish whether an input is high or low; compare actual observed values before making that claim.'}
+
+
 def evidence(s,run_id,row):
     r=s.runs.get(run_id)
     if not r:raise ValueError('Unknown prediction run in this session')
-    f=s.features[r['feat_id']]
-    if row<0 or row>=len(f['subjects']):raise ValueError('Unknown target row')
-    return {'subject':f['subjects'][row],'row':row,'features':[{'feature':p['name'],'expr':p['expr'],'rationale':p['rationale'],'value':float(f['matrix'][96+row,i])} for i,p in enumerate(f['programs'])],'caveat':'Observed feature values, not causal effects or feature importance.'}
+    return _feature_evidence(s.features[r['feat_id']],row)
 
 
 def explain(ctx:RunContextWrapper,run_id:str,row:int=0,summary:str='')->str:
@@ -355,7 +524,22 @@ def publish_results(ctx:RunContextWrapper,run_id:str,summary:str='')->str:
         return {'run_id':run_id,'dashboard_url':'/demo#report='+run_id,'n_rows':len(result['predictions']),'storage':'public synthetic result database, expires after 24 hours or backend restart'}
     return observe(ctx,'publish_results',run)
 
-TOOLS=[function_tool(fn,strict_mode=False,needs_approval=fn is execute_features) for fn in [describe_data,query_ontology,propose_features,execute_features,predict,explain,publish_results,show_view]]
+def _execution_tool():
+    from agents import FunctionTool
+    decorated=function_tool(execute_features,strict_mode=False)
+    async def invoke(ctx,arguments):
+        return await decorated.on_invoke_tool(ctx,arguments)
+    # SDK 0.22.3 forces manual approval before a decorated policy whenever
+    # defaults/order change during argument validation. A public FunctionTool
+    # policy inspects the raw task/names; invocation retains the decorator's
+    # complete argument validation and the body's second scope check.
+    return FunctionTool(name=decorated.name,description=decorated.description,
+                        params_json_schema=decorated.params_json_schema,
+                        strict_json_schema=decorated.strict_json_schema,
+                        on_invoke_tool=invoke,needs_approval=execution_needs_approval)
+
+
+TOOLS=[_execution_tool() if fn is execute_features else function_tool(fn,strict_mode=False) for fn in [describe_data,query_ontology,propose_features,execute_features,predict,explain,publish_results,show_view]]
 DEPLOYMENT_NOTES='''
 PUBLIC DATA ADAPTER (same responsibilities, different data source):
 Available tasks are churn (고객 이탈), stockout (재고 부족), defect (생산 불량); describe_data(task="all") lists actual downloaded workbook columns.
@@ -363,21 +547,92 @@ Pass requested columns or transformations to propose_features(requirements=...).
 These three public datasets are synthetic snapshots, NOT the internal rel-f1 database. There is no Superset MCP in this deployment; publish_results writes the actual result database and provides a report URL. Do not claim a Superset dashboard, production evaluation or official test split. predict supplies synthetic holdout AUROC and a constant baseline, with unknown target outcomes. Features have no physical units.
 When the user asks for a picture, diagram, chart, graph, distribution or schema, call show_view and add at most two sentences; never draw ASCII boxes, tables in code blocks or text diagrams. Never show tool names, function-call syntax or parameters to the user, and never describe a view or capability that show_view does not have; if nothing fits, say so plainly in Korean.
 For a prediction, keep the original seven-step workflow and execute_features approval pause. For questions or explanations, use data/ontology tools and answer directly without triggering a prediction. Name risk probabilities only from predict output. Explain input evidence and caveats using explain; predict output already includes top_evidence for the highest-risk row. Do not estimate probabilities yourself.
-Always finish the workflow with publish_results; the screen turns predict, explain and publish_results observations into cards (ranking, top probability, evidence, report link). After publishing, answer in two or three Korean sentences: what the top entities have in common and what to check next. Do not repeat the probability list or AUROC, do not print report URLs, and refer to inputs by their Korean column names, not c0..c3 or snake_case feature names.
+Always finish the workflow with publish_results; the screen turns predict, explain and publish_results observations into cards (ranking, top probability, evidence, report link). After publishing, answer in two or three Korean sentences using an observable fact from top_evidence and a cautious next check. Evidence is observed input, not feature importance or the reason for the probability. Never call inputs high or low just because predicted risk is high: use the supplied actual value and target rank/range, or omit the comparison. Only the highest-risk row has automatic evidence; do not claim other subjects share its values without querying their evidence. For arithmetic features, keep the actual expression's numerator and denominator. Program rationale is an unvalidated model proposal, not empirical evidence. Use the host's definitions and actual feature expression for arithmetic facts. Do not invent causal effects or model contributions. Read entity counts and distinctness from the tool results. Do not repeat the probability list or AUROC, do not print report URLs, and refer to inputs by their Korean column names, not c0..c3 or snake_case feature names.
 '''
 
 
+DEPLOYMENT_NOTES+='''
+표현 검증: 실제 execute_features 관측이 나오기 전에는 승인 완료나 실행 완료라고 말하지 마세요. 승인 카드를 기다리는 상태는 승인 대기입니다.
+현재 데이터에 없는 매출·실명·날짜·외래키·시간 이력 분석을 가능한 예시로 제안하지 마세요. 요청한 컬럼이 없으면 실제 컬럼을 안내하고 뜻을 확인하며, 조용히 다른 컬럼으로 바꾸거나 일부만 사용하는 것으로 단정하지 마세요.
+차트 설명은 실제 표시된 종류와 수치를 기준으로 하세요. 모든 구간을 비교하지 않고 단조 증가·감소라고 일반화하지 마세요. 합성 스냅샷 값에 입증되지 않은 물리적 의미나 인과 효과를 붙이지 마세요. 자연스러운 한국어만 사용하세요.
+'''
+
+
+def public_instructions():
+    """Use the original tool roles with the public adapter's metrics and style."""
+    adapted={
+        '4. predict':'4. predict → actual TabICL probabilities and synthetic holdout metrics from the tool; target outcomes are unknown.',
+        '5. explain':'5. explain → actual observed inputs and feature calculations for the requested target, without causal or importance claims.',
+        '6. publish_results':'6. publish_results → save the actual results and evidence and provide the report link to the screen. Always call this tool to complete a prediction.',
+        '7. Answer':'7. Answer in Korean. After prediction, use two or three concise sentences about observed input and a cautious next check. The screen already shows probability ranking, metrics and the report link; do not repeat them or output a URL. For column questions use the actual Korean names, never internal c0/c1/c2/c3 aliases.',
+    }
+    lines=['You are ONTIC, a data agent for the three published synthetic snapshot workbooks. The ontology constrains available tables and columns. You answer questions, synthesize feature programs and choose tools; the executor computes approved feature expressions and an anonymous matrix goes to TabICL for actual in-context numerical prediction. Do not train model weights or claim access to an internal relational customer database.'];ontology_shape=False;workflow=False
+    for line in SYSTEM_PROMPT.splitlines():
+        if not workflow:
+            if not line.startswith('Workflow for a prediction question:'):continue
+            workflow=True
+        if line.startswith('Superset tools ('):continue
+        if line.startswith('Ontology shape:'):
+            ontology_shape=True
+            lines.append('Public ontology: tables are owl:Class d:churn, d:stockout, d:defect with rdfs:label. Columns d:<task>.column0..column5 have rdfs:domain, rdfs:label, rdfs:range and ontic:sensitivity. No foreign keys, temporal relations, primaryKey, nullRate, distinct or Metric predicates are published. Use FILTER(?col = d:churn.column0) to restrict the row-key column.')
+            continue
+        if ontology_shape:
+            if not line.startswith('Write the `summary`'):continue
+            ontology_shape=False
+        lines.append(next((replacement for prefix,replacement in adapted.items() if line.startswith(prefix)),line))
+    return '\n'.join(lines)+'\n'+DEPLOYMENT_NOTES
+
+
+def live_public_instructions(ctx,agent):
+    """SDK resumes its stored agent; resolve current user scope on every call."""
+    return ctx.context.current_instructions()
+
+
 class PublicSession(SessionRuntime):
     steps=STEPS
     own_tools=set(STEPS)
     def __init__(self):
-        super().__init__();self.request_text='';self.proposals={};self.features={};self.runs={};self.touched=time.monotonic()
+        super().__init__();self.request_text='';self.proposals={};self.proposal_task=None;self.features={};self.runs={};self.touched=time.monotonic()
     def send(self,text):
         self.request_text=text
         return super().send(text)
+    def confirm(self,approve,reason=''):
+        if not approve and reason.strip():
+            self.request_text=reason
+            task=self.proposal_task
+            if task in self.proposals:
+                try:policy=column_policy(task,reason,self.proposals[task]['programs'])
+                except ValueError:
+                    reason+='\n[입력 범위 검증] 이전에 제안한 입력 중 허용된 입력이 남지 않았습니다. 새 입력을 확인하기 전에는 실행하지 마세요.'
+                else:
+                    if policy['allowed'] is not None:
+                        allowed=', '.join(columns(task)[c] for c in sorted(policy['allowed']))
+                        reason+='\n[입력 범위 검증] 현재 '+task+'에 허용된 입력은 '+allowed+'뿐입니다. 나머지는 직전 제안에서 제외 후 남은 입력이며 다른 데이터 컬럼을 새로 허용한 뜻이 아닙니다. 한 입력만 남으면 원값만 사용해도 됩니다.'
+        return super().confirm(approve,reason)
+    def pending(self):
+        actions=super().pending()
+        for action in actions:
+            if action['tool']=='execute_features':
+                task=action['args'].get('task');programs=_execution_programs(self,task,action['args'].get('names'))
+                action['programs']=programs;action['columns']=columns(task)
+        return actions
+    def current_instructions(self):
+        instructions=public_instructions()
+        task=self.proposal_task
+        if task in self.proposals:
+            # The same user boundary enforced by tools must also be visible to
+            # the deciding agent, before it rewrites a relative edit as a request.
+            try:policy=column_policy(task,self.request_text,self.proposals[task]['programs'])
+            except ValueError:
+                instructions+='\nCURRENT USER INPUT BOUNDARY: No requested inputs remain for '+task+'. Ask the user to choose inputs before proposing or executing.'
+            else:
+                if policy['allowed'] is not None:
+                    allowed=', '.join(columns(task)[c] for c in sorted(policy['allowed']))
+                    instructions+='\nCURRENT USER INPUT BOUNDARY for '+task+': '+allowed+' only. This comes from the latest user request and the previous proposal. Relative edits such as 나머지 retain the remaining previously proposed inputs; they do not authorize other dataset columns. Follow it when proposing or selecting programs. Choose whether to answer, propose or execute according to the user request; execution still requires fresh approval.'
+        return instructions
     def _agent(self,mcp_servers=()):
         base,key=credentials(self.id)
-        return Agent(name='ONTIC',instructions=SYSTEM_PROMPT+'\n'+DEPLOYMENT_NOTES,tools=TOOLS,model_settings=ModelSettings(parallel_tool_calls=False),model=OpenAIChatCompletionsModel(model=MODEL,openai_client=AsyncOpenAI(base_url=base,api_key=key,timeout=120,max_retries=0)))
+        return Agent(name='ONTIC',instructions=live_public_instructions,tools=TOOLS,model_settings=ModelSettings(temperature=0,parallel_tool_calls=False),model=OpenAIChatCompletionsModel(model=MODEL,openai_client=AsyncOpenAI(base_url=base,api_key=key,timeout=120,max_retries=0)))
 
 SESSIONS={}
 SESSIONS_LOCK=threading.Lock()
@@ -449,6 +704,34 @@ def report(run_id:str):
 
 local_router=APIRouter()
 
+
+def visible_answer(text):
+    """Remove Qwen's reasoning protocol from its final answer, before streaming."""
+    if not isinstance(text,str):return text
+    text=re.sub(r'<think\b[^>]*>.*?</think\s*>','',text,flags=re.I|re.S)
+    # Some OpenAI-compatible responses omit the opening tag but retain its close.
+    closes=list(re.finditer(r'</think\s*>',text,re.I))
+    if closes:text=text[closes[-1].end():]
+    text=re.split(r'<think\b[^>]*>',text,maxsplit=1,flags=re.I)[0]
+    return text.strip()
+
+
+def visible_completion(result):
+    """Keep final text and tool calls; reasoning never enters the public stream."""
+    choices=result.get('choices')
+    if not isinstance(choices,list) or not choices:raise ValueError('The model returned no completion choices')
+    out=dict(result);out['choices']=[]
+    for choice in choices:
+        if not isinstance(choice,dict) or not isinstance(choice.get('message'),dict):raise ValueError('The model returned no message')
+        message=dict(choice['message'])
+        for key in ('reasoning','reasoning_content','thinking'):message.pop(key,None)
+        if isinstance(message.get('content'),str):message['content']=visible_answer(message['content'])
+        if not message.get('content') and not message.get('tool_calls'):
+            raise ValueError('The model did not return a complete answer or tool call')
+        out['choices'].append(dict(choice,message=message))
+    return out
+
+
 @local_router.post('/local-llm/v1/chat/completions')
 async def local_completion(request:Request):
     if not request.client or request.client.host not in ('127.0.0.1','::1'):raise HTTPException(403,'Loopback only')
@@ -460,6 +743,9 @@ async def local_completion(request:Request):
     try:result=await asyncio.to_thread(dispatch,'llm',dict(data,model=MODEL,stream=False),strict=True)
     except GPUQwenUnavailable as exc:
         return JSONResponse({'error':{'message':str(exc),'type':'gpu_qwen_unavailable','code':'GPU_QWEN_UNAVAILABLE','reason':exc.reason}},status_code=503)
+    try:result=visible_completion(result)
+    except ValueError:
+        return JSONResponse({'error':{'message':'모델이 완성된 답변을 반환하지 못했습니다. 다시 시도해 주세요.','code':'INCOMPLETE_MODEL_OUTPUT'}},status_code=502)
     if not data.get('stream'):return result
     choice=result['choices'][0];message=choice['message'];delta=dict(message)
     if message.get('tool_calls'):delta['tool_calls']=[dict(t,index=i) for i,t in enumerate(message['tool_calls'])]

requirements.txt

@@ -5,10 +5,11 @@ tabicl[forecast]==2.2.0
 torch==2.14.0
 uvicorn==0.52.4
 
-openai-agents>=0.22,<0.23
-openai>=3,<4
+openai-agents==0.22.3
+openai==3.16.2
 duckdb>=1.5.5,<2
 pandas>=2.2,<3
 pyyaml>=6,<7
-rdflib>=7,<8
+rdflib==7.6.0
+pyparsing==3.3.3
 cryptography>=42,<49

web/agent-ui.js

@@ -11,6 +11,7 @@ export function agentSurface(id,event){
  else if(event.type==='approval'){
   const pending=event.actions?.[0];if(pending?.tool!=='execute_features')throw new Error('승인할 도구를 확인하지 못했습니다.');
   items=[text('title','이 기준으로 위험도를 계산할까요?','heading'),text('scope','학습 데이터 96행을 문맥으로 TabICL이 바로 계산합니다(모델 학습 없음). 빼거나 바꿀 기준은 채팅으로 알려 주세요.','muted'),{id:'actions',component:'Actions',buttons:[{id:'approve',label:'이대로 예측',primary:true,action:{event:{name:'approve_prediction'}}},{id:'edit',label:'기준 바꾸기',primary:false,action:{event:{name:'edit_question'}}}]}];
+  if(pending.programs?.length)items.splice(1,0,text('selected','실행할 기준: '+pending.programs.map(p=>korean(p.expr,pending.columns)).join(' · ')));
   model={selected_features:[0]};
  }else if(event.tool==='describe_data'){
   if(!Array.isArray(d.datasets))throw new Error('데이터 사전 응답이 올바르지 않습니다.');
@@ -29,18 +30,23 @@ export function agentSurface(id,event){
   items=[table('ontology','온톨로지 조회',keys,rows.map(r=>keys.map(k=>r[k]??'')))];
  }else if(event.tool==='propose_features'){
   if(!Array.isArray(d.programs))throw new Error('피처 제안 응답이 올바르지 않습니다.');
-  items=[text('label','예측에 쓸 기준','label'),text('programs',d.programs.map(p=>`- **${korean(p.expr,d.columns)}** — ${p.rationale}`).join('\n'))];
+  items=[text('label','예측에 쓸 기준','label'),text('programs',d.programs.map(p=>`- **${korean(p.expr,d.columns)}**${d.definitions?.[p.name]?` — ${d.definitions[p.name]}`:''}`).join('\n'))];
   if(d.rejected?.length)items.push(text('rejected',`질문과 맞지 않거나 검증을 통과하지 못한 제안 ${d.rejected.length}개는 뺐습니다.`,'muted'));
  }else if(event.tool==='execute_features')return [];
  else if(event.tool==='predict'){
   if(d.model?.output!=='real_inference'||!Array.isArray(d.predictions)||d.predictions.some(r=>!Number.isFinite(r.probability)||r.probability<0||r.probability>1))throw new Error('실제 예측 결과를 확인하지 못했습니다.');
   const ui=SCENARIO_UI[d.task]||{name:'예측',title:'위험 순위',next:''};const top=d.predictions[0];
-  const signals=(d.top_evidence?.features||[]).map(f=>({feature:korean(f.expr,d.columns),value:f.value}));
+  const inputs=d.top_evidence?.input_values||[];
+  const signals=[...inputs.map(v=>({feature:v.column,value:v.value})),...(d.top_evidence?.features||[]).filter(f=>!inputs.some(v=>f.expr===v.column_code)).map(f=>({feature:f.display_expr||korean(f.expr,d.columns),value:f.value}))];
   items=[text('label',`${ui.name} 예측 · 합성 데이터`,'label'),text('answer',`${top.subject}부터 확인하세요.`,'heading'),{id:'metric',component:'Metric',label:`${top.subject}의 예측 확률`,value:{path:'/top'}},{id:'ranking',component:'Ranking',title:ui.title,items:{path:'/predictions'}}];
   if(ui.next)items.push(text('next',ui.next,'callout'));
   items.push({id:'evidence',component:'Evidence',title:`근거와 모델 보기 · ${top.subject} 입력값`,features:{path:'/features'},signals:{path:'/signals'},model:{path:'/model'},timing:{path:'/timing'}});
   model={top:top.probability,predictions:d.predictions,features:d.programs.map(p=>korean(p.expr,d.columns)),signals,model:d.model,timing:`보류 검증 AUROC ${d.validation.auc.toFixed(3)} (상수 기준선 0.5) · 계산 ${d.seconds}초`};
- }else if(event.tool==='explain')items=[table('evidence',`${d.subject}의 입력값`,['기준','입력값'],(d.features||[]).map(f=>[korean(f.expr,{}),Number(f.value).toFixed(2)])),text('caveat','관측 입력값이며 인과관계나 변수 중요도를 뜻하지 않습니다.','muted')];
+ }else if(event.tool==='explain'){
+  items=[];
+  if(d.input_values?.length)items.push(table('source-inputs',`${d.subject}의 원본 입력`,['컬럼','입력값'],d.input_values.map(v=>[v.column,Number(v.value).toFixed(2)])));
+  items.push(table('evidence',`${d.subject}의 계산된 기준값`,['기준','계산값'],(d.features||[]).map(f=>[f.display_expr||korean(f.expr,d.columns),Number(f.value).toFixed(2)])),text('caveat','관측 입력값이며 인과관계나 변수 중요도를 뜻하지 않습니다.','muted'));
+ }
  else if(event.tool==='publish_results'){
   if(!/^\/demo#report=[0-9a-f]{32}$/.test(d.dashboard_url))throw new Error('결과 링크가 올바르지 않습니다.');
   items=[{id:'report',component:'ReportLink',label:'공유용 결과 페이지 열기 ↗',url:d.dashboard_url}];

web/demo-chat.js

@@ -13,14 +13,14 @@ function lock(busy){form.toggleAttribute('aria-busy',busy);form.querySelector('b
 function newChat(){generation++;active?.abort();active=null;sid=null;turns.forEach(t=>t.renderer.setLocked(true));turns.length=0;conversation.replaceChildren();$('#welcome').hidden=false;question.value='';history.replaceState(null,'','#start');show('start');lock(false);question.focus();announce('새 대화를 시작했습니다.');}
 $('#new-chat').onclick=newChat;$('#new-chat-mobile').onclick=newChat;
 function makeTurn(text){$('#welcome').hidden=true;show('start');const article=node('article','chat-turn');if(text)article.append(node('p','user-message',text));const label=node('div','assistant-label');label.append(node('b','','O'),node('span','','ONTIC'));const host=node('div','assistant-content');article.append(label,host);conversation.append(article);const turn={node:article,host,text,renderer:new A2UIRenderer(host,event=>action(turn,event)),pending:false,answer:null};turns.push(turn);article.scrollIntoView({behavior:'smooth',block:'start'});return turn;}
-function render(turn,event,id){const messages=agentSurface(id,event);messages.forEach(m=>turn.renderer.consume(m));}
+function render(turn,event,id){const messages=agentSurface(id,event);messages.forEach(m=>{if(m.createSurface&&turn.renderer.surfaces.has(id))return;turn.renderer.consume(m);});}
 function action(turn,event){if(active||turn!==turns.at(-1)||!turn.pending)return;
  if(event.action.name==='approve_prediction'){turn.pending=false;turn.renderer.setLocked(true);run({sid,approve:true},turn);}
  else{question.focus();question.placeholder='제외할 피처나 바꿀 조건을 알려 주세요';announce('바꿀 조건을 입력하면 에이전트가 제안을 수정합니다.');}
 }
 function failure(turn,err){const box=node('div','chat-error');box.setAttribute('role','alert');box.append(node('p','',err.message));if(err.request_id)box.append(node('p','fineprint',`요청 ID: ${err.request_id}`));turn.host.append(box);announce(err.message);}
 async function run(payload,turn){
- const mine=generation,controller=new AbortController();active=controller;turn.answer=null;lock(true);
+ const mine=generation,controller=new AbortController();active=controller;turn.answer=null;turn.proposalSurfaceId=null;lock(true);
  const statusId='agent-status-'+(++counter);surface(statusId,[{id:'root',component:'Column',children:['status']},{id:'status',component:'Text',tone:'status',text:'데이터와 대화 이력을 확인하고 있어요.'}],{}).forEach(m=>turn.renderer.consume(m));
  const status=text=>{if(turn.renderer.surfaces.has(statusId))turn.renderer.consume({version:'v0.9',updateComponents:{surfaceId:statusId,components:[{id:'root',component:'Column',children:['status']},{id:'status',component:'Text',tone:'status',text}]}});announce(text);};
  let timeout;const resetTimer=()=>{clearTimeout(timeout);timeout=setTimeout(()=>controller.abort(),150000);};resetTimer();let terminal=false;
@@ -34,9 +34,9 @@ async function run(payload,turn){
    else if(e.type==='action'){status(e.summary||'에이전트가 도구를 실행하고 있어요.');}
    else if(e.type==='observation'){
     if(e.data?.error){status('도구 응답을 확인하고 수정하고 있어요.');return;}
-    if(e.tool==='predict')turn.topRow=e.data?.predictions?.[0]?.row;
-    if(e.tool==='explain'&&e.data?.row===turn.topRow)return; // already inside the result card's evidence
-    const observationId='agent-tool-'+(++counter);render(turn,e,observationId);
+    if(e.tool==='predict'){turn.topRow=e.data?.predictions?.[0]?.row;turn.hasTopEvidence=Boolean(e.data?.top_evidence?.features?.length);}
+    if(e.tool==='explain'&&e.data?.row===turn.topRow&&turn.hasTopEvidence)return; // suppress only evidence actually present in the result card
+    const observationId=e.tool==='propose_features'?(turn.proposalSurfaceId??=( 'agent-proposal-'+(++counter))):'agent-tool-'+(++counter);render(turn,e,observationId);
     if(e.tool==='predict'){const n=turn.renderer.surfaces.get(observationId)?.node;if(n)window.scrollTo({top:n.getBoundingClientRect().top+scrollY-80,left:0,behavior:'smooth'});} // the answer, not the approval card, should be on screen
     if(['describe_data','query_ontology','explain'].includes(e.tool)){const rendered=turn.renderer.surfaces.get(observationId)?.node;if(rendered){const details=node('details','tool-observation');details.append(node('summary','',e.tool==='explain'?'입력 근거 보기':'조회한 데이터·컬럼 보기'));rendered.before(details);details.append(rendered);}}
    }else if(e.type==='token'){