@yunhozz/arc 0.2.2 → 0.2.4

package/lib/runtime/adapters/codex.mjs

@@ -1,6 +1,6 @@
 import {evaluate} from '../evaluate.mjs';
-import {evaluateCapability} from '../capabilities.mjs';
-import {registerAgentObservation} from '../identity.mjs';
+import {evaluateCapability,plannerHookContextStatus} from '../capabilities.mjs';
+import {recordPlannerAgentObservation} from '../identity.mjs';
 import {transactWorkflow, fingerprintRequest} from '../store.mjs';
 import {runGate} from '../gate.mjs';
 
@@ -12,6 +12,7 @@ const deny=reason=>({decision:'deny',reason,ruleIds:['runtime.codex'],proposedTr
  * describeTool must parse the complete tool invocation conservatively, and supply
  * semantic operation, paths and descriptor. No native provider is assumed here. */
 export function normalizeCodexEvent(input,context={}){
+ const status=plannerHookContextStatus({platform:'codex',input,context});if(status.missing.length)throw Error('Missing trusted hook inputs: '+status.missing.join(', '));
  if(!object(input)||input.hook_event_name!=='PreToolUse'||!text(input.session_id)||input.session_id!==context.sessionRef||!text(context.actorRef)||!text(context.taskId)||!text(context.requestId)||!text(input.tool_use_id)||input.tool_use_id!==context.toolUseId||!text(input.tool_name)||!object(input.tool_input)||!text(input.cwd))throw Error('Verified session identity and complete PreToolUse event required');
  const toolPath=['Agent','spawn_agent'].includes(input.tool_name)?'spawn_agent':input.tool_name;
  const coverage={...evaluateCapability({platform:'codex',toolPath,sessionRef:context.sessionRef}),enforcement:'hook-response-only',nativeVerified:false,startupTimeout:'unknown',existingSessionInput:'unsupported',specializedPaths:'unknown',hostedTools:'unsupported'};
@@ -34,12 +35,10 @@ export async function runCodexGate(input,context={}){
   // SubagentStart cannot prevent startup. Only a trusted provider can correlate
   // agent_id with a pending assignment; tool/event agent_type is not authority.
   try{
-   if(input.session_id===context.sessionRef&&text(input.agent_id)&&typeof context.observeAgent==='function'){
-    const observation=await context.observeAgent(structuredClone(input));
-    if(observation?.actorRef===input.agent_id&&observation.platform==='codex'){
-     const decision=registerAgentObservation(context.state,observation);
-     if(decision.decision==='allow'&&decision.proposedTransition&&typeof context.persistObservation==='function')await context.persistObservation(decision,observation);
-    }
+   if(input.session_id===context.sessionRef&&text(input.agent_id)&&text(context.statePath)){
+    let observation;try{if(typeof context.observeAgent==='function')observation=await context.observeAgent(structuredClone(input));}catch{}
+    const decision=await recordPlannerAgentObservation({statePath:context.statePath,expectedRevision:context.state?.revision,input,platform:'codex',sessionRef:context.sessionRef,observation});
+    if(decision.decision==='allow'&&decision.proposedTransition&&typeof context.persistObservation==='function')await context.persistObservation(decision,observation);
    }
   }catch{/* Observation failure never claims startup was blocked. */}
   return {};

package/lib/runtime/bootstrap.mjs

@@ -6,7 +6,7 @@ import {observeCooperativeTarget,validateObservedTarget,validateWorkflowId,workf
 import {saveDurableState} from './store.mjs';
 export const COOPERATIVE_RUNTIME_MODULES=Object.freeze([
  'cli.mjs','command.mjs','bootstrap.mjs','cooperative-schema.mjs','cooperative.mjs','evaluate.mjs',
- 'scope.mjs','store.mjs','git-evidence.mjs','assignment.mjs','verification.mjs','acceptance.mjs','external.mjs'
+ 'scope.mjs','store.mjs','git-evidence.mjs','assignment.mjs','verification.mjs','acceptance.mjs','external.mjs','schema.mjs','operations.mjs','gate.mjs','adapters/codex.mjs','adapters/claude.mjs','capabilities.mjs','identity.mjs','git-query.mjs'
 ]);
 export const cooperativeCoverage=()=>({enforcement:'cooperative',provenance:'operator-attested',nativeVerified:false});
 export function commandResult({workflowId,state,input,decision='allow',ruleId='cooperative.recorded',persisted=false,...extra}){
@@ -16,7 +16,7 @@ export async function cooperativeVersions(){
  const hash=bytes=>'sha256:'+crypto.createHash('sha256').update(bytes).digest('hex');
  let policy;try{policy=await fs.readFile(new URL('../policy/role-policy.json',import.meta.url));}catch(error){if(error.code!=='ENOENT')throw error;policy=await fs.readFile(new URL('./role-policy.json',import.meta.url));}
  const runtime=await Promise.all(COOPERATIVE_RUNTIME_MODULES.map(file=>fs.readFile(new URL(file,import.meta.url))));
- return {policy:'1',runtime:'cooperative-1',policyHash:hash(policy),runtimeHash:hash(Buffer.concat(runtime))};
+ return {policy:'1',runtime:'cooperative-4',policyHash:hash(policy),runtimeHash:hash(Buffer.concat(runtime))};
 }
 export async function initializeCooperativeWorkflow({cwd,workflowId,input,observe=observeCooperativeTarget,storage={}}){
  validateWorkflowId(workflowId);validateCooperativeCommand({command:'init',input});
@@ -28,6 +28,7 @@ export async function initializeCooperativeWorkflow({cwd,workflowId,input,observ
   lock=await fs.open(lockPath,'wx',0o600);await inspectPath(statePath,{missing:true});
   const state={schemaVersion:1,workflowKind:'cooperative',contractVersion:1,workflowId,revision:0,mode:'plan',coverage:cooperativeCoverage(),versions:await cooperativeVersions(),target,targetVersion:1,scopeVersion:0};
   for(const key of ['actors','selections','assignments','identities','leases','scopes','approvals','documents','tasks','requests','intents','results','checks','findings','acceptances','commits','audit','unresolved','records','targetHistory'])state[key]=[];
+  state.plannerLedger={version:1,stages:[]};
   state.actors.push({actor:input.actor,source:'operator-attested'});state.selections.push({...input.selection,actor:input.actor,source:'operator-attested',targetVersion:1});
   state.audit.push({command:'init',revision:0,source:'operator-attested',actor:input.actor});validateCooperativeState(state);
   await saveDurableState({statePath,state,create:true,storage});return commandResult({workflowId,state,input,persisted:true,ruleId:'cooperative.initialized'});

package/lib/runtime/capabilities.mjs

@@ -28,5 +28,17 @@ export function evaluateCapability({platform,toolPath,sessionRef,platformVersion
     declared:{source:'documentation',matcher:contracts[platform]?.[toolPath] ?? null},
     status:!known || observationOnly ? 'unsupported':'unknown',verifiedDeny:false,
     source:!known || observationOnly ? 'documentation':'unverified',
+    observation:observationOnly?'documented':toolPath==='followup_task'?'unknown':'not-verified',enforcement:observationOnly?'observation-only':'unverified',
     observedPaths:observed.toolPaths.filter(p=>p === toolPath)};
 }
+
+/** Raw event fields identify an invocation, not its approved role or semantics. */
+export function plannerHookContextStatus({platform,input,context={}}={}){
+ const text=v=>typeof v==='string'&&v.length>0,object=v=>v!==null&&typeof v==='object'&&!Array.isArray(v);
+ const fields={
+  'hook.hook_event_name':input?.hook_event_name==='PreToolUse','hook.session_id':text(input?.session_id),'hook.tool_use_id':text(input?.tool_use_id),'hook.tool_name':text(input?.tool_name),'hook.tool_input':object(input?.tool_input),'hook.cwd':text(input?.cwd),
+  'context.sessionRef':text(context.sessionRef),'context.actorRef':text(context.actorRef),'context.taskId':text(context.taskId),'context.requestId':text(context.requestId),'context.toolUseId':text(context.toolUseId),'context.statePath':text(context.statePath),'context.state':object(context.state),'context.policy':object(context.policy),'context.evidence':object(context.evidence),'context.describeTool':typeof context.describeTool==='function',
+ };
+ const missing=Object.keys(fields).filter(k=>!fields[k]);
+ return {platform,available:Object.keys(fields).filter(k=>fields[k]),missing,enforcement:missing.length?'unavailable':'hook-response-only',nativeVerified:false,source:'context-validation'};
+}

package/lib/runtime/cooperative-schema.mjs

@@ -1,6 +1,6 @@
 import {ROLES} from './operations.mjs';
 import {assertSecretFree} from './external.mjs';
-import {object,text} from './schema.mjs';
+import {object,text,validatePlannerLedger} from './schema.mjs';
 import {absolute,validateWorkflowId} from './scope.mjs';
 const fail=message=>{throw Error('Cooperative schema: '+message);};
 const hash=value=>typeof value==='string'&&/^sha256:[a-f0-9]{64}$/.test(value);
@@ -25,7 +25,7 @@ export function validateCooperativeCommand(command){
  if(name==='record'){
   fields(input.evidence,['kind','messageRef','data']);
   if(input.evidence?.data?.affectedTaskIds!==undefined&&(!Array.isArray(input.evidence.data.affectedTaskIds)||!input.evidence.data.affectedTaskIds.every(text)||new Set(input.evidence.data.affectedTaskIds).size!==input.evidence.data.affectedTaskIds.length))fail('affected task IDs');
-  if(!statement(input.evidence)||!['note','approval','external-approval','document','scope','check','finding','review','acceptance-evidence'].includes(input.evidence.kind))fail('evidence');
+  if(!statement(input.evidence)||!['note','approval','external-approval','document','scope','check','finding','review','acceptance-evidence','planner-stage','planner-evidence','planner-result','planner-review'].includes(input.evidence.kind))fail('evidence');
  }
  if(resultStatement){
   fields(input.result,['status','messageRef','data','notExecutedEvidence']);
@@ -51,5 +51,6 @@ export function validateCooperativeState(state){
  if(state.requests.some(r=>!text(r.requestId)||!hash(r.requestFingerprint)||!object(r.decision))||new Set(state.requests.map(r=>r.requestId)).size!==state.requests.length)fail('request replay');
  if(state.intents.some(i=>!text(i.requestId)||!['prepared','succeeded','failed','unknown','mismatch','cancelled'].includes(i.status)||!hash(i.fingerprint))||new Set(state.intents.map(i=>i.requestId)).size!==state.intents.length)fail('intents');
  if(state.results.some(r=>!text(r.requestId)||!['succeeded','failed','unknown','mismatch','cancelled'].includes(r.status)||r.source!=='operator-attested'||!object(r.data)))fail('results');
+ if(state.plannerLedger!==undefined){validatePlannerLedger(state.plannerLedger);if(state.plannerLedger.stages.some(stage=>stage.workflowId!==state.workflowId||!Array.isArray(stage.artifacts)))fail('Planner workflow binding or artifacts');}
  assertSecretFree(state);json(state);return state;
 }

package/lib/runtime/cooperative.mjs

@@ -4,6 +4,9 @@ import {evaluateCooperativeVerification,invalidateAffectedEvidence,readCooperati
 import {readAssignmentGitEvidence,readCooperativeCommitGitEvidence} from './git-evidence.mjs';
 import {recordCooperativeAssignmentResult} from './assignment.mjs';
 import fs from 'node:fs/promises';
+import {constants} from 'node:fs';
+import path from 'node:path';
+import {createHash} from 'node:crypto';
 import {validateCooperativeCommand,validateCooperativeState} from './cooperative-schema.mjs';
 import {observeCooperativeTarget,validateObservedTarget,validateWorkflowId,workflowStatePath,inspectPath,absolute,within} from './scope.mjs';
 import {fingerprintRequest,saveDurableState,applyCooperativeCommitTransition} from './store.mjs';
@@ -23,12 +26,14 @@ export async function runCooperativeCommand({cwd,workflowId,command,input,observ
   if(!sameCheckout(state.target,target))return result(undefined,{decision:'hold',ruleIds:['cooperative.target']});
   const changes=state.tasks.length?await readChanges({state}):undefined;
   const evaluation=evaluateCooperative({state,request:{command,input},evidence:{target,versions:await cooperativeVersions(),changes}});
-  const unresolved=state.unresolved.some(entry=>!entry.resolvedBy)||state.intents.some(i=>['prepared','unknown','mismatch'].includes(i.status)&&!(['check','review'].includes(i.operation)&&i.stale));
+  const unresolved=state.plannerLedger?.stages.some(s=>s.pending)||state.unresolved.some(entry=>!entry.resolvedBy)||state.intents.some(i=>['prepared','unknown','mismatch'].includes(i.status)&&!(['check','review'].includes(i.operation)&&i.stale));
   return {...result(state,evaluation.decision==='allow'&&unresolved?{decision:'hold',ruleIds:['cooperative.unresolved']}:evaluation,{persisted:true}),state,support:cooperativeSupport(),...(changes?{changeFingerprints:changes}:{})};
  }
- let lock;
+ let lock,plannerLock;
  try{
   lock=await fs.open(statePath+'.lock','wx',0o600);let state=await read();
+  const plannerWork=command==='prepare'&&input.operation==='planner-call'||command==='record'&&input.evidence.kind.startsWith('planner-');
+  if(plannerWork)plannerLock=await fs.open(path.join(target.gitCommonDir,'arc','planner.lock'),'wx',0o600);
   if(!sameCheckout(state.target,target))return result(state,{decision:'hold',ruleIds:['cooperative.target']});
   const requestFingerprint=fingerprintRequest({command,input});const prior=state.requests.find(r=>r.requestId===input.requestId);
   if(prior){if(prior.requestFingerprint!==requestFingerprint)throw Error('Request fingerprint conflict');return result(state,{decision:'hold',ruleIds:['cooperative.replay']},{replayed:true});}
@@ -45,9 +50,12 @@ export async function runCooperativeCommand({cwd,workflowId,command,input,observ
    try{git=await readCommitGit({target:currentTarget,...(commitIntent&&input.result?.data?.commit?{commit:input.result.data.commit}:{})});}catch(error){gitError=error.message;}
   }
   const changes=state.tasks.length?await readChanges({state}):undefined;
-  let decision=evaluateCooperative({state,request:{command,input},evidence:{target:currentTarget,versions,git,changes}});
+  const plannerArtifacts=plannerWork?await readPlannerArtifacts(state,command==='record'&&input.evidence.kind==='planner-evidence'?input.evidence:undefined):undefined;
+  const plannerHistory=command==='record'&&input.evidence.kind==='planner-stage'?await readPlannerHistory(state,statePath,input.evidence.data.document?.path):{};
+  let decision=evaluateCooperative({state,request:{command,input},evidence:{target:currentTarget,versions,git,changes,requestFingerprint,plannerArtifacts,...plannerHistory}});
   if(gitError)decision={decision:'hold',ruleIds:[input.operation==='assign-agent'?'cooperative.documents':'cooperative.git-evidence'],reason:gitError};
   if(command==='prepare'&&decision.decision==='allow'){
+   if(decision.proposedTransition?.plannerLedger)state.plannerLedger=decision.proposedTransition.plannerLedger;
    if(decision.proposedTransition?.intent)state.intents.push(decision.proposedTransition.intent);
    if(decision.proposedTransition?.acceptance){state.acceptances.push(decision.proposedTransition.acceptance);state.tasks.find(t=>t.id===input.taskId).status='accepted';}
   }
@@ -100,6 +108,15 @@ export async function runCooperativeCommand({cwd,workflowId,command,input,observ
     if(decision.decision==='allow'&&actualResult.status==='succeeded'&&intent.operation==='assign-agent')state.assignments.push({intentId:intent.requestId,taskId:intent.taskId,agentId:actualResult.data.agentId,status:'active',source:'operator-attested',identityVerified:false});
    }
    else state.unresolved.push({kind:'unmatched-result',requestId:input.intentId,revision:state.revision+1});
+  }else if(command==='record'&&input.evidence.kind.startsWith('planner-')){
+   if(decision.proposedTransition?.plannerLedger&&(decision.decision==='allow'||decision.proposedTransition.recordUncertainty)){
+    state.plannerLedger=decision.proposedTransition.plannerLedger;
+    state.records.push({...input.evidence,actor:input.actor,source:'operator-attested',requestId:input.requestId,revision:state.revision+1,scopeVersion:state.scopeVersion,targetVersion:state.targetVersion});
+    if(input.evidence.kind==='planner-result'){
+     const intent=state.intents.find(i=>i.operation==='planner-call'&&i.requestId===input.evidence.data.callRequestId);
+     if(intent)intent.status=input.evidence.data.status;
+    }
+   }
   }else if(command==='record'&&decision.decision==='allow'){
    const entry={...input.evidence,actor:input.actor,source:'operator-attested',requestId:input.requestId,revision:state.revision+1,scopeVersion:state.scopeVersion,targetVersion:state.targetVersion};
    if(entry.kind==='scope'){
@@ -132,5 +149,36 @@ export async function runCooperativeCommand({cwd,workflowId,command,input,observ
   state.requests.push({requestId:input.requestId,requestFingerprint,request:structuredClone({command,input}),decision:output});
   state.audit.push({command,requestId:input.requestId,revision:state.revision,decision:output.decision,ruleIds:output.ruleIds,source:'operator-attested',actor:input.actor,...(input.intentId?{intentId:input.intentId,resolution:state.results.at(-1)?.status}:{}),...(input.operation?{operation:input.operation}:{})});
   validateCooperativeState(state);await inspectPath(statePath);await saveDurableState({statePath,state,storage});return output;
- }finally{if(lock){await lock.close();await fs.unlink(statePath+'.lock');}}
+ }finally{if(plannerLock){await plannerLock.close();await fs.unlink(path.join(target.gitCommonDir,'arc','planner.lock'));}if(lock){await lock.close();await fs.unlink(statePath+'.lock');}}
+}
+
+async function readPlannerArtifacts(state,newRecord){
+ const entries=(state.plannerLedger?.stages??[]).flatMap(s=>(s.artifacts??[]).map(a=>({...a,stageId:s.id})));
+ if(newRecord)entries.push({...newRecord.data,ref:newRecord.messageRef});
+ return Promise.all(entries.map(async artifact=>{
+  try{
+   if(!absolute(artifact.path)||!within(state.target.realpath,artifact.path))throw Error('Artifact path escapes workspace');
+   await inspectPath(artifact.path);const handle=await fs.open(artifact.path,constants.O_RDONLY|constants.O_NOFOLLOW|constants.O_NONBLOCK);let bytes;
+   try{const before=await handle.stat();if(!before.isFile())throw Error('Artifact must be a regular file');bytes=await handle.readFile();const after=await handle.stat(),named=await fs.lstat(artifact.path);if(before.dev!==after.dev||before.ino!==after.ino||before.size!==after.size||before.mtimeMs!==after.mtimeMs||after.dev!==named.dev||after.ino!==named.ino)throw Error('Artifact changed while reading');}finally{await handle.close();}
+   await inspectPath(artifact.path);if(!within(state.target.realpath,await fs.realpath(artifact.path)))throw Error('Artifact realpath escapes workspace');
+   const hash='sha256:'+createHash('sha256').update(bytes).digest('hex');
+   if(artifact.hash&&artifact.hash!==hash||artifact.contentHash&&artifact.contentHash!==hash)throw Error('Artifact hash mismatch');
+   return {...artifact,hash,verification:{status:'verified',source:'local-bytes'}};
+  }catch(error){return {...artifact,verification:{status:'unverified',source:'local-bytes'},error:error.message};}
+ }));
+}
+async function readPlannerHistory(state,statePath,documentPath){
+ const plannerHistory=[];
+ try{
+  const root=path.dirname(path.dirname(statePath));await inspectPath(root,{directory:true});
+  for(const entry of await fs.readdir(root,{withFileTypes:true})){
+   if(entry.name===state.workflowId)continue;
+   if(!entry.isDirectory()||entry.isSymbolicLink())throw Error('Unsafe workflow history path');
+   const filename=path.join(root,entry.name,'state.json');await inspectPath(filename);const other=validateCooperativeState(JSON.parse(await fs.readFile(filename,'utf8')));
+   if(!sameCheckout(state.target,other.target))continue;
+   if(!other.plannerLedger&&other.documents.some(d=>d.path===documentPath||d.data?.path===documentPath))throw Error('Existing document history has no Planner ledger');
+   for(const stage of other.plannerLedger?.stages??[])plannerHistory.push({workflowId:other.workflowId,stage});
+  }
+  return {plannerHistory};
+ }catch(error){return {plannerHistory,plannerHistoryError:error.message};}
 }

package/lib/runtime/evaluate.mjs

@@ -15,7 +15,7 @@ import {prepareCooperativeAssignment} from './assignment.mjs';
  */
 import path from 'node:path';
 import {validateCooperativeState,validateCooperativeCommand} from './cooperative-schema.mjs';
-import {validateWorkflowState, validateRequest, validateEvidence} from './schema.mjs';
+import {validateWorkflowState, validateRequest, validateEvidence,validatePlannerStage} from './schema.mjs';
 import {ROLES, ROLE_OPERATIONS, GIT_OPERATIONS, EXTERNAL_OPERATIONS} from './operations.mjs';
 const same=(a,b)=>JSON.stringify(a)===JSON.stringify(b);
 const within=(base,file)=>{const relative=path.relative(base,file);return relative===''||(!relative.startsWith('..'+path.sep)&&relative!=='..'&&!path.isAbsolute(relative));};
@@ -82,7 +82,17 @@ export function evaluate(policy, state, request, evidence){
   if(d.checks&&(!Array.isArray(approval.scope.checks)||d.checks.some(c=>!approval.scope.checks.some(approved=>same(approved,c)))))return result('hold','runtime.assignment','delegated checks not approved',['delegated-checks']);
   if(d.temporary&&!same(d.temporary,approval.scope.temporary))return result('hold','runtime.assignment','delegated temporary scope not approved',['delegated-temporary-scope']);
   if(state.assignments.some(a=>a.assignmentId===request.requestId||a.correlationRef===d.correlationRef))return result('hold','runtime.identity','assignment correlation already registered',['new-assignment-correlation']);
-  const next=structuredClone(state);next.assignments.push({assignmentId:request.requestId,requestId:request.requestId,requestedBy:request.actorRef,status:'pending',actorRef:null,platform:request.platform,correlationRef:d.correlationRef,role:d.role,taskId:d.taskId,paths:[...d.paths],operations:[...d.operations],approvalRef:d.approvalRef,...(d.checks?{checks:structuredClone(d.checks)}:{}),...(d.temporary?{temporary:structuredClone(d.temporary)}:{})});
+  const next=structuredClone(state);
+  if(d.role==='planner'){
+   const stage=state.plannerLedger?.stages.find(s=>s.id===d.plannerCall?.stageId),proof=fact('planner-call');
+   const contract=stage&&{document:stage.document,inputVersion:stage.inputVersion,criteriaVersion:stage.criteriaVersion,scopeVersion:stage.scopeVersion};
+   if(!stage||stage.workflowId!==state.workflowId||stage.approvalRef!==approval.id||!same(approval.scope.plannerStage,contract)||!d.paths.includes(stage.document.path)||proof?.sourceRef!==correlation.sourceRef||!same({stageId:proof?.data.stageId,inputVersion:proof?.data.inputVersion,criteriaVersion:proof?.data.criteriaVersion,scopeVersion:proof?.data.scopeVersion},{stageId:stage.id,inputVersion:stage.inputVersion,criteriaVersion:stage.criteriaVersion,scopeVersion:stage.scopeVersion}))return result('hold','runtime.planner-call','Current approved Planner stage and provider evidence required',['planner-stage-ledger','planner-call-evidence']);
+   if(stage.document.kind==='plan'&&!state.documents.some(doc=>doc.kind==='spec'&&state.approvals.some(a=>a.id===doc.approvalRef&&a.contentHash===doc.contentHash&&evidence.provenance.some(p=>p.id===a.id&&p.messageRef===a.messageRef&&p.contentHash===doc.contentHash&&p.verification.sourceRef===a.messageRef))))return result('hold','runtime.planner-call','Approved spec prerequisite required',['approved-spec']);
+   const planner=evaluatePlannerCall({stage,request:{...d.plannerCall,requestId:request.requestId},evidence:{artifacts:proof.data.artifacts,semanticProvenance:'operator-attested'}});
+   if(planner.decision!=='allow')return planner;
+   next.plannerLedger.stages[next.plannerLedger.stages.findIndex(s=>s.id===stage.id)]=planner.proposedTransition;
+  }
+  next.assignments.push({assignmentId:request.requestId,requestId:request.requestId,requestedBy:request.actorRef,status:'pending',actorRef:null,platform:request.platform,correlationRef:d.correlationRef,role:d.role,taskId:d.taskId,paths:[...d.paths],operations:[...d.operations],approvalRef:d.approvalRef,...(d.role==='planner'?{plannerStageId:d.plannerCall.stageId}:{}),...(d.checks?{checks:structuredClone(d.checks)}:{}),...(d.temporary?{temporary:structuredClone(d.temporary)}:{})});
   try{validateWorkflowState(next);}catch{return result('hold','runtime.assignment','invalid pending assignment scope',['valid-assignment']);}
   return {...result('allow','runtime.assignment','pending assignment authorized; observed spawn result still required'),proposedTransition:next};
  }
@@ -119,6 +129,7 @@ export function evaluateCooperative({policy,state,request,evidence}={}){
  if(!same(evidence.versions,state.versions))return hold('cooperative.versions','Policy or runtime changed');
  if(request.input&&request.input.expectedRevision!==state.revision)return hold('cooperative.revision','Stale revision');
  if(request.command==='record'&&request.input.evidence.kind==='external-approval'&&request.input.actor.role!=='orchestrator')return hold('cooperative.external-approval','Orchestrator records explicit external approval');
+ if(request.command==='record'&&request.input.evidence.kind.startsWith('planner-')||request.command==='prepare'&&request.input.operation==='planner-call')return evaluateCooperativePlanner({state,request,evidence});
  if(request.command==='prepare'){
   if(unresolvedExternal(state))return hold('cooperative.external-unresolved','Investigate unresolved external effects before follow-up');
   if(EXTERNAL_ACTIONS.includes(request.input.operation))return evaluateCooperativeExternal({state,request:request.input,approvalEvidence:state.records.findLast(r=>r.kind==='external-approval'&&r.messageRef===request.input.arguments?.approvalRef)});
@@ -137,3 +148,105 @@ export function reconcileCooperativeResult({state,intent,result,observations}={}
  try{validateCooperativeState(state);}catch(error){return {...base,decision:'hold',ruleIds:['cooperative.schema'],reason:error.message};}
  return {...base,decision:'hold',ruleIds:[!intent?'cooperative.intent':result?.status==='unknown'?'cooperative.unknown':'cooperative.reconciliation'],requiredEvidence:[],nextActions:[],proposedTransition:null,reason:!intent?'No matching durable intent':'Recorded operator statement requires reconciliation; no execution authorized'};
 }
+
+/** Pure Planner decision. Artifact verification belongs to the trusted reader;
+ * semantic judgments retain their recorded source and never become native proof. */
+export function evaluatePlannerCall({stage,request,evidence}={}){
+ const base={expectedRevision:stage?.revision??0,proposedTransition:null,coverage:{enforcement:'decision-only',semanticProvenance:evidence?.semanticProvenance==='operator-attested'?'operator-attested':'unverified',nativeVerified:false}};
+ const result=(decision,reason,requiredEvidence=[])=>({...base,decision,ruleIds:['runtime.planner-call'],reason,requiredEvidence});
+ if(['format-only','re-expression-only','save-error-only','patch-error-only'].includes(request?.intent))return result('deny','Orchestrator handles non-progress delivery and formatting work');
+ try{validatePlannerStage(stage);}catch(error){return result('hold',error.message,['planner-stage-ledger']);}
+ if(!request||!['initial','correction','further'].includes(request.kind)||request.intent!=='substantive'||typeof request.requestId!=='string'||!request.requestId||request.stageId!==stage.id||!Array.isArray(request.criterionIds)||new Set(request.criterionIds).size!==request.criterionIds.length||!Array.isArray(request.evidenceRefs)||new Set(request.evidenceRefs).size!==request.evidenceRefs.length)return result('hold','Valid stage-bound Planner request required',['planner-request']);
+ if(stage.pending)return result('hold','Reconcile the pending Planner call before another request',['confirmed-planner-result']);
+ if(stage.calls.some(c=>c.requestId===request.requestId))return result('hold','Planner request already recorded',['new-request-id']);
+ const initial=stage.calls.find(c=>c.kind==='initial'),correction=stage.calls.find(c=>c.kind==='correction');
+ if(request.kind==='initial'&&stage.calls.length)return result('deny','Initial draft opportunity already used');
+ if(request.kind!=='initial'){
+  if(!initial||!['succeeded','failed'].includes(initial.status)||!stage.result||!['succeeded','failed'].includes(stage.result.status)||stage.result.requestId!==stage.calls.at(-1).requestId||!['succeeded','failed'].includes(stage.calls.at(-1).status))return result('hold','A confirmed prior result is required',['confirmed-planner-result']);
+  if(!stage.review?.full||stage.review.resultRef!==stage.result.ref||stage.review.criteriaVersion!==stage.criteriaVersion||request.reviewRef!==stage.review.ref||stage.review.source!=='operator-attested')return result('hold','A complete review of the recorded result is required',['consolidated-review']);
+  if(request.kind==='correction'&&correction)return result('deny','Consolidated correction opportunity already used');
+  if(request.kind==='further'&&!correction)return result('hold','Use the consolidated correction before further calls',['consolidated-correction']);
+ }
+ const used=new Set(stage.calls.flatMap(c=>c.evidenceHashes)),artifacts=request.evidenceRefs.map(ref=>evidence?.artifacts?.find(a=>a.ref===ref));
+ if(request.kind==='further'){
+  if(!request.criterionIds.length||request.criterionIds.some(id=>!stage.criteria.some(c=>c.id===id&&c.status==='open')))return result('deny','Concrete open criteria are required');
+  if(!request.evidenceRefs.length)return result('hold','Unresolved criteria alone are not new progress',['new-criterion-evidence']);
+ }
+ if(artifacts.some(a=>a&&a.stageId!==stage.id))return result('deny','Evidence belongs to another stage');
+ if(artifacts.some(a=>!a||!['input','progress','finding'].includes(a.purpose)||a.verification?.status!=='verified'||a.verification.source!=='local-bytes'||!/^sha256:[a-f0-9]{64}$/.test(a.hash??'')))return result('hold','Accessible locally verified input or progress bytes are required',['verified-artifact-bytes']);
+ if(request.kind==='further'){
+  if(artifacts.some(a=>used.has(a.hash)))return result('deny','Identical evidence bytes cannot authorize another call');
+  if(request.criterionIds.some(id=>!artifacts.some(a=>a.criterionIds?.includes(id))))return result('hold','Evidence must address every requested criterion',['criterion-evidence-link']);
+  if(artifacts.some(a=>!a.semantic||a.semantic.meaningful!==true||a.semantic.source!=='operator-attested'||!a.semantic.judgmentRef||a.semantic.targetHash!==a.hash))return result('hold','A hash-bound semantic judgment is required',['semantic-attestation']);
+ }
+ const next=structuredClone(stage),call={requestId:request.requestId,kind:request.kind,intent:request.intent,criterionIds:[...request.criterionIds],evidenceHashes:artifacts.map(a=>a.hash),evidenceRefs:[...request.evidenceRefs],reviewRef:request.reviewRef??null,status:'reserved',ordinal:stage.calls.length+1};
+ next.calls.push(call);next.pending=request.requestId;next.ready=false;
+ return {...result('allow','Planner call reserved; dispatch and result remain unverified'),proposedTransition:next};
+}
+
+/** Cooperative Planner records are attestations with separately observed bytes. */
+export function evaluateCooperativePlanner({state,request,evidence}={}){
+ const base={expectedRevision:state.revision,coverage:{enforcement:'cooperative',provenance:'operator-attested',nativeVerified:false},proposedTransition:null,requiredEvidence:[]};
+ const result=(decision,reason)=>({...base,decision,ruleIds:['cooperative.planner'],reason});
+ if(request.input.actor.role!=='orchestrator')return result('hold','Orchestrator records and prepares Planner work');
+ if(!state.plannerLedger)return result('hold','Existing workflow Planner history has no ledger; reconciliation required');
+ const ledger=structuredClone(state.plannerLedger),input=request.input,data=input.evidence?.data;
+ const stage=ledger.stages.find(s=>s.id===(data?.stageId??input.arguments?.stageId));
+ const observed=evidence.plannerArtifacts??[];
+ const artifact=ref=>observed.find(a=>a.ref===ref&&a.stageId===stage?.id&&a.verification?.status==='verified');
+ const transition=(s,reason,decision='allow',uncertainty=false)=>({...result(decision,reason),proposedTransition:{plannerLedger:ledger,...(s?{stageId:s.id}:{}),...(uncertainty?{recordUncertainty:true}:{})}});
+ if(request.command==='prepare'){
+  if(!stage)return result('hold','Planner stage ledger unavailable');
+  if(stage.workflowId!==state.workflowId||stage.scopeVersion!==state.scopeVersion||stage.targetVersion!==state.targetVersion)return result('hold','Planner stage contract version changed');
+  const d=evaluatePlannerCall({stage,request:{...input.arguments,requestId:input.requestId},evidence:{artifacts:observed,semanticProvenance:'operator-attested'}});
+  if(d.decision!=='allow')return {...d,coverage:base.coverage,expectedRevision:state.revision};
+  ledger.stages[ledger.stages.indexOf(stage)]=d.proposedTransition;
+  return {...transition(stage,d.reason),proposedTransition:{plannerLedger:ledger,intent:{requestId:input.requestId,operation:'planner-call',stageId:stage.id,taskId:input.taskId??null,status:'prepared',fingerprint:evidence.requestFingerprint,source:'operator-attested',identityVerified:false,target:structuredClone(state.target),kind:input.arguments.kind}}};
+ }
+ const kind=input.evidence.kind,ref=input.evidence.messageRef;
+ if(kind==='planner-stage'){
+  if(ledger.stages.some(s=>s.id===data.id))return result('deny','Planner stage ID already exists');
+  const contract={document:data.document,inputVersion:data.inputVersion,criteriaVersion:data.criteriaVersion,scopeVersion:data.scopeVersion};
+  const approval=state.records.find(r=>r.kind==='approval'&&r.messageRef===data.approvalRef&&r.source==='operator-attested'&&r.scopeVersion===state.scopeVersion&&r.targetVersion===state.targetVersion);
+  const approved=approval?.data?.plannerStage;
+  if(!approved||!same(contract.document,approved.document)||['inputVersion','criteriaVersion','scopeVersion'].some(k=>contract[k]!==approved[k])||contract.scopeVersion!==state.scopeVersion||!within(state.target.realpath,data.document?.path))return result('hold','Approved stage contract and current scope are required');
+  if(data.document.kind==='plan'&&!approval.data.prerequisiteRefs?.some(ref=>state.records.some(r=>r.kind==='approval'&&r.messageRef===ref&&r.data.kind==='spec'&&r.source==='operator-attested')))return result('hold','Approved spec prerequisite is required for plan drafting');
+  const previous=[...ledger.stages,...(evidence.plannerHistory??[]).map(h=>h.stage)].filter(s=>s.document.path===data.document.path&&s.document.kind===data.document.kind&&s.document.phase===data.document.phase);
+  if(evidence.plannerHistoryError)return result('hold','Planner history could not be verified: '+evidence.plannerHistoryError);
+  if(previous.length){
+   const prior=previous.find(s=>data.previousStageRef?.workflowId===s.workflowId&&data.previousStageRef?.stageId===s.id);
+   if(!prior||approved.newScope!==true||!same(approved.previousStageRef,data.previousStageRef)||data.inputVersion<=prior.inputVersion||data.approvalRef===prior.approvalRef)return result('hold','Existing stage history requires an approved scope transition and predecessor link');
+  }
+  const created={...structuredClone(data),workflowId:state.workflowId,targetVersion:state.targetVersion,targetIdentity:{realpath:state.target.realpath,gitCommonDir:state.target.gitCommonDir,gitDir:state.target.gitDir},calls:[],pending:null,result:null,review:null,artifacts:[],ready:false};
+  try{validatePlannerStage(created);}catch(error){return result('hold',error.message);}
+  ledger.stages.push(created);return transition(created,'Planner stage registered without resetting prior history');
+ }
+ if(!stage)return result('hold','Planner stage ledger unavailable');
+ if(stage.scopeVersion!==state.scopeVersion||stage.targetVersion!==state.targetVersion)return result('hold','Planner stage contract version changed');
+ if(kind==='planner-evidence'){
+  if(stage.artifacts.some(a=>a.ref===ref))return result('deny','Planner evidence reference already recorded');
+  const item=observed.find(a=>a.ref===ref&&a.stageId===stage.id);
+  if(!item||item.verification?.status!=='verified'||!['draft','self-review','input','progress','finding'].includes(data.purpose)||!Array.isArray(data.criterionIds)||data.criterionIds.some(id=>!stage.criteria.some(c=>c.id===id)))return result('hold','Accessible stage-bound artifact bytes and purpose required');
+  if(data.semantic&&(data.semantic.source!==undefined&&data.semantic.source!=='operator-attested'||typeof data.semantic.meaningful!=='boolean'||!data.semantic.judgmentRef||data.semantic.targetHash!==item.hash))return result('hold','Semantic attestation must bind the observed artifact hash');
+  stage.artifacts.push({...item,purpose:data.purpose,criterionIds:[...data.criterionIds],...(data.semantic?{semantic:{...data.semantic,source:'operator-attested'}}:{})});return transition(stage,'Artifact bytes recorded separately from semantic attestation');
+ }
+ if(kind==='planner-result'){
+  const call=stage.calls.find(c=>c.requestId===data.callRequestId);
+  if(!call||stage.pending!==call.requestId||!['reserved','unknown'].includes(call.status)||!['succeeded','failed','unknown'].includes(data.status))return result('hold','A pending Planner call and confirmed result identity are required');
+  if(data.status==='succeeded'&&(!artifact(data.artifactRef)||artifact(data.artifactRef).purpose!=='draft'||!artifact(data.selfReviewRef)||artifact(data.selfReviewRef).purpose!=='self-review'))return result('hold','Verified full draft and self-review artifacts are required');
+  call.status=data.status;call.resultRef=ref;stage.result={ref,requestId:call.requestId,status:data.status,artifactRef:data.artifactRef??null,selfReviewRef:data.selfReviewRef??null,source:'operator-attested'};stage.ready=false;
+  if(data.status!=='unknown')stage.pending=null;
+  return transition(stage,data.status==='unknown'?'Planner execution remains unknown':'Planner result statement recorded',data.status==='unknown'?'hold':'allow',data.status==='unknown');
+ }
+ if(kind==='planner-review'){
+  if(stage.pending||!stage.result||!['succeeded','failed'].includes(stage.result.status)||data.resultRef!==stage.result.ref||data.full!==true||typeof data.complete!=='boolean'||!Array.isArray(data.criteria)||data.criteria.length!==stage.criteria.length||new Set(data.criteria.map(c=>c.id)).size!==stage.criteria.length||data.criteria.some(c=>!stage.criteria.some(old=>old.id===c.id)||!['open','resolved'].includes(c.status)||!c.judgmentRef))return result('hold','Full review must bind the confirmed result and all criteria');
+  for(const old of stage.criteria)if(old.status==='resolved'&&data.criteria.find(c=>c.id===old.id).status==='open'){
+   const reassessment=data.reassessments?.find(r=>r.criterionId===old.id&&r.previousJudgmentRef===old.judgmentRef&&r.reasonRef),proof=artifact(reassessment?.newEvidenceRef);
+   if(!reassessment||!proof||!proof.criterionIds.includes(old.id)||!proof.semantic?.meaningful||stage.calls.some(c=>c.evidenceHashes.includes(proof.hash)))return result('hold','Resolved criteria require a new evidence-bound reassessment');
+  }
+  if(data.complete&&(data.criteria.some(c=>c.status!=='resolved')||!artifact(stage.result.artifactRef)||!artifact(stage.result.selfReviewRef)))return result('hold','Incomplete draft cannot become ready or accepted');
+  stage.criteria=structuredClone(data.criteria);stage.review={ref,resultRef:data.resultRef,criteriaVersion:stage.criteriaVersion,full:true,complete:data.complete,source:'operator-attested'};stage.ready=data.complete;
+  return transition(stage,'Semantic completeness and criterion judgments remain operator-attested');
+ }
+ return result('hold','Unsupported Planner record');
+}

package/lib/runtime/identity.mjs

@@ -1,5 +1,8 @@
 import {validateWorkflowState, text} from './schema.mjs';
 import {ROLES} from './operations.mjs';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import {fingerprintRequest,saveDurableState} from './store.mjs';
 const same=(a,b)=>JSON.stringify(a)===JSON.stringify(b);
 /** Observation is supplied by the trusted platform provider, never agent/tool arguments. */
 export function registerAgentObservation(state, observation){
@@ -25,3 +28,22 @@ export function registerAgentObservation(state, observation){
  validateWorkflowState(next);
  return {decision:'allow',reason:'matching observed spawn bound to pending assignment',state:next,proposedTransition:next};
 }
+
+/** A raw start is audit only; verified correlation may bind an existing assignment. */
+export async function recordPlannerAgentObservation({statePath,expectedRevision,input,platform,sessionRef,observation}={}){
+ if(!path.isAbsolute(statePath??'')||input?.hook_event_name!=='SubagentStart'||input.session_id!==sessionRef||!text(sessionRef)||!text(input.agent_id)||!['codex','claude'].includes(platform))throw Error('Trusted observation target and complete start required');
+ const parent=await fs.realpath(path.dirname(statePath));statePath=path.join(parent,path.basename(statePath));let lock;
+ try{
+  lock=await fs.open(statePath+'.lock','wx',0o600);const stat=await fs.lstat(statePath);if(!stat.isFile()||stat.isSymbolicLink())throw Error('Observation state must be regular file');
+  const state=validateWorkflowState(JSON.parse(await fs.readFile(statePath,'utf8'))),eventHash=fingerprintRequest({input,observation:observation??null});
+  if(state.plannerObservations?.some(o=>o.eventHash===eventHash))return {decision:'hold',reason:'Observation replay',proposedTransition:null,replayed:true};
+  const candidates=state.assignments.filter(a=>a.status==='pending'&&a.role==='planner');
+  let decision={decision:'hold',reason:'Raw event lacks verified assignment correlation',proposedTransition:null};
+  if(state.revision!==expectedRevision)decision.reason='Stale provider context cannot bind identity';
+  else if(observation?.actorRef===input.agent_id&&observation.platform===platform)decision=registerAgentObservation(state,observation);
+  const correlated=decision.decision==='allow'&&Boolean(decision.proposedTransition),next=correlated?decision.proposedTransition:structuredClone(state);
+  const entry={eventHash,event:'SubagentStart',source:correlated?'verified-provider':'hook-stdin',sessionRef,agentRef:input.agent_id,classification:correlated?'correlated':candidates.length?'uncorrelated':'unmatched',identityVerified:correlated,reason:decision.reason,stageCandidates:candidates.map(a=>({assignmentId:a.assignmentId,stageId:a.plannerStageId??null,requestId:a.requestId})),coverage:{enforcement:'observation-only',nativeVerified:false,prevention:false},deduplication:'content-hash-only'};
+  next.plannerObservations=[...(state.plannerObservations??[]),entry];next.revision=state.revision+1;next.audit.push({event:'SubagentStart',eventHash,revision:next.revision,classification:entry.classification,source:entry.source});validateWorkflowState(next);await saveDurableState({statePath,state:next});
+  return {...decision,proposedTransition:correlated?next:null,observation:entry,persisted:true};
+ }finally{if(lock){await lock.close();await fs.unlink(statePath+'.lock');}}
+}

package/lib/runtime/schema.mjs

@@ -59,6 +59,7 @@ export function validateWorkflowState(s){
  if(s.acceptances.some(a=>!object(a)||!text(a.taskId)||!text(a.actorRef)||!text(a.fingerprint)||!strings(a.criteria)||!strings(a.checkIds)||!strings(a.findingIds)))fail('acceptances');
  if(s.commits.some(c=>!object(c)||!text(c.purpose)||!text(c.taskId)||!text(c.expectedParent)||!text(c.expectedTree)))fail('commits');
  if(s.requests.some(r=>!object(r)||!text(r.requestId)||!hash(r.requestFingerprint)||!object(r.decision))||new Set(s.requests.map(r=>r.requestId)).size!==s.requests.length)fail('request replay');
+ if(s.plannerLedger!==undefined){validatePlannerLedger(s.plannerLedger);if(s.plannerLedger.stages.some(stage=>stage.workflowId!==s.workflowId))fail('Planner workflow binding');}
  return s;
 }
 export function validateRequest(r){
@@ -77,3 +78,21 @@ export function validateEvidence(e){
  }
  return e;
 }
+
+/** Shared stage shape. Missing ledgers remain valid legacy state, never fresh history. */
+export function validatePlannerStage(stage){
+ if(stage?.ready!==undefined&&typeof stage.ready!=='boolean')fail('Planner readiness type');
+ if(!object(stage)||!text(stage.id)||!text(stage.workflowId)||!object(stage.document)||!absolute(stage.document.path)||!['spec','plan'].includes(stage.document.kind)||!text(stage.document.phase)||!text(stage.approvalRef)||!Number.isSafeInteger(stage.inputVersion)||stage.inputVersion<1||!Number.isSafeInteger(stage.scopeVersion)||stage.scopeVersion<0||!Number.isSafeInteger(stage.criteriaVersion)||stage.criteriaVersion<1)fail('Planner stage identity');
+ if(!Array.isArray(stage.criteria)||!stage.criteria.length||!unique(stage.criteria,'id')||stage.criteria.some(c=>!['open','resolved'].includes(c.status)||!text(c.judgmentRef)))fail('Planner criteria');
+ if(!Array.isArray(stage.calls)||!unique(stage.calls,'requestId')||stage.calls.some(c=>!['initial','correction','further'].includes(c.kind)||!['reserved','unknown','succeeded','failed'].includes(c.status)||!Array.isArray(c.evidenceHashes)||c.evidenceHashes.some(h=>!hash(h)))||stage.calls.filter(c=>c.kind==='initial').length>1||stage.calls.filter(c=>c.kind==='correction').length>1)fail('Planner call history');
+ if(stage.pending!==null&&(!text(stage.pending)||!stage.calls.some(c=>c.requestId===stage.pending&&['reserved','unknown'].includes(c.status))))fail('Planner pending call');
+ const pending=stage.calls.filter(c=>['reserved','unknown'].includes(c.status));if(pending.length>1||pending.length!==(stage.pending===null?0:1))fail('Planner orphan reservation');
+ if(stage.artifacts!==undefined&&(!Array.isArray(stage.artifacts)||!unique(stage.artifacts,'ref')||stage.artifacts.some(a=>!absolute(a.path)||!hash(a.hash)||!Array.isArray(a.criterionIds)||!['draft','self-review','input','progress','finding'].includes(a.purpose)||a.verification?.status!=='verified'||a.verification.source!=='local-bytes'||a.semantic&&a.semantic.source!=='operator-attested')))fail('Planner artifact evidence');
+ if(stage.ready===true&&(stage.pending!==null||stage.criteria.some(c=>c.status!=='resolved')||stage.result?.status!=='succeeded'||stage.review?.complete!==true||stage.review?.full!==true||stage.review?.resultRef!==stage.result.ref||!stage.artifacts?.some(a=>a.ref===stage.result.artifactRef&&a.purpose==='draft')||!stage.artifacts?.some(a=>a.ref===stage.result.selfReviewRef&&a.purpose==='self-review')))fail('Planner incomplete readiness');
+ return stage;
+}
+export function validatePlannerLedger(ledger){
+ if(!object(ledger)||ledger.version!==1||!Array.isArray(ledger.stages)||!unique(ledger.stages,'id'))fail('Planner ledger');
+ for(const stage of ledger.stages)validatePlannerStage(stage);
+ return ledger;
+}

package/lib/tui/app.mjs

@@ -8,7 +8,7 @@ function goHome(){throw Object.assign(Error('Return home'),{code:'ARC_TUI_HOME'}
 function interrupted(){return Object.assign(Error('Session interrupted'),{code:'ARC_CANCELLED'});}
 export function createTuiInterface(session,{input,controller}={}){
  async function event(){const e=await session.nextEvent();if(e.name==='interrupt')throw interrupted();if(e.name==='eof')throw Object.assign(Error('Session closed'),{code:'ARC_TUI_EOF'});if(e.name==='error')throw e.error;return e;}
- async function menu(title,rows,{selected=0,info=[],separatorBefore,backRow=false,backLabel='back',wordmark=false}={}){
+ async function menu(title,rows,{selected=0,info=[],separatorBefore,backRow=false,backLabel='back',escapeBack=false,wordmark=false}={}){
   const actions=backRow?[...rows,'Back']:rows;
   selected=actions.length?Math.max(0,Math.min(selected,actions.length-1)):0;
   while(true){
@@ -17,7 +17,7 @@ export function createTuiInterface(session,{input,controller}={}){
    const capacity=Math.max(1,viewport.rows-(wordmark?6:1)-information.length-4),offset=Math.max(0,Math.min(displayIndex-capacity+1,display.length-capacity)),visible=display.slice(offset,offset+capacity);
    const screen={title,wordmark,rows:[...information,...visible],selected:actions.length?information.length+displayIndex-offset:undefined,hint:navigationHint('menu',{backLabel}),...(display.length>capacity?{position:(offset+1)+'-'+Math.min(offset+capacity,display.length)+'/'+display.length}:{})};
    const rendered=session.render(screen),e=await event();
-   if(e.name==='up'&&actions.length)selected=(selected+actions.length-1)%actions.length;else if(e.name==='down'&&actions.length)selected=(selected+1)%actions.length;else if(e.name==='escape'){if(backLabel==='exit')return null;goHome();}else if(e.name==='enter'&&actions.length&&rendered.selectionEnabled!==false)return backRow&&selected===rows.length?null:selected;
+   if(e.name==='up'&&actions.length)selected=(selected+actions.length-1)%actions.length;else if(e.name==='down'&&actions.length)selected=(selected+1)%actions.length;else if(e.name==='escape'){if(backLabel==='exit'||escapeBack)return null;goHome();}else if(e.name==='enter'&&actions.length&&rendered.selectionEnabled!==false)return backRow&&selected===rows.length?null:selected;
   }
  }
  async function text(title,initial=''){let value=initial,selected=2;while(true){const rendered=session.render({title,mode:'text',rows:[value,'','Save','Back',''],selected,hint:navigationHint('text')});const e=await event();if(e.name==='text'||e.name==='paste')value+=e.text;else if(e.name==='backspace')value=[...value].slice(0,-1).join('');else if(e.name==='up'||e.name==='down')selected=selected===2?3:2;else if(e.name==='escape')goHome();else if(e.name==='enter'&&rendered.selectionEnabled!==false)return selected===2?value:null;}}
@@ -32,7 +32,11 @@ export function createTuiInterface(session,{input,controller}={}){
  async function busy(action){session.render({title:'Working',mode:'busy',rows:['Operation in progress. Please wait.'],hint:navigationHint('busy')});session.setBusy(true);const wasFlowing=input?.readableFlowing;const onData=chunk=>{if(String(chunk).includes('\x03')||String(chunk).includes('\x04'))controller?.abort();};input?.on('data',onData);try{const result=await action();if(controller?.signal.aborted){if(typeof result?.code!=='number')throw interrupted();return{...result,code:130,interrupted:true};}return result;}finally{input?.removeListener('data',onData);if(wasFlowing!==true)input?.pause?.();session.setBusy(false);session.discardInput();}}
  return{menu,text,page,busy};
 }
-export function resultRows(result){return[...(result.messages??[]).map(s=>s.trim()),...[result.stdout,result.stderr].flatMap(text=>text?text.trimEnd().split(/\r?\n/):[]),...(result.results??[]).flatMap(item=>[`${item.platform??item.target?.platform??'Target'}: ${item.status}; rollback: ${item.rollback??'not needed'}`,...(item.residualPaths??[]).map(p=>'Residual path: '+p),...(item.error?['Error: '+item.error.message]:[])]),...(result.cli?['CLI: '+result.cli.status,...(result.cli.error?['CLI error: '+result.cli.error.message]:[])]:[]),...(result.error?['Error: '+result.error.message]:[]),'Exit code: '+result.code,...(result.code===0?['Open a new agent session to use changed harness settings.']:['Review the failed target and retry from the menu.']),...(result.exitSession?[(result.cli?'CLI removal':'CLI replacement')+' ended this session. Run arc again for further management.']:[])];}
+export function resultRows(result){
+ const clean=text=>text.replace(/; rollback: [^\r\n]*/g,''),label=platform=>({codex:'Codex',claude:'Claude'}[platform]??platform);
+ const removed=result.code===0&&['removed','absent'].includes(result.cli?.status);
+ return[...(result.messages??[]).map(s=>clean(s.trim())),...[result.stdout,result.stderr].flatMap(text=>text?text.trimEnd().split(/\r?\n/).map(clean):[]),...(result.results??[]).flatMap(item=>{const platform=item.platform??item.target?.platform??'Target';return[...(removed&&item.status==='uninstalled'?[]:[item.status==='installed'?`ARC installed for ${label(platform)}.`:item.status==='uninstalled'?`${label(platform)} ARC settings removed.`:`${platform}: ${item.status}`]),...(item.residualPaths??[]).map(p=>'Residual path: '+p),...(item.error?['Error: '+item.error.message]:[])];}),...(removed?[result.cli.status==='removed'?'ARC settings and CLI removed.':'ARC settings removed. CLI is not installed.']:result.cli?['CLI: '+result.cli.status,...(result.cli.error?['CLI error: '+result.cli.error.message]:[])]:[]),...(result.error?['Error: '+result.error.message]:[]),'Exit code: '+result.code,...(result.exitSession?[result.cli?'CLI removal ended this session.':'CLI replacement ended this session.']:[])];
+}
 export async function runTui(options={}){
  let session=options.session,code=0,finalReport;const controller=new AbortController(),signals=options.signals??process;const abort=()=>controller.abort();signals.on('SIGINT',abort);signals.on('SIGTERM',abort);
  try{session??=createTerminalSession(options);const ui=createTuiInterface(session,{input:options.input??process.stdin,controller}),api={collectStatus,prepareOperation,executeOperation,...options.services},context=options.context?{...options.context,signal:controller.signal}:await createManagementContext({...options.contextOptions,signal:controller.signal});const draft={};let selected=0;
@@ -42,11 +46,11 @@ export async function runTui(options={}){
    await ui.page('Result',resultRows(result));return false;
   }
   async function uninstall(){
-   let target=0,global=0;
-   while(true){const nextTarget=await ui.menu('Uninstall target',['Codex','Claude','Both targets'],{selected:target,backRow:true});if(nextTarget===null)return null;target=nextTarget;
-    while(true){const nextGlobal=await ui.menu('Global ARC instructions',['Remove ARC blocks','Preserve ARC blocks'],{selected:global,backRow:true});if(nextGlobal===null)break;global=nextGlobal;
-     return ui.busy(()=>api.prepareOperation(context,{kind:'uninstall',target:['codex','claude','all'][target],skipGlobal:global===1}));
-    }
+   let selected=0,target=0;
+   while(true){const choice=await ui.menu('Uninstall',['Settings','Remove CLI'],{selected,backRow:true});if(choice===null)return null;selected=choice;
+    if(choice===0){const next=await ui.menu('Uninstall settings',['Codex','Claude'],{selected:target,backRow:true});if(next===null)continue;target=next;return ui.busy(()=>api.prepareOperation(context,{kind:'uninstall',target:['codex','claude'][target],removeCli:false}));}
+    const proceed=await ui.menu('Remove CLI',['Continue','Back'],{selected:1,escapeBack:true,info:['Removes ARC settings for Codex and Claude, then removes the ARC CLI.','']});
+    if(proceed===0)return ui.busy(()=>api.prepareOperation(context,{kind:'uninstall',target:'all',removeCli:true}));
    }
   }
   while(true){const statuses=await api.collectStatus(context),ordered=[...statuses].sort((a,b)=>({claude:0,codex:1}[a.platform]??2)-({claude:0,codex:1}[b.platform]??2));

package/lib/tui/setup.mjs

@@ -2,21 +2,18 @@ const presetLabel=value=>({economy:'Economy',balanced:'Balanced',smart:'Smart'}[
 const languageLabel=value=>({en:'EN',ko:'KR'}[value]??value);
 import {parsePositiveLimit} from '../limits.mjs';
 export function initialSettings(statuses){return Object.fromEntries(['codex','claude'].map(platform=>{const settings=statuses.find(s=>s.platform===platform)?.settings;return[platform,{preset:settings?.modelConfig?.preset??'balanced',language:settings?.language??'en',maxTotalSubagents:settings?.limits?.max_total_subagents??100,maxConcurrentSubagents:settings?.limits?.max_concurrent_subagents??5,skipGlobal:false}];}));}
-export function setupOptions(draft,target){if(target==='all'&&JSON.stringify(draft.codex)!==JSON.stringify(draft.claude))throw Error('Target settings differ. Explicitly select common values before applying to both.');return{...draft[target==='all'?'codex':target],target};}
+export function setupOptions(draft,target){if(!['codex','claude'].includes(target))throw Object.assign(Error('Unsupported setup target'),{code:'ARC_CLI_INPUT'});return{...draft[target],target};}
 export async function runSetup({ui,statuses,draft,kind,prepare}){
  for(const[key,value]of Object.entries(initialSettings(statuses)))draft[key]??=value;
  let selectedTarget=0;
- while(true){const targetIndex=await ui.menu(kind==='preset'?'Change Preset':'Install / Update',['Codex','Claude','Both targets'],{selected:selectedTarget,backRow:true});if(targetIndex===null)return null;selectedTarget=targetIndex;const target=['codex','claude','all'][targetIndex];
-  if(target==='all'&&JSON.stringify(draft.codex)!==JSON.stringify(draft.claude)){
-   const choice=await ui.menu('Target settings differ',['Use Codex values for both','Use Claude values for both'],{backRow:true,info:['Codex: '+summary(draft.codex),'Claude: '+summary(draft.claude),'Choosing common values replaces the other target values.']});if(choice===null)continue;const source=choice===0?'codex':'claude';draft.codex={...draft[source]};draft.claude={...draft[source]};
-  }
-  const settings=draft[target==='all'?'codex':target];let editing=true,selectedField=kind==='preset'?1:0;
+ while(true){const targetIndex=await ui.menu(kind==='preset'?'Change Preset':'Install / Update',['Codex','Claude'],{selected:selectedTarget,backRow:true});if(targetIndex===null)return null;selectedTarget=targetIndex;const target=['codex','claude'][targetIndex];
+  const settings=draft[target];let editing=true,selectedField=0;
   while(editing){const labels=kind==='preset'?['Preset: '+presetLabel(settings.preset),'Apply','Back']:['Preset: '+presetLabel(settings.preset),'Harness language: '+languageLabel(settings.language),'Total subagents: '+settings.maxTotalSubagents,'Concurrent subagents: '+settings.maxConcurrentSubagents,'Apply global settings: '+!settings.skipGlobal,'Apply','Back'];const field=await ui.menu('Settings — '+target,labels,{selected:selectedField,separatorBefore:labels.length-2});if(field===null||field===labels.length-1)break;selectedField=field;
    if(field===0){const value=await ui.menu('Performance preset',['Economy','Balanced','Smart'],{backRow:true,selected:['economy','balanced','smart'].indexOf(settings.preset)});if(value!==null)settings.preset=['economy','balanced','smart'][value];if(kind==='preset')selectedField=1;}
    else if(kind==='install'&&field===1){const value=await ui.menu('Harness output language',['EN','KR'],{backRow:true,selected:settings.language==='ko'?1:0});if(value!==null)settings.language=['en','ko'][value];}
-   else if(kind==='install'&&(field===2||field===3)){const key=field===2?'maxTotalSubagents':'maxConcurrentSubagents';let raw=String(settings[key]);while(true){raw=await ui.text(field===2?'Maximum total subagents':'Maximum concurrent subagents',raw);if(raw===null)break;let value;try{value=parsePositiveLimit(raw);}catch{await ui.page('Invalid limit',['Enter a positive safe ASCII decimal integer.']);continue;}settings[key]=value;if(target==='all')draft.claude={...settings};break;}}
+   else if(kind==='install'&&(field===2||field===3)){const key=field===2?'maxTotalSubagents':'maxConcurrentSubagents';let raw=String(settings[key]);while(true){raw=await ui.text(field===2?'Maximum total subagents':'Maximum concurrent subagents',raw);if(raw===null)break;let value;try{value=parsePositiveLimit(raw);}catch{await ui.page('Invalid limit',['Enter a positive safe ASCII decimal integer.']);continue;}settings[key]=value;break;}}
    else if(kind==='install'&&field===4)settings.skipGlobal=!settings.skipGlobal;
-   else{if(target==='all')draft.claude={...settings};return prepare({kind,...setupOptions(draft,target)});}
+   else{return prepare({kind,...setupOptions(draft,target)});}
   }
  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yunhozz/arc",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"
@@ -27,7 +27,16 @@
   "files": [
     "bin/",
     "lib/",
-    "scripts/",
+    "scripts/build-native.mjs",
+    "scripts/check-installer-parity.mjs",
+    "scripts/pack-release.mjs",
+    "scripts/postinstall.mjs",
+    "scripts/update-manifest.mjs",
+    "scripts/update-role-policy.mjs",
+    "scripts/update-runtime-assets.mjs",
+    "scripts/update-superpowers.mjs",
+    "scripts/vendor-toml.mjs",
+    "scripts/verify-release.mjs",
     "vendor/",
     "prebuilds/",
     "native/binding.c",

package/scripts/update-manifest.mjs

@@ -1,28 +1,26 @@
-import {isDynamicReferencePath} from '../lib/installer/superpowers.mjs';
+import {renderManifest,LOCAL_UPDATER_PATH} from '../lib/installer/manifest.mjs';
 import fs from 'node:fs';
 import path from 'node:path';
-import crypto from 'node:crypto';
 import { fileURLToPath } from 'node:url';
 const i = process.argv.indexOf('--root');
 const root = i < 0 ? fileURLToPath(new URL('../', import.meta.url)) : path.resolve(process.argv[i + 1]);
 const mutable = new Set(['codex/skill/models.toml', 'claude/skill/models.toml']);
 const excluded = new Set(['.DS_Store', '__pycache__', 'build']);
-const files = new Set();
+const files = new Map();
 function visit(relative) {
-  if(isDynamicReferencePath(relative)) return;
   const filename = path.join(root, relative);
-  if (!fs.existsSync(filename)) return;
-  const stat = fs.lstatSync(filename);
+  let stat;try { stat = fs.lstatSync(filename); } catch (error) { if(error.code==='ENOENT')return;throw error; }
   if (stat.isSymbolicLink()) throw new Error(`Protected payload contains symlink: ${relative}`);
+  if(relative===LOCAL_UPDATER_PATH){if(!stat.isFile())throw new Error('Local updater wrapper must be a regular file');return;}
   if (stat.isDirectory()) {
     for (const name of fs.readdirSync(filename).sort()) if (!excluded.has(name)) visit(`${relative}/${name}`);
-  } else if (stat.isFile() && !mutable.has(relative)) files.add(relative);
+  } else if (stat.isFile() && !mutable.has(relative)) files.set(relative,fs.readFileSync(filename));
   else if (!stat.isFile()) throw new Error(`Protected payload is not regular: ${relative}`);
 }
 for (const entry of ['README.md', 'install.command', 'package.json', 'bin', 'lib', 'native/binding.c', 'native/binding.gyp', 'scripts', 'vendor', 'prebuilds', 'codex/skill', 'codex/agents', 'claude/skill', 'claude/agents']) visit(entry);
-const content = [...files].sort().map(name => `${crypto.createHash('sha256').update(fs.readFileSync(path.join(root, name))).digest('hex')}  ${name}\n`).join('');
+const content = renderManifest(files);
 const manifest = path.join(root, 'MANIFEST.sha256');
 if (process.argv.includes('--check')) {
-  if (!fs.existsSync(manifest) || fs.readFileSync(manifest, 'utf8') !== content) { console.error('Protected payload manifest is stale'); process.exitCode = 1; }
+  if (!fs.existsSync(manifest) || !fs.readFileSync(manifest).equals(content)) { console.error('Protected payload manifest is stale'); process.exitCode = 1; }
   else console.log(`Protected payload manifest verified (${files.size} files)`);
 } else { fs.writeFileSync(manifest, content); console.log(`Updated manifest (${files.size} files)`); }