@awak-app/simy-cli 0.7.45 → 0.7.47

package/src/codex-plugins/simy/hooks/measurement-store.mjs

@@ -0,0 +1,132 @@
+import { mkdir, readFile, readdir, link, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { acquireLock, atomicSave, readState } from './update-state-store.mjs';
+import { MEASUREMENT_VERSION, measurementDigest, validateMeasurementEvent } from './measurement-contract.mjs';
+import { measurementRepository } from './measurement-snapshot.mjs';
+
+const sessionDirectory = (root, provider, session) => join(root, 'measurement', measurementDigest([provider, session]));
+async function measurementLock(file) {
+  for (let attempt = 0; ; attempt++) {
+    try { return acquireLock(file); }
+    catch (error) { if (error.code !== 'state_busy' || attempt >= 30) throw error; await new Promise(resolve => setTimeout(resolve, 10)); }
+  }
+}
+export const measurementDirectory = (root, provider, session, trace) => {
+  const directory = sessionDirectory(root, provider, session);
+  const id = trace || readState(join(directory, 'active.json'))?.trace;
+  if (id && !/^[a-f0-9]{64}$/.test(id)) throw new Error('Invalid measurement trace.');
+  return id ? join(directory, id) : directory;
+};
+export const measurementPolicyPath = (root, provider, cwd) => join(root, 'measurement-policies', `${measurementDigest([provider, cwd])}.json`);
+export const measurementPolicyEnabled = (root, provider, cwd) => readState(measurementPolicyPath(root, provider, cwd))?.enabled === true;
+export const measurementRuntime = record => record.admission?.model ? measurementDigest({ provider: record.provider,
+  model: record.admission.model, source: record.admission.source || null,
+  permissionMode: record.updateObservation?.permissionMode || null }) : null;
+export async function enrollMeasurementFromPolicy({ root, previous, current }) {
+  if (!current) return;
+  const policy = readState(measurementPolicyPath(root, current.provider, current.cwd));
+  if (!policy?.enabled) return;
+  const task = current.run?.managed?.taskId || current.run?.id || `passive:${current.session}`;
+  if (!current.run && (policy.loop !== 'off' || await measurementBinding(root, current.provider, current.session))) return;
+  if (current.run && previous?.run?.id === current.run.id) return;
+  if (policy.loop === 'off' && current.autoContinue !== false || policy.loop === 'on' && current.autoContinue !== true) return;
+  const binding = await enrollMeasurement({ root, provider: current.provider, session: current.session, task,
+    source: policy.source, layer: policy.layer, loop: policy.loop, cohort: policy.cohort, scope: policy.scope,
+    late: !(['SessionStart', 'UserPromptSubmit'].includes(current.lastEvent) && (!current.run || current.observedAt === current.run.startedAt)),
+    repository: await measurementRepository(current.run?.executionCwd || current.cwd), runtime: measurementRuntime(current) });
+  if (policy.judge) await writeFile(join(measurementDirectory(root, current.provider, current.session, binding.trace), 'judge.json'), JSON.stringify(policy.judge), { flag: 'wx', mode: 0o600 });
+  return binding;
+}
+export async function measurementBinding(root, provider, session, trace) {
+  return readState(join(measurementDirectory(root, provider, session, trace), 'binding.json'));
+}
+export function measurementCollectionEnabled(root, provider, session, trace) {
+  return readState(join(measurementDirectory(root, provider, session, trace), 'collection.json'))?.enabled !== false;
+}
+export async function enrollMeasurement({ root, provider, session, task, source = 'field', layer = null, loop = 'on', cohort, late = true, scope = null, repository = null, runtime = null }) {
+  if (!['codex', 'claude'].includes(provider) || !session || !task || !['field', 'fixture'].includes(source) ||
+      ![null, 'N', 'S', 'F', 'W', 'X', 'B'].includes(layer) || !['on', 'off'].includes(loop) || !cohort) throw new Error('Explicit measurement identity and cohort required.');
+  // Enrollment and the active pointer form one session-scoped publication.
+  // Concurrent task updates cannot steal another trace's initial event.
+  const release = await measurementLock(join(sessionDirectory(root, provider, session), 'active.json'));
+  try {
+    const existing = await measurementBinding(root, provider, session);
+    if (existing?.task === measurementDigest(task)) throw new Error('Task measurement binding already exists.');
+    const trace = measurementDigest(randomUUID());
+    const directory = measurementDirectory(root, provider, session, trace);
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    const binding = { schemaVersion: 1, trace, provider, session: measurementDigest(session),
+      task: measurementDigest(task), source, layer, loop, cohort: measurementDigest(cohort), scope };
+    // Each task owns an immutable trace. Moving the active pointer retains every
+    // prior task and its complete journal in the same provider conversation.
+    const temporary = join(directory, `${randomUUID()}.tmp`);
+    await writeFile(temporary, JSON.stringify(binding), { flag: 'wx', mode: 0o600 });
+    try { await link(temporary, join(directory, 'binding.json')); }
+    finally { await rm(temporary, { force: true }); }
+    const collectorSources = await Promise.all(['contract', 'store', 'snapshot', 'judge', 'collector'].map(name => readFile(new URL(`./measurement-${name}.mjs`, import.meta.url), 'utf8')));
+    const collector = measurementDigest(collectorSources);
+    await appendMeasurement({ root, provider, session, trace, type: 'run_started', key: 'enrollment', data: { loop, cohort: binding.cohort, repository, runtime, collector } });
+    if (late) await appendMeasurement({ root, provider, session, trace, type: 'gap', key: 'late_enrollment', data: { reason: 'late_enrollment' } });
+    atomicSave(join(sessionDirectory(root, provider, session), 'active.json'), { schemaVersion: 1, trace });
+    return binding;
+  } finally { release(); }
+}
+export async function appendMeasurement({ root, provider, session, trace, type, key, data, at = Date.now() }) {
+  const binding = await measurementBinding(root, provider, session, trace);
+  if (!binding) return null;
+  if (typeof key !== 'string' || !key || key.length > 2000) throw new Error('Measurement source identity required.');
+  const directory = measurementDirectory(root, provider, session, binding.trace), manifest = join(directory, 'journal.json');
+  const release = await measurementLock(manifest);
+  try {
+    const journal = readState(manifest) || { schemaVersion: 1, sequence: 0 };
+    const source = measurementDigest([type, key]), eventFile = join(directory, `${source}.event.json`);
+    let saved;
+    try { saved = await readFile(eventFile, 'utf8'); } catch (error) { if (error.code !== 'ENOENT') throw error; }
+    if (saved) {
+      const event = validateMeasurementEvent(JSON.parse(saved));
+      if (JSON.stringify(event.data) !== JSON.stringify(data)) throw new Error('Measurement source changed; preserve the original event.');
+      return event;
+    }
+    const unsigned = { version: MEASUREMENT_VERSION, trace: binding.trace, provider, session: binding.session, task: binding.task,
+      sequence: journal.sequence + 1, source: binding.source, layer: binding.layer, type, at: new Date(at).toISOString(), data };
+    const event = validateMeasurementEvent({ ...unsigned, id: measurementDigest(unsigned) });
+    // Reserve the sequence durably BEFORE publishing: a crash is a visible gap,
+    // never two different observations occupying one sequence number.
+    atomicSave(manifest, { schemaVersion: 1, sequence: event.sequence });
+    atomicSave(eventFile, event);
+    return event;
+  } finally { release(); }
+}
+export async function readMeasurements({ root, provider, session, trace }) {
+  const directory = measurementDirectory(root, provider, session, trace);
+  const binding = await measurementBinding(root, provider, session, trace);
+  let names; try { names = await readdir(directory); } catch (error) { if (error.code === 'ENOENT') return []; throw error; }
+  const events = [];
+  for (const name of names.filter(name => /^[a-f0-9]{64}\.event\.json$/.test(name))) {
+    const event = validateMeasurementEvent(JSON.parse(await readFile(join(directory, name), 'utf8')));
+    if (!binding || event.trace !== binding.trace || event.task !== binding.task || event.session !== binding.session || event.provider !== binding.provider || event.source !== binding.source || event.layer !== binding.layer) throw new Error('Measurement event belongs to another trace.');
+    events.push(event);
+  }
+  return events.sort((left, right) => left.sequence - right.sequence);
+}
+export async function measurementEventForSource({ root, provider, session, trace, type, key }) {
+  const file = join(measurementDirectory(root, provider, session, trace), `${measurementDigest([type, key])}.event.json`);
+  try { return validateMeasurementEvent(JSON.parse(await readFile(file, 'utf8'))); }
+  catch (error) { if (error.code === 'ENOENT') return null; throw error; }
+}
+export async function listMeasurementTraces({ root, provider, session }) {
+  let names; try { names = await readdir(sessionDirectory(root, provider, session)); } catch (error) { if (error.code === 'ENOENT') return []; throw error; }
+  return names.filter(name => /^[a-f0-9]{64}$/.test(name));
+}
+export async function retainMeasurementArtifact(file, value) {
+  const temporary = `${file}.${randomUUID()}.publish`;
+  atomicSave(temporary, value);
+  try {
+    try { await link(temporary, file); }
+    catch (error) {
+      if (error.code !== 'EEXIST') throw error;
+      if (JSON.stringify(JSON.parse(await readFile(file, 'utf8'))) !== JSON.stringify(value)) throw new Error('Measurement artifact content conflict.');
+    }
+  } finally { await rm(temporary, { force: true }); }
+}

package/src/codex-plugins/simy/native/app-tools.mjs

@@ -0,0 +1,45 @@
+import {spawn} from 'node:child_process';
+import {createInterface} from 'node:readline';
+const fail=code=>Object.assign(new Error(code),{code});
+export async function openAppTools({record,signal,node,server,pipe}) {
+ const p=spawn(node,[server],{env:{...process.env,CODEX_APP_TOOLS_PIPE_PATH:pipe},stdio:['pipe','pipe','ignore']});
+ let sequence=0,closed=false;const pending=new Map();const lines=createInterface({input:p.stdout});
+ const close=()=>{if(closed)return;closed=true;signal?.removeEventListener('abort',close);for(const q of pending.values())q.reject(fail(q.write?'native_submission_unknown':'native_tools_closed'));pending.clear();lines.close();p.stdin.end();p.kill('SIGTERM');};
+ p.on('error',close);p.on('exit',close);p.stdin.on('error',close);signal?.addEventListener('abort',close,{once:true});
+ lines.on('line',line=>{let d;try{d=JSON.parse(line);}catch{close();return;}const q=pending.get(d.id);if(!q)return;pending.delete(d.id);d.error?q.reject(fail(q.write?'native_submission_unknown':'native_tools_request_failed')):q.resolve(d.result);});
+ const rpc=(method,params,write=false)=>new Promise((resolve,reject)=>{
+  if(closed||signal?.aborted){reject(fail('native_tools_closed'));return;}const id=++sequence;
+  const timer=setTimeout(()=>{pending.delete(id);reject(fail(write?'native_submission_unknown':'native_tools_timeout'));},15000);
+  pending.set(id,{write,resolve:r=>{clearTimeout(timer);resolve(r)},reject:e=>{clearTimeout(timer);reject(e)}});
+  p.stdin.write(JSON.stringify({jsonrpc:'2.0',id,method,params})+'\n');
+ });
+ try{
+  await rpc('initialize',{protocolVersion:'2025-06-18',capabilities:{},clientInfo:{name:'simy-original-continuation',version:'1.0.0'}});
+  p.stdin.write(JSON.stringify({jsonrpc:'2.0',method:'notifications/initialized'})+'\n');
+  const list=await rpc('tools/list',{});const names=new Set(list.tools.map(t=>t.name));
+  if(!names.has('read_thread')||!names.has('send_message_to_thread'))throw fail('native_tools_unsupported');
+  const call=async(name,args,write=false)=>{
+   const result=await rpc('tools/call',{name,arguments:args,_meta:{'openai/threadId':record.session}},write);
+   if(result.isError)throw fail(write?'native_submission_unknown':result.content?.some(c=>c.type==='text'&&c.text.includes('exceeds the size limit'))?'native_tools_response_too_large':'native_tools_request_failed');
+   const text=result.content?.find(c=>c.type==='text')?.text;if(!text)throw fail(write?'native_submission_unknown':'native_tools_invalid_response');
+   return JSON.parse(text);
+  };
+  const read=async(cursor,includeOutputs=false)=>{
+   const r=await call('read_thread',{threadId:record.session,hostId:'local',turnLimit:1,includeOutputs,maxOutputCharsPerItem:16000,...(cursor?{cursor}:{})});
+   if(r.thread?.id!==record.session||r.thread?.hostId!=='local'||r.thread?.cwd!==record.cwd)throw fail('native_tools_owner_mismatch');return r;
+  };
+  return {transport:'codex_app_tools',close,
+   async request(method,params){
+    if(params.threadId!==record.session)throw fail('native_tools_target_mismatch');
+    const r=await read(params.cursor,method==='thread/turns/list');
+    if(method==='thread/read')return {thread:{...r.thread,status:{type:r.thread.status?.type==='active'?'active':r.thread.status?.type==='idle'?'idle':'unknown'}}};
+    if(method==='thread/turns/list')return {data:r.turns,nextCursor:r.page?.nextCursor};
+    throw fail('native_method_unsupported');
+   },
+   async submitOriginal({text,beforeSubmit}){
+    const r=await read();if(r.thread.status?.type!=='idle')throw fail('native_thread_busy');
+    await beforeSubmit();signal?.throwIfAborted();
+    return call('send_message_to_thread',{threadId:record.session,hostId:'local',prompt:text},true);
+   }};
+ }catch(e){close();throw e;}
+}

package/src/codex-plugins/simy/native/bridge.mjs

@@ -0,0 +1,156 @@
+import {assertGuidanceIntent, guidancePending} from './guidance-intent.mjs';
+import {createServer, createConnection} from 'node:net';
+import {mkdir, stat, readFile, writeFile, rename, chmod, rm, readdir} from 'node:fs/promises';
+import {join} from 'node:path';
+import {randomUUID, createHash} from 'node:crypto';
+import {readRecord, updateRecord, automaticContinuationAllowed, hasPendingUserStop, managedBudgetReason} from '../hooks/delivery-loop.mjs';
+import {openAppTools} from './app-tools.mjs';
+
+const fail = code => Object.assign(new Error(code), {code});
+export const nativeIntentId = r => createHash('sha256').update(JSON.stringify([r.run.id, r.autoContinueEpoch, r.run.controlRevision, r.run.revision, r.run.managed.decision?.id])).digest('hex');
+const directory = root => join(root, 'native-app-bridge');
+// This is an app-launched transport, never a supervisor or a new task owner.
+// Every write requires an already persisted, exact original-task send intent.
+export async function startNativeBridge({root, node, server, pipe, openClient = openAppTools}) {
+  const pipeStat = await stat(pipe);
+  if (!pipeStat.isSocket() || pipeStat.uid !== process.getuid()) throw fail('native_tools_owner_mismatch');
+  const dir = directory(root), id = randomUUID(), token = randomUUID();
+  await mkdir(dir, {recursive: true, mode: 0o700});
+  const socket = join(dir, id + '.sock'), peers = new Set();
+  const listener = createServer(peer => {
+    peers.add(peer); peer.setEncoding('utf8'); peer.setTimeout(60000, () => peer.destroy());
+    let buffer = '', busy = false, authorizationReply = null;
+    peer.on('error', () => {}); peer.on('close', () => peers.delete(peer));
+    peer.on('data', chunk => {
+      buffer += chunk;
+      if (buffer.length > 1024 * 1024) {peer.destroy(); return;}
+      const end = buffer.indexOf('\n'); if (end < 0) return;
+      if (buffer.indexOf('\n', end + 1) !== -1) {peer.destroy(); return;}
+      const line = buffer.slice(0, end); buffer = buffer.slice(end + 1);
+      if (busy) {if (authorizationReply) authorizationReply(line); else peer.destroy(); return;}
+      busy = true;
+      void (async () => {
+        let client;
+        try {
+          const q = JSON.parse(line);
+          if (q.token !== token || !['thread/read', 'thread/turns/list', 'submit', 'submit_guidance'].includes(q.method)) throw fail('native_tools_bridge_denied');
+          // Old hosts cannot answer the final controller challenge. Fail closed
+          // rather than silently accepting their earlier authorization.
+          if (q.method === 'submit_guidance' && q.guidanceAuthorization !== 1) throw fail('native_guidance_unavailable');
+          const authorizeGuidance = () => new Promise((resolve, reject) => {
+            const challenge = randomUUID();
+            const finish = error => {
+              clearTimeout(timer); authorizationReply = null; peer.removeListener('close', lost);
+              error ? reject(error) : resolve();
+            };
+            const lost = () => finish(fail('native_guidance_changed'));
+            const timer = setTimeout(lost, 15000);
+            peer.once('close', lost);
+            authorizationReply = line => {
+              try {
+                const ack = JSON.parse(line);
+                if (ack.token !== token || ack.method !== 'authorize_guidance' || ack.challenge !== challenge ||
+                    ack.guidanceId !== q.guidanceId || ack.authorized !== true) throw fail('native_guidance_changed');
+                finish();
+              } catch {finish(fail('native_guidance_changed'));}
+            };
+            if (peer.destroyed) {lost(); return;}
+            peer.write(JSON.stringify({kind: 'guidance_authorization_required', guidanceId: q.guidanceId, challenge}) + '\n');
+          });
+          const r = await readRecord(join(root, 'delivery-hooks'), 'codex', q.session);
+          if (!r?.run?.managed || r.run.id !== q.runId || r.run.managed.taskId !== q.taskId || r.autoContinueEpoch !== q.epoch || !(q.guidanceId ? guidancePending(r) && r.run.managed.userGuidance.id === q.guidanceId : automaticContinuationAllowed(r))) throw fail('native_tools_attachment_changed');
+          client = await openClient({record: r, node, server, pipe});
+          const result = q.method === 'submit_guidance' ? await client.submitOriginal({text: q.text, beforeSubmit: async () => {
+            await updateRecord(join(root, 'delivery-hooks'), 'codex', q.session, async fresh => {
+              const intent = assertGuidanceIntent(fresh, q.guidanceId, q.text);
+              if (intent.phase !== 'submitting' || intent.bridgeAttemptedAt || hasPendingUserStop(join(root, 'delivery-hooks'), fresh) || managedBudgetReason(fresh.run)) throw fail('native_guidance_changed');
+              // Hold the exact intent lock while asking its original controller
+              // to recheck account/org/provider authority at the provider boundary.
+              await authorizeGuidance();
+              assertGuidanceIntent(fresh, q.guidanceId, q.text);
+              if (peer.destroyed || hasPendingUserStop(join(root, 'delivery-hooks'), fresh) || managedBudgetReason(fresh.run)) throw fail('native_guidance_changed');
+              intent.bridgeAttemptedAt = Date.now();
+              return fresh;
+            });
+          }}) : q.method === 'submit' ? await client.submitOriginal({text: q.text, beforeSubmit: async () => {
+            const fresh = await readRecord(join(root, 'delivery-hooks'), 'codex', q.session), m = fresh?.run?.managed, h = m?.nativeHandoff;
+            if (fresh?.run?.id !== q.runId || m?.taskId !== q.taskId || fresh.autoContinueEpoch !== q.epoch || !automaticContinuationAllowed(fresh) || hasPendingUserStop(join(root, 'delivery-hooks'), fresh) || fresh.run.stopReason || fresh.run.state !== 'recovery_required' || m.pendingApproval || m.resumeLease || m.liveWorkspaceLease || m.outcomeAudit?.lease || m.providerWarning || m.usageBlocked || m.maxTokens || m.understandingQuestion || m.purpose?.nativeBoundary || managedBudgetReason(fresh.run) || ['verifying', 'understanding', 'needs_clarification', 'action_association'].includes(m.phase) || m.executionUncertain || m.nativeWait || m.userQuestion || m.authenticationWait || m.dependencyWait || h?.id !== q.handoffId || h?.id !== nativeIntentId(fresh) || h.phase !== 'submitting' || h.text !== q.text) throw fail('native_tools_intent_changed');
+          }}) : await client.request(q.method, {threadId: q.session, cursor: q.cursor});
+          peer.end(JSON.stringify({ok: true, result, guidanceAuthorization: 1}) + '\n');
+        } catch (error) {peer.end(JSON.stringify({ok: false, code: error.code || 'native_tools_request_failed'}) + '\n');}
+        finally {client?.close();}
+      })();
+    });
+  });
+  await new Promise((resolve, reject) => {listener.once('error', reject); listener.listen(socket, resolve);});
+  await chmod(socket, 0o600);
+  const target = join(dir, id + '.json'), temp = target + '.tmp';
+  await writeFile(temp, JSON.stringify({schema: 1, id, pid: process.pid, socket, token, startedAt: Date.now()}), {mode: 0o600});
+  await rename(temp, target);
+  return {id, async close() {
+    for (const peer of peers) peer.destroy();
+    await new Promise(resolve => listener.close(resolve));
+    await rm(socket, {force: true});
+    try {if (JSON.parse(await readFile(target, 'utf8')).id === id) await rm(target);} catch (e) {if (e.code !== 'ENOENT') throw e;}
+  }};
+}
+
+export async function openNativeBridge(options) {
+  let names;
+  try {names = (await readdir(directory(options.root))).filter(n => /^[0-9a-f-]{36}\.json$/.test(n)).sort();}
+  catch (e) {if (e.code === 'ENOENT') return null; throw e;}
+  if (!names.length) return null;
+  for (const name of names) {
+    let client;
+    try {
+      const a = JSON.parse(await readFile(join(directory(options.root), name), 'utf8'));
+      client = await openBridgeInstance(options, a);
+      await client.request('thread/read', {threadId: options.record.session});
+      return client;
+    } catch (e) {client?.close(); if (options.signal?.aborted) throw e;}
+  }
+  throw fail('native_tools_bridge_unavailable');
+}
+async function openBridgeInstance({root, record, signal, guidanceId: optionsGuidanceId}, a) {
+  if (a.schema !== 1 || typeof a.token !== 'string' || a.socket !== join(directory(root), a.id + '.sock')) throw fail('native_tools_bridge_invalid');
+  const s = await stat(a.socket).catch(() => {throw fail('native_tools_bridge_unavailable');});
+  if (!s.isSocket() || s.uid !== process.getuid() || (s.mode & 0o077)) throw fail('native_tools_owner_mismatch');
+  const peers = new Set(); let closed = false, guidanceAuthorization = false;
+  const call = (method, extra = {}, authorizeGuidance) => new Promise((resolve, reject) => {
+    if (closed || signal?.aborted) {reject(fail('native_tools_closed')); return;}
+    const peer = createConnection(a.socket); peers.add(peer); let buffer = '', sent = false, settled = false, challenged = false;
+    const finish = (error, result) => {if (settled) return; settled = true; clearTimeout(timer); peers.delete(peer); peer.destroy(); error ? reject(error) : resolve(result);};
+    const lost = () => finish(fail(sent && ['submit', 'submit_guidance'].includes(method) ? 'native_submission_unknown' : 'native_tools_bridge_unavailable'));
+    const timer = setTimeout(lost, 45000);
+    peer.setEncoding('utf8'); peer.on('error', lost); peer.on('close', lost);
+    peer.on('connect', () => {sent = true; peer.write(JSON.stringify({token: a.token, session: record.session, runId: record.run.id, taskId: record.run.managed.taskId, epoch: record.autoContinueEpoch, method, ...(method === 'submit_guidance' ? {guidanceAuthorization: 1} : {}), ...(optionsGuidanceId ? {guidanceId: optionsGuidanceId} : {}), ...extra}) + '\n');});
+    peer.on('data', chunk => {
+      buffer += chunk; if (buffer.length > 16 * 1024 * 1024) {lost(); return;}
+      const end = buffer.indexOf('\n'); if (end < 0) return;
+      const line = buffer.slice(0, end); buffer = buffer.slice(end + 1);
+      try {
+        const r = JSON.parse(line);
+        if (r.kind === 'guidance_authorization_required') {
+          if (method !== 'submit_guidance' || challenged || !authorizeGuidance || r.guidanceId !== optionsGuidanceId ||
+              typeof r.challenge !== 'string' || !/^[0-9a-f-]{36}$/i.test(r.challenge)) {lost(); return;}
+          challenged = true;
+          const acknowledge = authorized => {
+            if (!settled && !peer.destroyed) peer.write(JSON.stringify({token: a.token, method: 'authorize_guidance',
+              guidanceId: optionsGuidanceId, challenge: r.challenge, authorized}) + '\n');
+          };
+          Promise.resolve().then(authorizeGuidance).then(() => {signal?.throwIfAborted(); acknowledge(true);}, () => acknowledge(false)).catch(() => acknowledge(false));
+          return;
+        }
+        if (r.guidanceAuthorization === 1) guidanceAuthorization = true;
+        finish(r.ok ? null : fail(r.code), r.result);
+      } catch {lost();}
+    });
+  });
+  const close = () => {closed = true; signal?.removeEventListener('abort', close); for (const peer of peers) peer.destroy();};
+  signal?.addEventListener('abort', close, {once: true});
+  return {transport: 'codex_app_tools', close, get guidanceAuthorization() {return guidanceAuthorization;},
+    request(method, params) {if (params.threadId !== record.session) throw fail('native_tools_target_mismatch'); return call(method, {cursor: params.cursor});},
+    async submitGuidance({text, beforeSubmit}) {if (!optionsGuidanceId || !guidanceAuthorization) throw fail('native_guidance_unavailable'); await beforeSubmit(); signal?.throwIfAborted(); return call('submit_guidance', {text}, beforeSubmit);},
+    async submitOriginal({text, beforeSubmit}) {await beforeSubmit(); signal?.throwIfAborted(); const fresh = await readRecord(join(root, 'delivery-hooks'), 'codex', record.session); return call('submit', {text, handoffId: fresh?.run?.managed?.nativeHandoff?.id});},
+  };
+}

package/src/codex-plugins/simy/native/guidance-intent.mjs

@@ -0,0 +1,30 @@
+import {createHash} from 'node:crypto';
+
+export const guidancePending = record => ['prepared', 'submitting', 'submitted', 'unknown'].includes(record?.run?.managed?.userGuidance?.phase);
+export const guidanceDigest = text => createHash('sha256').update(text).digest('hex');
+export function guidanceTarget(record) {
+  return {provider: record?.provider, session: record?.session, cwd: record?.cwd,
+    runId: record?.run?.id, taskId: record?.run?.managed?.taskId, epoch: record?.autoContinueEpoch,
+    revision: (record?.run?.revision || 0) + (record?.run?.controlRevision || 0)};
+}
+export function guidanceAllowed(record, {pendingId} = {}) {
+  const m = record?.run?.managed;
+  return record?.provider === 'codex' && record.autoContinue === true && !!record.autoContinueEpoch &&
+    !record.providerArchived && !record.parentSession && record.run?.state === 'recovery_required' && !record.run.stopReason &&
+    m?.purpose?.enabled === true && m.resumeChannel === 'codex_app_server' && (!m.autoContinueEpoch || m.autoContinueEpoch === record.autoContinueEpoch) &&
+    !m.pendingApproval && !m.userQuestion && !m.understandingQuestion && !m.nativeWait && !m.dependencyWait && !m.authenticationWait &&
+    !m.resumeLease && !m.liveWorkspaceLease && !m.outcomeAudit?.lease && !m.executionUncertain && !m.providerWarning &&
+    !m.usageBlocked && !m.maxTokens && !m.purpose?.nativeBoundary &&
+    !['verifying', 'understanding', 'needs_clarification', 'action_association'].includes(m.phase) &&
+    (!m.nativeHandoff || ['finished', 'cancelled'].includes(m.nativeHandoff.phase)) &&
+    (!guidancePending(record) || pendingId === m.userGuidance.id);
+}
+export function assertGuidanceIntent(record, id, text) {
+  const intent = record?.run?.managed?.userGuidance;
+  if (!intent || intent.id !== id || !guidanceAllowed(record, {pendingId: id}) ||
+      JSON.stringify(intent.target) !== JSON.stringify(guidanceTarget(record)) ||
+      intent.text !== text || intent.digest !== guidanceDigest(text)) {
+    throw Object.assign(new Error('The original guidance target or send intent changed.'), {code: 'native_guidance_changed'});
+  }
+  return intent;
+}

package/src/codex-plugins/simy/native/launch

@@ -0,0 +1,36 @@
+#!/bin/sh
+set -eu
+
+if [ "$#" -lt 1 ]; then
+  printf '%s\n' 'Codex app tools could not start: missing MCP server path.' >&2
+  exit 64
+fi
+
+PATH="${PATH:-/usr/bin:/bin}:/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin"
+export PATH
+
+cache_root=${XDG_CACHE_HOME:-${HOME:-}/.cache}
+codex_resources=
+case "${CODEX_CLI_PATH:-}" in
+  */*) codex_resources=${CODEX_CLI_PATH%/*} ;;
+esac
+for candidate in \
+  "${CODEX_MCP_NODE_PATH:-}" \
+  "${CODEX_BROWSER_USE_NODE_PATH:-}" \
+  "${CODEX_ELECTRON_RESOURCES_PATH:-}/cua_node/bin/node" \
+  "$codex_resources/cua_node/bin/node" \
+  "$cache_root/codex-runtimes/codex-primary-runtime/dependencies/node/bin/node"
+do
+  if [ -n "$candidate" ] && [ -x "$candidate" ]; then
+    exec "$candidate" "$@"
+  fi
+done
+
+if node_path=$(command -v node 2>/dev/null); then
+  case "$node_path" in
+    /*) exec "$node_path" "$@" ;;
+  esac
+fi
+
+printf '%s\n' 'Codex app tools could not find a Node runtime. Reinstall or update Codex.' >&2
+exit 127

package/src/codex-plugins/simy/native/server.mjs

@@ -0,0 +1,26 @@
+import {createInterface} from 'node:readline';
+import {homedir} from 'node:os';
+import {join, dirname} from 'node:path';
+import {startNativeBridge} from './bridge.mjs';
+
+// Codex launches this ordinary stdio MCP server with its own Node runtime and
+// fresh app-tools pipe. No saved pipe, daemon launch or app modification needed.
+let bridge, reason = 'native_tools_attachment_missing';
+try {
+  const resources = process.env.CODEX_ELECTRON_RESOURCES_PATH || dirname(dirname(dirname(process.execPath)));
+  bridge = await startNativeBridge({root: process.env.SIMY_HOME || join(homedir(), '.simy'), node: process.execPath,
+    server: join(resources, 'plugins/openai-bundled/plugins/codex-app-tools/server.mjs'), pipe: process.env.CODEX_APP_TOOLS_PIPE_PATH});
+} catch (e) {reason = e.code || reason;}
+const lines = createInterface({input: process.stdin});
+for await (const line of lines) {
+  let q; try {q = JSON.parse(line);} catch {continue;}
+  if (q.id === undefined) continue;
+  let result;
+  if (q.method === 'initialize') result = {protocolVersion: q.params.protocolVersion, capabilities: {tools: {}}, serverInfo: {name: 'simy-native-continuation', version: '1.0.0'}};
+  else if (q.method === 'tools/list') result = {tools: [{name: 'native_connection_status', description: 'Read SIMY native Codex transport availability. Connection availability is not execution or completion proof.', inputSchema: {type: 'object', properties: {}, additionalProperties: false}, annotations: {readOnlyHint: true}}]};
+  else if (q.method === 'tools/call' && q.params?.name === 'native_connection_status') result = {content: [{type: 'text', text: JSON.stringify({connected: !!bridge, reason: bridge ? 'app_launched_transport' : reason})}]};
+  else if (q.method === 'ping') result = {};
+  else {process.stdout.write(JSON.stringify({jsonrpc: '2.0', id: q.id, error: {code: -32601, message: 'Method not found'}}) + '\n'); continue;}
+  process.stdout.write(JSON.stringify({jsonrpc: '2.0', id: q.id, result}) + '\n');
+}
+await bridge?.close();

package/src/codex-plugins/simy/native/submission-receipt.mjs

@@ -0,0 +1,9 @@
+// Exact tool output, original sender, complete text and XML escaping are all
+// required. A quoted message or worker assertion is never a send receipt.
+export function matchesNativeDelegation(turn, session, text) {
+  const escaped = text.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
+  const expected = `<codex_delegation>\n  <source_thread_id>${session}</source_thread_id>\n  <input>${escaped}</input>\n</codex_delegation>`;
+  return turn.items?.some(item => item.type === 'functionCallOutput' && item.namespace === 'codex_app' &&
+    item.name === 'send_message_to_thread' && !item.output?.truncated &&
+    (typeof item.output === 'string' ? item.output : item.output?.text) === expected) === true;
+}

package/src/delivery-hooks/command.js

@@ -47,6 +47,10 @@ function parseDeliveryOptions(args, allowed) {
 
 export async function runDeliveryCommand(argv, { root = rootDirectory(), cwd = process.cwd(), webOrigin, input = process.stdin, output = console.log } = {}) {
   const [action, ...args] = argv;
+  if (action === 'measurement') {
+    const { runMeasurementCommand } = await import('./measurement.js');
+    return runMeasurementCommand(args, { root, cwd, webOrigin, output });
+  }
   if (action === 'auto-continue') {
     const controller = new AbortController(), abort = () => controller.abort();
     process.once('SIGINT', abort); process.once('SIGTERM', abort);
@@ -238,6 +242,8 @@ export async function runDeliveryCommand(argv, { root = rootDirectory(), cwd = p
     output('simy delivery consult [--scope diagnose|repair_continue] [--request-id USER_TURN_ID] [--context-file context.json] [--provider codex|claude --session ID | --task-id ID] — diagnose scope: check why it stopped, using the observed current conversation or selected original work; repair_continue scope never implies completion.');
     output('simy delivery diagnose --provider codex|claude --session ID [--task-id ID] [--mode analyze|evidence] [--issues-file issues.json] [--detail brief|full] — advisory check of why it stopped, in a separate process; never resumes the target. Exact --task-id alone is also supported.');
     output('simy delivery evidence --provider codex|claude --session ID — read-only execution and acceptance receipts.');
+    output('simy delivery measurement enable|disable --provider codex|claude --cohort ID [--source field|fixture --layer N|S|F|W|X|B --loop on|off --judge-file FILE] — opt in future tasks in this workspace to local snapshot collection.');
+    output('simy delivery measurement start|stop|list|status|export|record|flush --provider codex|claude --session ID [--trace SHA256] — audit or explicitly upload content-free observations. See docs/adoption-measurement.md.');
     output('simy delivery activity [--watch] [--json] [--provider codex|claude] [--session ID] — local observations every 60 seconds; not productive time.');
     output('A task stops after repeated failures, and pauses for review when no progress is confirmed. Resume starts a new progress window.');
     output('simy delivery continuation_policy --provider PROVIDER --session ID --task-id ID --continuation-policy bounded|progress');

package/src/delivery-hooks/measurement.js

@@ -0,0 +1,149 @@
+import { readFile, writeFile, realpath } from 'node:fs/promises';
+import { dirname, join, relative, isAbsolute, sep } from 'node:path';
+import { readRecord, updateRecord } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+import { enrollMeasurement, measurementBinding, measurementDirectory, measurementPolicyPath, readMeasurements, appendMeasurement, listMeasurementTraces, measurementRuntime } from '../codex-plugins/simy/hooks/measurement-store.mjs';
+import { measurementDigest } from '../codex-plugins/simy/hooks/measurement-contract.mjs';
+import { validateMeasurementJudge } from '../codex-plugins/simy/hooks/measurement-judge.mjs';
+import { readSession, isSessionValid } from '../session-store.js';
+import { webApiUrl } from '../web-api.js';
+import { atomicSave, readState } from '../codex-plugins/simy/hooks/update-state-store.mjs';
+import { measurementRepository } from '../codex-plugins/simy/hooks/measurement-snapshot.mjs';
+
+function measurementCloudScope(webOrigin, auth) {
+  if (!webOrigin || !isSessionValid(auth, Date.now(), webOrigin) || !auth.organization_id ||
+      !(auth.account_id || auth.auth_user_id) || !auth.device_id) return null;
+  return { origin: new URL(webOrigin).origin, organization: auth.organization_id,
+    account: auth.account_id || auth.auth_user_id, device: auth.device_id };
+}
+
+async function loadMeasurementJudge(file, cwd) {
+  const root = await realpath(cwd), target = await realpath(file), path = relative(root, target);
+  if (!(path === '..' || path.startsWith(`..${sep}`) || isAbsolute(path))) throw new Error('Held-out judge must remain outside the solver workspace.');
+  const content = await readFile(target);
+  if (content.length > 65536) throw new Error('Held-out judge exceeds 64 KiB.');
+  return validateMeasurementJudge(JSON.parse(content.toString('utf8')));
+}
+
+export function measurementReadiness(events, { reservedSequence = events.at(-1)?.sequence || 0 } = {}) {
+  const gaps = []; let expected = 1;
+  for (const event of events) { if (event.sequence !== expected) gaps.push({ expected, received: event.sequence }); expected = event.sequence + 1; }
+  if (reservedSequence >= expected) gaps.push({ expected, received: null, reserved: reservedSequence });
+  const stops = events.filter(event => event.type === 'stop');
+  const judges = events.filter(event => event.type === 'judge');
+  return {
+    eventCount: events.length, stopCount: stops.length, sequenceGaps: gaps,
+    missingRunStart: !events.some(event => event.type === 'run_started' && event.sequence === 1),
+    terminalObserved: events.some(event => event.type === 'run_finished'),
+    declaredGaps: events.filter(event => event.type === 'gap').map(event => event.data.reason),
+    missingSnapshots: stops.filter(event => !event.data.snapshot).length,
+    unjudgedStops: stops.filter(stop => !judges.some(judge => judge.data.stop === stop.id && judge.data.snapshot === stop.data.snapshot && judge.data.scope === 'task_acceptance')).length,
+    artifactJudgedStops: stops.filter(stop => judges.some(judge => judge.data.stop === stop.id && judge.data.snapshot === stop.data.snapshot)).length,
+    unknownNaturalStops: stops.filter(event => event.data.natural === null).length,
+    unclassifiedStops: stops.filter(stop => stop.data.stop_kind === 'unknown' && !events.some(event => event.type === 'stop_label' && event.data.stop === stop.id)).length,
+    unclassifiedInstructions: events.filter(instruction => instruction.type === 'instruction' && instruction.data.instruction_type === 'unknown' && !events.some(event => event.type === 'instruction_label' && event.data.instruction === instruction.id)).length,
+    hasBillingReceipt: events.some(event => event.type === 'cost' && event.data.basis === 'billing' && event.data.amount_micros !== null),
+    // This is a collection audit. It cannot certify causal calibration, sample
+    // sufficiency, real-user acceptance or turn a fixture into field evidence.
+    effectReadiness: 'requires_cohort_evaluation',
+    remainingEvaluation: [
+      ...(stops.some(stop => !judges.some(judge => judge.data.stop === stop.id && judge.data.scope === 'task_acceptance')) ? ['independent_task_judgement'] : []),
+      'cohort_calibration', 'sample_sufficiency',
+    ],
+  };
+}
+
+export async function flushMeasurements({ root, provider, session, trace, webOrigin, fetchImpl = globalThis.fetch }) {
+  const binding = await measurementBinding(root, provider, session, trace);
+  if (!binding?.scope) throw new Error('Measurement was not enrolled with a Cloud scope.');
+  const auth = await readSession(webOrigin, dirname(root));
+  const scope = measurementCloudScope(webOrigin, auth);
+  if (!scope || !binding.scope.device || JSON.stringify(scope) !== JSON.stringify(binding.scope)) throw new Error('Measurement Cloud account or organization changed; original scope required.');
+  const events = await readMeasurements({ root, provider, session, trace: binding.trace });
+  const directory = measurementDirectory(root, provider, session, binding.trace); let uploaded = 0;
+  for (const event of events) {
+    let saved;
+    try { saved = await readFile(join(directory, `${event.id}.ack`), 'utf8'); } catch (error) { if (error.code !== 'ENOENT') throw error; }
+    if (saved === event.id) continue;
+    const response = await fetchImpl(webApiUrl('sqm/measurement-events', { webOrigin, apiBaseUrl: auth.api_base_url }), {
+      method: 'POST', headers: { authorization: `Bearer ${auth.token}`, 'content-type': 'application/json', accept: 'application/json' },
+      body: JSON.stringify(event), signal: AbortSignal.timeout(10000),
+    });
+    const ack = await response.json().catch(() => null);
+    if (!response.ok || ack?.accepted !== true || ack?.event_id !== event.id || ack?.sequence !== event.sequence || ack?.trace !== event.trace)
+      throw new Error('Measurement upload was not acknowledged; local events retained.');
+    await writeFile(join(directory, `${event.id}.ack`), event.id, { mode: 0o600 }); uploaded++;
+  }
+  return { uploaded, retained: events.length };
+}
+
+export async function runMeasurementCommand(args, { root, cwd, webOrigin, output }) {
+  const [operation, ...flags] = args, options = {};
+  const allowed = new Set(['provider', 'session', 'trace', 'source', 'layer', 'loop', 'cohort', 'judge-file', 'event-file']);
+  for (let index = 0; index < flags.length; index += 2) {
+    const key = flags[index]?.slice(2);
+    if (!flags[index]?.startsWith('--') || !allowed.has(key) || !flags[index + 1] || Object.hasOwn(options, key)) throw new Error('Invalid measurement option.');
+    options[key] = flags[index + 1];
+  }
+  const { provider, session } = options;
+  if (!['codex', 'claude'].includes(provider) || !session && !['enable', 'disable'].includes(operation)) throw new Error('Use measurement enable|disable|start|status|export|record|flush --provider codex|claude [--session ID].');
+  const context = { root, provider, session, trace: options.trace };
+  if (['enable', 'disable'].includes(operation)) {
+    if (operation === 'disable') atomicSave(measurementPolicyPath(root, provider, cwd), { schemaVersion: 1, enabled: false });
+    else {
+      if (!options.cohort || !['field', 'fixture'].includes(options.source || 'field') || !['on', 'off'].includes(options.loop || 'on') || ![undefined, 'N','S','F','W','X','B'].includes(options.layer)) throw new Error('Explicit cohort and valid measurement policy required.');
+      const auth = webOrigin ? await readSession(webOrigin, dirname(root)) : null;
+      const scope = measurementCloudScope(webOrigin, auth);
+      const judge = options['judge-file'] ? await loadMeasurementJudge(options['judge-file'], cwd) : null;
+      atomicSave(measurementPolicyPath(root, provider, cwd), { schemaVersion: 1, enabled: true, cohort: options.cohort, source: options.source || 'field', layer: options.layer || null, loop: options.loop || 'on', scope, judge });
+    }
+    output(JSON.stringify({ enabled: operation === 'enable', appliesTo: 'future_tasks_in_this_workspace', historicalStopsAvailable: false }, null, 2));
+  } else if (operation === 'start') {
+    const record = await readRecord(root, provider, session);
+    if (!record?.run) throw new Error('Enroll an existing exact task; no task is started by measurement.');
+    if (options.loop === 'off' && record.autoContinue !== false) throw new Error('Turn off Auto Continue before enrolling a Loop-off control.');
+    if (options.loop !== 'off' && record.autoContinue !== true) throw new Error('A Loop-on cohort requires enabled Auto Continue.');
+    const auth = webOrigin ? await readSession(webOrigin, dirname(root)) : null;
+    const scope = measurementCloudScope(webOrigin, auth);
+    let spec;
+    if (options['judge-file']) spec = await loadMeasurementJudge(options['judge-file'], cwd);
+    let binding;
+    await updateRecord(root, provider, session, async fresh => {
+      if (fresh?.run?.id !== record.run.id || fresh.autoContinue !== record.autoContinue) throw new Error('Task changed before measurement enrollment.');
+      binding = await enrollMeasurement({ ...context, task: record.run.managed?.taskId || record.run.id,
+        source: options.source || 'field', layer: options.layer || null, loop: options.loop || 'on', cohort: options.cohort, late: true, scope,
+        repository: await measurementRepository(record.run.executionCwd || record.cwd), runtime: measurementRuntime(record) });
+      if (spec) await writeFile(join(measurementDirectory(root, provider, session, binding.trace), 'judge.json'), JSON.stringify(spec), { flag: 'wx', mode: 0o600 });
+      return fresh;
+    });
+    output(JSON.stringify({ enrolled: true, trace: binding.trace, cloudScopeBound: Boolean(scope), historicalStopsAvailable: false }, null, 2));
+  } else if (operation === 'stop') {
+    if (!await measurementBinding(root, provider, session, context.trace)) throw new Error('Measurement trace not found.');
+    atomicSave(join(measurementDirectory(root, provider, session, context.trace), 'collection.json'), { schemaVersion: 1, enabled: false });
+    output(JSON.stringify({ collectionEnabled: false, eventsRetained: true, taskChanged: false }, null, 2));
+  } else if (operation === 'list') output(JSON.stringify({ traces: await listMeasurementTraces(context) }, null, 2));
+  else if (operation === 'record') {
+    if (!options['event-file']) throw new Error('--event-file is required.');
+    const entry = JSON.parse(await readFile(options['event-file'], 'utf8'));
+    if (!['stop_label', 'instruction_label', 'resolution', 'gate', 'cost'].includes(entry.type)) throw new Error('Only externally reviewed annotations or usage receipts may be imported.');
+    const events = await readMeasurements(context);
+    const referenced = entry.data?.stop || entry.data?.instruction;
+    if (referenced && !events.some(event => event.id === referenced && event.type === (entry.type === 'stop_label' ? 'stop' : 'instruction'))) throw new Error('Annotation target is absent from this trace.');
+    if (entry.type === 'resolution') {
+      const first = events.find(event => event.type === 'sqm' && event.data.proof === entry.data?.first_proof);
+      if (!first?.data.findings.includes(entry.data?.finding) || entry.data.final_proof !== null &&
+          !events.some(event => event.type === 'sqm' && event.data.proof === entry.data.final_proof))
+        throw new Error('Resolution finding or proof is absent from this trace.');
+    }
+    if (entry.type === 'cost' && !events.some(event => ['execution', 'cost'].includes(event.type) && event.data.attempt === entry.data?.attempt))
+      throw new Error('Cost attempt is absent from this trace.');
+    const event = await appendMeasurement({ ...context, type: entry.type, key: entry.key, data: entry.data });
+    output(JSON.stringify({ recorded: true, event_id: event.id }, null, 2));
+  } else if (operation === 'flush') output(JSON.stringify(await flushMeasurements({ ...context, webOrigin }), null, 2));
+  else if (operation === 'status' || operation === 'export') {
+    const events = await readMeasurements(context);
+    const reservedSequence = readState(join(measurementDirectory(root, provider, session, context.trace), 'journal.json'))?.sequence || 0;
+    output(JSON.stringify(operation === 'export' ? { version: 'adoption_measurement_export.v1', events, readiness: measurementReadiness(events, { reservedSequence }) }
+      : { enrolled: Boolean(await measurementBinding(root, provider, session, context.trace)), ...measurementReadiness(events, { reservedSequence }) }, null, 2));
+  } else throw new Error('Use measurement start|status|export|flush.');
+  return 0;
+}