@jaimevalasek/aioson 1.37.0 → 1.37.1

package/src/commands/agent-execution.js

@@ -0,0 +1,36 @@
+'use strict';
+const path=require('node:path');
+const {initManifest,loadManifest,resolveAgentExecution}=require('../agent-execution/manifest');
+const {dispatch,readState}=require('../agent-execution/dispatcher');
+const {openRuntimeDb,getExecutionSnapshot,listExecutionEvents}=require('../runtime-store');
+async function resolveAllAgents(manifest,catalogLoader){
+ const entries=await Promise.all(Object.keys(manifest.agents).map(async id=>[id,await resolveAgentExecution(manifest,id,{}, {catalogLoader})]));
+ return Object.fromEntries(entries);
+}
+function resolutionErrors(resolutions){
+ return Object.entries(resolutions).filter(([,value])=>!value.ok).map(([id,value])=>({path:`$.agents.${id}.model`,message:value.reason,candidates:value.candidates||[],supported:value.supported||[]}));
+}
+async function runAgentExecution({args,options={},logger,catalogLoader}){
+ const projectDir=path.resolve(process.cwd(),args[0]||'.'); const sub=options.sub||'show'; const feature=String(options.feature||options.slug||'').trim();
+ if(!feature)return {ok:false,reason:'feature_required',message:'Use --feature=<slug>'};
+ if(sub==='init'){const created=await initManifest(projectDir,feature,String(options.host||'codex')); const result={ok:true,feature,path:path.relative(projectDir,created.path),digest:created.digest,manifest:created.manifest,availability:'validated_at_dispatch'}; if(!options.json)logger.log(`Agent execution manifest: ${result.path}\nValidate: aioson agent:execution:validate . --feature=${feature}`); return result;}
+ const loaded=await loadManifest(projectDir,feature);
+ if(sub==='validate'){
+  let resolutions={};let errors=loaded.errors||[];
+  if(loaded.exists&&loaded.ok){resolutions=await resolveAllAgents(loaded.manifest,catalogLoader);errors=resolutionErrors(resolutions)}
+  const result={ok:Boolean(loaded.exists&&loaded.ok&&!errors.length),feature,path:path.relative(projectDir,loaded.path),legacy:!loaded.exists,digest:loaded.digest||null,errors,resolutions,availability:'validated_at_dispatch'};
+  if(!options.json)(result.ok?logger.log(`Valid: ${result.path} (models resolved against the current runtime catalog).`):logger.error(JSON.stringify(result.errors,null,2)));return result;
+ }
+ if(sub==='show'){
+  if(!loaded.exists)return {ok:true,legacy:true,feature,path:path.relative(projectDir,loaded.path),message:'Manifest absent; legacy configured-default remains active.'};
+  if(!loaded.ok)return {ok:false,feature,errors:loaded.errors};
+  const agents=await resolveAllAgents(loaded.manifest,catalogLoader);const errors=resolutionErrors(agents);
+  return {ok:!errors.length,feature,path:path.relative(projectDir,loaded.path),digest:loaded.digest,agents,errors,availability:'validated_at_dispatch'};
+ }
+ if(sub==='dispatch')return dispatch({projectDir,feature,agent:options.agent||'dev',runId:options['run-id'],promptPath:options.prompt,catalogLoader});
+ if(sub==='resume'){const state=await readState(projectDir,feature);if(!state)return {ok:false,reason:'state_missing'};return dispatch({projectDir,feature,agent:options.agent||state.attempts.at(-1)?.agent||'dev',runId:state.run_id,promptPath:options.prompt,catalogLoader});}
+ if(sub==='status'){const {db}=await openRuntimeDb(projectDir);try{return{ok:true,schema_version:1,feature,runs:getExecutionSnapshot(db,{feature,agent:options.agent,state:options.state,limit:options.limit})}}finally{db.close()}}
+ if(sub==='events'){const state=await readState(projectDir,feature);const run=String(options.run||state?.attempts?.at(-1)?.telemetry_run_id||'');if(!run)return{ok:false,reason:'telemetry_run_required'};const {db}=await openRuntimeDb(projectDir);try{const owned=getExecutionSnapshot(db,{feature,limit:200}).some(item=>item.telemetry_run_id===run);if(!owned)return{ok:false,reason:'telemetry_run_not_found'};return{ok:true,schema_version:1,trust:'sanitized_untrusted_output',feature,telemetry_run_id:run,...listExecutionEvents(db,run,{after:options.after,limit:options.limit})}}finally{db.close()}}
+ return {ok:false,reason:'invalid_subcommand',valid:['init','validate','show','dispatch','resume','status','events']};
+}
+module.exports={runAgentExecution};

package/src/commands/op-capture.js

@@ -23,14 +23,27 @@ const path = require('node:path');
 const { resolveIdentity } = require('../operator-memory/identity');
 const { ensureStorageTree, recordIdentityActivity, openIndexDb, getStorageRoot } = require('../operator-memory/storage');
 const { deriveSlug, fingerprintProposal } = require('../operator-memory/slug');
-const { captureSignal, readProposal, VALID_SIGNAL_TYPES } = require('../operator-memory/proposal');
-const { promoteProposal } = require('../operator-memory/decision');
+const { captureSignal, readProposal, deleteProposal, VALID_SIGNAL_TYPES } = require('../operator-memory/proposal');
+const { promoteProposal, readDecision, reinforceDecision } = require('../operator-memory/decision');
 const { emitDossierEvent } = require('../lib/dossier-telemetry');
 
 const CONFIRMATIONS_JSONL = '.aioson/runtime/session-confirmations.jsonl';
 
 const PROMOTION_THRESHOLD = 2;
 
+/**
+ * Detections required before a signal promotes to a decision, by signal type.
+ *
+ * `confirmation` needs 2x — the user accepting the same non-obvious approach twice
+ * is what turns it into a signal. `authorization` / `exclusion` / `correction` are
+ * single explicit standing decisions ("pode sempre X", "nunca X", "pare de X"), so
+ * they promote on first detection. Mirrors the taxonomy in
+ * agents/_shared/memory-capture-directive.md.
+ */
+function promotionThresholdFor(signalType) {
+  return signalType === 'confirmation' ? PROMOTION_THRESHOLD : 1;
+}
+
 function existsCheckFactory(identity) {
   return (slug) => {
     const existing = readProposal(identity, slug);
@@ -130,7 +143,23 @@ First detection writes to proposals/{slug}.md. Second detection promotes to deci
 
   const count = result.proposal.detected_count;
 
-  if (count >= PROMOTION_THRESHOLD) {
+  // Idempotent re-detection: a signal already promoted to a decision is reinforced,
+  // not re-promoted — re-promotion would duplicate the FTS row and reset promoted_at.
+  const existingDecision = readDecision(resolved.identity, slug);
+  if (existingDecision) {
+    let reinforced = null;
+    try { reinforced = reinforceDecision(resolved.identity, slug); } catch { /* best-effort */ }
+    // captureSignal re-created a stray proposal (the decision had none) — drop it.
+    try { deleteProposal(resolved.identity, slug); } catch { /* best-effort */ }
+    const auditLine = `✔ Memory reforçada: '${proposal}'. aioson op:forget ${slug} p/ desfazer.`;
+    if (options.json) {
+      return { ok: true, promoted: false, reinforced: true, slug, identity: resolved.identity, reinforcement_count: reinforced ? reinforced.reinforcement_count : undefined };
+    }
+    if (logger) logger.log(auditLine);
+    return { ok: true, promoted: false, reinforced: true, slug };
+  }
+
+  if (count >= promotionThresholdFor(signal)) {
     // Promote to decision
     let decision;
     try {
@@ -166,6 +195,7 @@ First detection writes to proposals/{slug}.md. Second detection promotes to deci
 
 module.exports = {
   runOpCapture,
+  promotionThresholdFor,
   PROMOTION_THRESHOLD,
   CONFIRMATIONS_JSONL
 };

package/src/commands/op-reinforce.js

@@ -5,11 +5,9 @@
  * Phase 5 (v1.16.0). User-driven action when decay prompt fires.
  */
 
-const fs = require('node:fs');
 const { resolveIdentity } = require('../operator-memory/identity');
 const { ensureStorageTree } = require('../operator-memory/storage');
-const { readDecision, decisionPath, serializeDecision } = require('../operator-memory/decision');
-const { regenerateIndex } = require('../operator-memory/index-md');
+const { reinforceDecision } = require('../operator-memory/decision');
 const { emitDossierEvent } = require('../lib/dossier-telemetry');
 
 async function runOpReinforce({ args = [], options = {}, logger }) {
@@ -31,30 +29,20 @@ async function runOpReinforce({ args = [], options = {}, logger }) {
 
   const resolved = resolveIdentity();
   ensureStorageTree(resolved.identity);
-  const decision = readDecision(resolved.identity, slug);
-  if (!decision) {
+
+  // Surgical in-place reinforce: bumps reinforcement_count + refreshes
+  // last_reinforced and regenerates the index, preserving title/body/trigger-quotes
+  // byte-for-byte. (The old re-serialize path double-wrapped them, because the merged
+  // body from readDecision already contained the "# title" and "## Trigger quotes".)
+  const reinforced = reinforceDecision(resolved.identity, slug);
+  if (!reinforced) {
     const err = `op:reinforce — decision '${slug}' not found for identity ${resolved.identity}.`;
     if (options.json) return { ok: false, error: err };
     if (logger && logger.error) logger.error(err);
     return { ok: false, exitCode: 1, error: err };
   }
 
-  const now = new Date().toISOString();
-  const previous = decision.last_reinforced;
-  const updated = {
-    ...decision,
-    slug,
-    last_reinforced: now,
-    reinforcement_count: Number(decision.reinforcement_count || 0) + 1
-  };
-  // serialize keeps quotes + body + frontmatter intact
-  const out = serializeDecision({ ...updated, body: decision.body, title: decision.body?.split('\n')[0]?.replace(/^# /, '') || slug });
-  const filePath = decisionPath(resolved.identity, slug);
-  const tmp = `${filePath}.tmp`;
-  fs.writeFileSync(tmp, out, 'utf8');
-  fs.renameSync(tmp, filePath);
-
-  try { regenerateIndex(resolved.identity); } catch { /* non-fatal */ }
+  const { last_reinforced: now, previous, reinforcement_count } = reinforced;
 
   await emitDossierEvent(targetDir, {
     agent: 'op-reinforce',
@@ -64,7 +52,7 @@ async function runOpReinforce({ args = [], options = {}, logger }) {
   });
 
   if (options.json) {
-    return { ok: true, slug, last_reinforced: now, previous, reinforcement_count: updated.reinforcement_count };
+    return { ok: true, slug, last_reinforced: now, previous, reinforcement_count };
   }
   if (logger) logger.log(`op:reinforce — '${slug}' last_reinforced refreshed to ${now}.`);
   return { ok: true, slug };

package/src/commands/verification-plan.js

@@ -7,7 +7,8 @@
 // instead of re-interpreting the config in prose. Read-only; never mutates state.
 
 const fs = require('node:fs/promises');
-const path = require('node:path');
+const path = require('node:path');
+const { loadManifest, resolveAgentExecution } = require('../agent-execution/manifest');
 const {
   readVerificationConfig,
   resolveHost,
@@ -63,7 +64,7 @@ async function detectClassification(targetDir, slug) {
   return null;
 }
 
-async function runVerificationPlan({ args, options = {}, logger }) {
+async function runVerificationPlan({ args, options = {}, logger, catalogLoader }) {
   const targetDir = path.resolve(process.cwd(), args[0] || '.');
   const slug = (options.feature || options.slug || '').toString().trim() || null;
 
@@ -79,8 +80,12 @@ async function runVerificationPlan({ args, options = {}, logger }) {
   }
   const trigger = triggerRaw;
 
-  const config = await readVerificationConfig(targetDir);
-  const host = resolveHost(config, options.host);
+  const config = await readVerificationConfig(targetDir);
+  const host = resolveHost(config, options.host);
+  const executionManifest = slug ? await loadManifest(targetDir, slug) : { exists: false, legacy: true, ok: true };
+  if (executionManifest.exists && !executionManifest.ok) {
+    return { ok: false, reason: 'agent_execution_manifest_invalid', errors: executionManifest.errors, manifest_path: executionManifest.path };
+  }
 
   let classification = (options.classification || '').toString().trim().toUpperCase();
   if (!CLASSIFICATIONS.includes(classification)) {
@@ -91,13 +96,24 @@ async function runVerificationPlan({ args, options = {}, logger }) {
   const context = { trigger, classification, sensitiveSurface };
   const agents = [];
   for (const agentId of VERIFICATION_AGENTS) {
-    const dispatch = getAgentDispatch(config, agentId, host);
-    const entry = {
+    const dispatch = getAgentDispatch(config, agentId, host);
+    const execution = executionManifest.exists ? await resolveAgentExecution(executionManifest.manifest, agentId, {}, { catalogLoader }) : null;
+    if (execution && !execution.ok) {
+      return { ok: false, reason: 'model_resolution_failed', agent: agentId, resolution: execution };
+    }
+    const entry = {
       agent: agentId,
       run: shouldRunForTrigger(config, agentId, context),
-      mode: dispatch ? dispatch.mode : 'native',
-      model: dispatch ? dispatch.model : 'configured-default',
-      report: resolveAgentReportPath(config, agentId, slug || '{slug}')
+      host: execution ? execution.host : (dispatch ? dispatch.host : host),
+      mode: execution ? execution.mode : (dispatch ? dispatch.mode : 'native'),
+      model: execution ? execution.model : (dispatch ? dispatch.model : 'configured-default'),
+      model_requested: execution ? execution.model_requested : (dispatch ? dispatch.model : 'configured-default'),
+      model_resolved: execution ? execution.model_resolved : (dispatch ? dispatch.model : 'configured-default'),
+      model_resolution_strategy: execution ? execution.model_resolution_strategy : 'legacy',
+      reasoning_effort: execution ? (execution.reasoning_effort || null) : null,
+      report: execution ? execution.report.replace('{run_id}', '{run_id}') : resolveAgentReportPath(config, agentId, slug || '{slug}'),
+      execution_source: execution ? 'manifest' : 'legacy',
+      execution: execution || undefined
     };
     if (agentId === 'validator') {
       const cc = getCrossCheck(config, agentId);
@@ -115,8 +131,9 @@ async function runVerificationPlan({ args, options = {}, logger }) {
     sensitive_surface: sensitiveSurface,
     agents,
     phase_loop: getPhaseLoop(config),
-    budget: getBudget(config)
-  };
+    budget: getBudget(config)
+  };
+  result.agent_execution = executionManifest.exists ? { source: 'manifest', path: executionManifest.path, digest: executionManifest.digest } : { source: 'legacy' };
   result.continuation_directive = buildContinuationDirective(trigger, result.phase_loop);
 
   if (options.json) return result;

package/src/commands/workflow-execute.js

@@ -8,7 +8,8 @@
  */
 
 const fs = require('node:fs/promises');
-const path = require('node:path');
+const path = require('node:path');
+const { initManifest, loadManifest } = require('../agent-execution/manifest');
 const {
   detectClassification,
   scanArtifacts,
@@ -751,7 +752,7 @@ async function performRunnerTransition(targetDir, suggestion, tool, requestedMod
 async function runWorkflowExecute({ args, options = {}, logger }) {
   const targetDir = path.resolve(process.cwd(), args[0] || '.');
   const slug = options.feature ? String(options.feature).trim() : null;
-  const tool = options.tool ? String(options.tool).trim() : 'claude';
+  const tool = options.tool ? String(options.tool).trim() : 'claude';
   const requestedMode = options.mode ? String(options.mode).trim() : null;
   const dryRun = Boolean(options['dry-run'] || options.dry);
   // --step (disarm) is by definition record-only: it writes the disarmed scheme
@@ -788,9 +789,20 @@ async function runWorkflowExecute({ args, options = {}, logger }) {
     return failure;
   }
 
-  const parallelGuard = laneIndex !== null
+  const parallelGuard = laneIndex !== null
     ? await runLaneGuardPreflight(targetDir, laneIndex)
-    : null;
+    : null;
+
+  let agentExecution = await loadManifest(targetDir, slug);
+  if (!dryRun && !agentExecution.exists) {
+    await initManifest(targetDir, slug, tool);
+    agentExecution = await loadManifest(targetDir, slug);
+  }
+  if (agentExecution.exists && !agentExecution.ok) {
+    const failure = { ok: false, reason: 'agent_execution_manifest_invalid', errors: agentExecution.errors, manifest_path: agentExecution.path };
+    if (!options.json) logger.error(`Invalid agent execution manifest: ${agentExecution.path}`);
+    return failure;
+  }
 
   if (parallelGuard && !parallelGuard.ok && !parallelGuard.skipped) {
     if (parallelGuard.reason === 'lane_not_found') {
@@ -882,7 +894,8 @@ async function runWorkflowExecute({ args, options = {}, logger }) {
       status_snapshot: statusSnapshot,
       suggestion: statusSnapshot && statusSnapshot.suggestion ? statusSnapshot.suggestion : null,
       resume_command: resumeCommand,
-      agentic_policy: agenticPolicy,
+      agentic_policy: agenticPolicy,
+      agent_execution: agentExecution.exists ? { path: agentExecution.path, digest: agentExecution.digest } : { source: 'legacy' },
       parallel_guard: parallelGuard
     };
 
@@ -953,7 +966,8 @@ async function runWorkflowExecute({ args, options = {}, logger }) {
       status_snapshot: statusSnapshot,
       suggestion: statusSnapshot && statusSnapshot.suggestion ? statusSnapshot.suggestion : null,
       resume_command: resumeCommand,
-      agentic_policy: agenticPolicy,
+      agentic_policy: agenticPolicy,
+      agent_execution: { path: agentExecution.path, digest: agentExecution.digest },
       parallel_guard: parallelGuard
     };
 

package/src/harness/criteria-runner.js

@@ -16,7 +16,10 @@
 
 const crypto = require('node:crypto');
 
-const DEFAULT_CHECK_TIMEOUT_MS = 120000;
+// Repository-wide quality gates can legitimately exceed two minutes on
+// Windows. Keep the CLI --timeout override, but give deterministic contract
+// checks enough headroom to avoid classifying a healthy full suite as failed.
+const DEFAULT_CHECK_TIMEOUT_MS = 300000;
 
 /**
  * Normaliza uma linha de erro para assinatura estável (D7):

package/src/operator-memory/decision.js

@@ -226,6 +226,46 @@ function promoteProposal({ identity, proposal: proposalData }) {
   return decision;
 }
 
+/**
+ * Reinforce an existing decision in place: bump reinforcement_count and refresh
+ * last_reinforced (PMD-11). Used when a signal already promoted is re-detected —
+ * strengthens the memory instead of re-promoting (which would duplicate the FTS
+ * row and reset promoted_at).
+ *
+ * Surgical frontmatter edit — preserves title, body and trigger quotes byte-for-byte
+ * (unlike a full re-serialize, which cannot recover the title from the merged body).
+ * Returns { slug, last_reinforced, previous, reinforcement_count } or null if absent.
+ */
+function reinforceDecision(identity, slug) {
+  const filePath = decisionPath(identity, slug);
+  if (!fs.existsSync(filePath)) return null;
+
+  const content = fs.readFileSync(filePath, 'utf8');
+  const parsed = parseDecisionFile(content);
+  const previous = (parsed && parsed.last_reinforced) || null;
+  const nextCount = Number((parsed && parsed.reinforcement_count) || 0) + 1;
+  const now = new Date().toISOString();
+
+  // Replace only the first (frontmatter) occurrence of each field; `.` never
+  // spans newlines, so the body is untouched.
+  const updated = content
+    .replace(/^(reinforcement_count:[ \t]*).*$/m, `$1${nextCount}`)
+    .replace(/^(last_reinforced:[ \t]*).*$/m, `$1${now}`);
+
+  const tmpPath = `${filePath}.tmp`;
+  fs.writeFileSync(tmpPath, updated, 'utf8');
+  fs.renameSync(tmpPath, filePath);
+
+  // Post-write: regenerate MEMORY.md index (best-effort — it surfaces the
+  // reinforced date). FTS body/category are unchanged, so no FTS write needed.
+  try {
+    const { regenerateIndex } = require('./index-md');
+    regenerateIndex(identity);
+  } catch { /* index regen failure is non-fatal */ }
+
+  return { slug, last_reinforced: now, previous, reinforcement_count: nextCount };
+}
+
 /**
  * Soft-delete a decision or proposal to history/.
  * Returns { mode: 'decision'|'proposal'|'noop', archivedPath: string|null }.
@@ -267,6 +307,7 @@ function forgetEntry(identity, slug) {
 
 module.exports = {
   promoteProposal,
+  reinforceDecision,
   forgetEntry,
   readDecision,
   decisionPath,

package/src/runtime-store.js

@@ -176,7 +176,7 @@ async function openRuntimeDb(targetDir, options = {}) {
       FOREIGN KEY (run_key) REFERENCES agent_runs(run_key) ON DELETE CASCADE
     );
 
-    CREATE TABLE IF NOT EXISTS execution_events (
+    CREATE TABLE IF NOT EXISTS execution_events (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       task_key TEXT,
       run_key TEXT,
@@ -199,7 +199,51 @@ async function openRuntimeDb(targetDir, options = {}) {
       created_at TEXT NOT NULL,
       FOREIGN KEY (task_key) REFERENCES tasks(task_key) ON DELETE SET NULL,
       FOREIGN KEY (run_key) REFERENCES agent_runs(run_key) ON DELETE CASCADE
-    );
+    );
+
+    CREATE TABLE IF NOT EXISTS agent_execution_runs (
+      telemetry_run_id TEXT PRIMARY KEY,
+      dispatcher_run_id TEXT NOT NULL,
+      attempt_id TEXT NOT NULL,
+      feature TEXT NOT NULL,
+      agent TEXT NOT NULL,
+      host TEXT NOT NULL,
+      model TEXT NOT NULL,
+      model_requested TEXT,
+      model_resolved TEXT,
+      reasoning_effort TEXT,
+      model_resolution_strategy TEXT,
+      catalog_source TEXT,
+      state TEXT NOT NULL DEFAULT 'queued',
+      pid INTEGER,
+      process_fingerprint TEXT,
+      report_path TEXT,
+      report_digest TEXT,
+      reason TEXT,
+      truncated_bytes INTEGER NOT NULL DEFAULT 0,
+      dropped_events INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      finished_at TEXT,
+      UNIQUE(feature, agent, dispatcher_run_id, attempt_id)
+    );
+
+    CREATE TABLE IF NOT EXISTS agent_execution_events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      telemetry_run_id TEXT NOT NULL,
+      sequence_no INTEGER NOT NULL,
+      schema_version INTEGER NOT NULL DEFAULT 1,
+      event_type TEXT NOT NULL,
+      stream TEXT,
+      safe_summary TEXT NOT NULL DEFAULT '',
+      payload_json TEXT,
+      bytes INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT NOT NULL,
+      UNIQUE(telemetry_run_id, sequence_no),
+      FOREIGN KEY (telemetry_run_id) REFERENCES agent_execution_runs(telemetry_run_id) ON DELETE CASCADE
+    );
+    CREATE INDEX IF NOT EXISTS idx_agent_execution_events_cursor ON agent_execution_events(telemetry_run_id, sequence_no);
+    CREATE INDEX IF NOT EXISTS idx_agent_execution_runs_feature_updated ON agent_execution_runs(feature, updated_at DESC);
 
     CREATE TABLE IF NOT EXISTS artifacts (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -650,8 +694,14 @@ function normalizeTaskStatus(value, fallback) {
   return VALID_TASK_STATUSES.has(candidate) ? candidate : fallback;
 }
 
-function ensureLegacyColumns(db) {
-  const taskColumns = db.prepare('PRAGMA table_info(tasks)').all();
+function ensureLegacyColumns(db) {
+  const executionRunColumns = db.prepare('PRAGMA table_info(agent_execution_runs)').all();
+  const executionRunColumnNames = new Set(executionRunColumns.map((column) => column.name));
+  for (const column of ['model_requested', 'model_resolved', 'reasoning_effort', 'model_resolution_strategy', 'catalog_source']) {
+    if (!executionRunColumnNames.has(column)) db.exec(`ALTER TABLE agent_execution_runs ADD COLUMN ${column} TEXT`);
+  }
+
+  const taskColumns = db.prepare('PRAGMA table_info(tasks)').all();
   const taskColumnNames = new Set(taskColumns.map((column) => column.name));
 
   if (!taskColumnNames.has('task_kind')) {
@@ -2619,9 +2669,115 @@ function insertEvolutionLog(db, opts) {
   return id;
 }
 
-function listEvolutionLog(db, limit = 20) {
+function listEvolutionLog(db, limit = 20) {
   return db.prepare('SELECT * FROM evolution_log ORDER BY applied_at DESC LIMIT ?').all(limit);
-}
+}
+
+const EXECUTION_TERMINAL_STATES = new Set(['passed', 'failed', 'cancelled']);
+const EXECUTION_TRANSITIONS = {
+  queued: new Set(['running', 'waiting_report', 'paused', 'failed', 'cancelled']),
+  running: new Set(['waiting_report', 'paused', 'failed', 'cancelled']),
+  waiting_report: new Set(['passed', 'failed', 'correcting', 'paused']),
+  correcting: new Set(['running', 'paused', 'failed', 'cancelled']),
+  paused: new Set(['running', 'cancelled'])
+};
+
+function executionCorrelation(input) {
+  return {
+    feature: String(input.feature), agent: String(input.agent),
+    dispatcherRunId: String(input.dispatcher_run_id || input.run_id),
+    attemptId: String(input.attempt_id)
+  };
+}
+
+function findExecutionRun(db, input) {
+  const c = executionCorrelation(input);
+  return db.prepare(`SELECT * FROM agent_execution_runs WHERE feature=? AND agent=? AND dispatcher_run_id=? AND attempt_id=?`)
+    .get(c.feature, c.agent, c.dispatcherRunId, c.attemptId) || null;
+}
+
+function createExecutionRun(db, input) {
+  const c = executionCorrelation(input); const now = nowIso();
+  const id = input.telemetry_run_id || `aex-${slugify(c.feature)}-${require('node:crypto').randomUUID()}`;
+  const modelResolved = String(input.model_resolved || input.model);
+  const modelRequested = String(input.model_requested || input.model || '');
+  db.prepare(`INSERT OR IGNORE INTO agent_execution_runs
+    (telemetry_run_id,dispatcher_run_id,attempt_id,feature,agent,host,model,model_requested,model_resolved,reasoning_effort,model_resolution_strategy,catalog_source,state,created_at,updated_at)
+    VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`).run(id,c.dispatcherRunId,c.attemptId,c.feature,c.agent,String(input.host),modelResolved,modelRequested,modelResolved,input.reasoning_effort?String(input.reasoning_effort):null,input.model_resolution_strategy?String(input.model_resolution_strategy):null,input.catalog_source?String(input.catalog_source):null,'queued',now,now);
+  const run = findExecutionRun(db,input);
+  appendExecutionEvent(db,run.telemetry_run_id,{type:'run_created',safe_summary:'Execution queued'});
+  return run;
+}
+
+function appendExecutionEvent(db, runOrCorrelation, event) {
+  const run = typeof runOrCorrelation === 'string'
+    ? db.prepare('SELECT * FROM agent_execution_runs WHERE telemetry_run_id=?').get(runOrCorrelation)
+    : findExecutionRun(db,runOrCorrelation);
+  if (!run) throw new Error('execution_run_not_found');
+  const allowed = new Set(['run_created','process_started','state_changed','output','retry','fallback','timeout','report_attached','output_truncated','recovered','diagnostic']);
+  if (!allowed.has(event.type)) throw new Error('execution_event_type_invalid');
+  const sanitize=(value,depth=0)=>{if(depth>4)return'[TRUNCATED]';if(typeof value==='string')return value.replace(/(authorization\s*[:=]\s*(?:bearer\s+)?|api[_-]?key\s*[:=]\s*|token\s*[:=]\s*|password\s*[:=]\s*)[^\s,;]+/gi,'$1[REDACTED]').slice(0,2000);if(Array.isArray(value))return value.slice(0,25).map(v=>sanitize(v,depth+1));if(value&&typeof value==='object'){const out={};for(const key of Object.keys(value).slice(0,25))out[String(key).slice(0,100)]=sanitize(value[key],depth+1);return out}return value};
+  const safeSummary=sanitize(String(event.safe_summary||''));const safePayload=event.payload?sanitize(event.payload):null;
+  const tx=db.transaction(()=>{const seq=db.prepare('SELECT COALESCE(MAX(sequence_no),0)+1 n FROM agent_execution_events WHERE telemetry_run_id=?').get(run.telemetry_run_id).n;
+    db.prepare(`INSERT INTO agent_execution_events(telemetry_run_id,sequence_no,event_type,stream,safe_summary,payload_json,bytes,created_at) VALUES(?,?,?,?,?,?,?,?)`)
+      .run(run.telemetry_run_id,seq,event.type,event.stream||null,safeSummary,safePayload?JSON.stringify(safePayload).slice(0,16384):null,Math.min(Math.max(Number(event.bytes||0),0),16384),nowIso());return seq;});
+  return tx();
+}
+
+function attachExecutionProcess(db, correlation, process) {
+  const run=findExecutionRun(db,correlation); if(!run)throw new Error('execution_run_not_found');
+  if(run.pid && run.pid!==process.pid)throw new Error('execution_process_conflict');
+  db.prepare('UPDATE agent_execution_runs SET pid=?,process_fingerprint=?,state=?,updated_at=? WHERE telemetry_run_id=?')
+    .run(Number(process.pid),String(process.fingerprint||''),'running',nowIso(),run.telemetry_run_id);
+  appendExecutionEvent(db,run.telemetry_run_id,{type:'process_started',safe_summary:`Process ${process.pid} started`});
+  return db.prepare('SELECT * FROM agent_execution_runs WHERE telemetry_run_id=?').get(run.telemetry_run_id);
+}
+
+function transitionExecutionRun(db, correlation, next, reason=null) {
+  const run=findExecutionRun(db,correlation); if(!run)throw new Error('execution_run_not_found');
+  if(run.state===next)return run;if(EXECUTION_TERMINAL_STATES.has(run.state)||!EXECUTION_TRANSITIONS[run.state]?.has(next))throw new Error('execution_state_transition_invalid');
+  const safeReason=String(reason||'').replace(/(token|password|api[_-]?key)\s*[:=]\s*\S+/gi,'$1=[REDACTED]').slice(0,500)||null;
+  const now=nowIso();db.prepare('UPDATE agent_execution_runs SET state=?,reason=?,updated_at=?,finished_at=? WHERE telemetry_run_id=? AND state=?')
+    .run(next,safeReason,now,EXECUTION_TERMINAL_STATES.has(next)?now:null,run.telemetry_run_id,run.state);
+  appendExecutionEvent(db,run.telemetry_run_id,{type:'state_changed',safe_summary:`${run.state} -> ${next}`,payload:{state:next,reason}});
+  return db.prepare('SELECT * FROM agent_execution_runs WHERE telemetry_run_id=?').get(run.telemetry_run_id);
+}
+
+function attachExecutionReport(db, correlation, report) {
+  const run=findExecutionRun(db,correlation);if(!run)throw new Error('execution_run_not_found');
+  if(report.attempt_id!==run.attempt_id||report.run_id!==run.dispatcher_run_id)throw new Error('execution_report_binding_invalid');
+  db.prepare('UPDATE agent_execution_runs SET report_path=?,report_digest=?,updated_at=? WHERE telemetry_run_id=?')
+    .run(String(report.path||''),String(report.digest||''),nowIso(),run.telemetry_run_id);
+  appendExecutionEvent(db,run.telemetry_run_id,{type:'report_attached',safe_summary:'Bound report attached'});return findExecutionRun(db,correlation);
+}
+
+function getExecutionSnapshot(db, filters={}) {
+  const where=[],args=[];for(const [column,key] of [['feature','feature'],['agent','agent'],['state','state']])if(filters[key]){where.push(`${column}=?`);args.push(String(filters[key]));}
+  const limit=Math.min(Math.max(Number(filters.limit)||50,1),200);
+  return db.prepare(`SELECT * FROM agent_execution_runs ${where.length?'WHERE '+where.join(' AND '):''} ORDER BY updated_at DESC LIMIT ?`).all(...args,limit);
+}
+
+function listExecutionEvents(db, runId, options={}) {
+  const after=Math.max(Number(options.after)||0,0),limit=Math.min(Math.max(Number(options.limit)||100,1),500);
+  const rows=db.prepare('SELECT * FROM agent_execution_events WHERE telemetry_run_id=? AND sequence_no>? ORDER BY sequence_no LIMIT ?').all(runId,after,limit+1);
+  const hasMore=rows.length>limit,events=hasMore?rows.slice(0,limit):rows;
+  return {events,next_cursor:events.at(-1)?.sequence_no||after,has_more:hasMore};
+}
+
+function reconcileExecutionRun(db, correlation, probe=()=>false) {
+  const run=findExecutionRun(db,correlation);if(!run)throw new Error('execution_run_not_found');
+  if(EXECUTION_TERMINAL_STATES.has(run.state)||run.state==='paused')return run;
+  if(!run.pid)return transitionExecutionRun(db,correlation,'paused','spawn_identity_missing');
+  const observed=probe({pid:run.pid,fingerprint:run.process_fingerprint,created_at:run.created_at});
+  const alive=observed===true?false:Boolean(observed?.alive&&observed?.fingerprint&&observed.fingerprint===run.process_fingerprint);
+  if(alive)return transitionExecutionRun(db,correlation,'paused','detached_process');
+  return transitionExecutionRun(db,correlation,'paused','process_not_alive');
+}
+
+function pruneExecutionTelemetry(db, options={}) {
+  const days=Math.max(Number(options.retentionDays)||14,1),cutoff=new Date(Date.now()-days*86400000).toISOString(),batch=Math.min(Math.max(Number(options.batch)||100,1),1000);
+  return db.prepare(`DELETE FROM agent_execution_runs WHERE telemetry_run_id IN (SELECT telemetry_run_id FROM agent_execution_runs WHERE updated_at < ? AND state IN ('passed','failed','cancelled','paused') ORDER BY updated_at LIMIT ?)` ).run(cutoff,batch).changes;
+}
 
 module.exports = {
   resolveRuntimePaths,
@@ -2725,5 +2881,8 @@ module.exports = {
   listDynamicTools,
   // Evolution Log CRUD
   insertEvolutionLog,
-  listEvolutionLog
-};
+  listEvolutionLog
+  ,createExecutionRun, findExecutionRun, attachExecutionProcess, transitionExecutionRun,
+  appendExecutionEvent, attachExecutionReport, getExecutionSnapshot, listExecutionEvents,
+  reconcileExecutionRun, pruneExecutionTelemetry
+};

package/template/.aioson/agents/dev.md

@@ -149,7 +149,7 @@ Also check `.aioson/plans/{slug}/manifest.md` before any implementation:
 
 ## Phase loop (auto-continue)
 
-@dev runs a phased plan as **one continuous drive to the end of the feature, not one phase per turn.** Auto-continue is imperative (`phase_loop.auto_continue`): when a phase's gate is clean, go straight into the next phase — never stop to ask "continue?", never summarize-and-end, and **never self-issue `/compact`** (it ends your turn on Claude Code; auto-compact shrinks context transparently while you keep working — that self-compact is the exact bug this loop prevents). Per phase: `harness:check`, then `aioson verification:plan . --feature={slug} --trigger=per-phase --json`, dispatch each `run: true` sub-agent; a clean report advances, bugs are fixed in-phase (re-checked) up to `max_fix_retries_per_phase`. `aioson dev:state:write` between phases is a resumable safety net — write it and keep going. Full runtime smoke runs once at end-of-feature. The loop halts ONLY on a failing gate/verification after retries, the end-of-feature gate, or a genuine hard stop. Full protocol: `.aioson/docs/dev/phase-loop.md`.
+@dev runs a phased plan as **one continuous drive to the end of the feature, not one phase per turn.** Auto-continue is imperative (`phase_loop.auto_continue`): when a phase's gate is clean, go straight into the next phase — never stop to ask "continue?", never summarize-and-end, and **never self-issue `/compact`**. Per phase: `harness:check`, then `aioson verification:plan . --feature={slug} --trigger=per-phase --json`; dispatch each `run: true` entry through `aioson agent:execution:dispatch`, never by an assumed prompt-only subagent. `unsupported_capability` pauses honestly. A clean schema-valid report advances; bugs are fixed in-phase up to `max_fix_retries_per_phase`. `aioson dev:state:write` between phases is a resumable safety net. Full runtime smoke runs once at end-of-feature. Full protocol: `.aioson/docs/dev/phase-loop.md`.
 
 ## Context size detection
 

package/template/.aioson/agents/product.md

@@ -339,7 +339,8 @@ Only `@product` asks (the kickoff). Downstream agents (`@sheldon`/`@orchestrator
 
 **Autopilot actions** (per `.aioson/docs/autopilot-handoff.md`):
 1. Finish the PRD, the `features.md` line, and — MICRO (`→ @dev`) — the `## Dev handoff producer` `dev-state.md`.
-2. Seed the contract (idempotent): `aioson workflow:execute . --feature={slug} --seed --tool=claude`. **Check the result.** A `different_active_feature` failure means another feature still holds `workflow.state.json`: surface it (close/pause it or `aioson feature:sweep .`) and stop with the manual handoff — a failed seed never arms the chain.
+2. Seed the contract (idempotent): `aioson workflow:execute . --feature={slug} --seed --tool=claude`. **Check the result.** A `different_active_feature` failure means another feature still holds `workflow.state.json`: surface it (close/pause it or `aioson feature:sweep .`) and stop with the manual handoff — a failed seed never arms the chain.
+   The seed creates `agent-execution-{slug}.json`; mention editable defaults. Aliases are not model IDs.
 3. Register closing duties (`agent:epilogue`/`agent:done`), emit `Autopilot: @product done → invoking @<next> (Ctrl+C to interrupt)`.
 4. Invoke the lane's next stage: SMALL → `Skill(aioson:agent:sheldon)`; MEDIUM → `Skill(aioson:agent:orchestrator)`; MICRO → `Skill(aioson:agent:dev)`; site → `Skill(aioson:agent:copywriter)`. Task: `"continue feature {slug} — autopilot handoff from @product"`.
 

package/template/.aioson/docs/autopilot-handoff.md

@@ -35,7 +35,13 @@ aioson workflow:execute . --feature={slug} --seed --tool=<tool>
 
 **Seed failure is a stop condition.** The seeding agent must check the command result: a `different_active_feature` failure means another feature is genuinely active in `workflow.state.json` — surface it to the user (close/pause it, or `aioson feature:sweep .`) and stop with the manual handoff. Never continue the chain as if autopilot were armed when the seed failed.
 
-The headless/tracked runner `aioson workflow:execute . --feature={slug} --tool=<tool> --agentic` (without `--seed`) is the same contract but also advances checkpoints from the CLI — use it for non-interactive runs. Prompt-level `Skill(...)` chaining is how interactive Claude Code / codex sessions consume the scheme.
+The headless/tracked runner `aioson workflow:execute . --feature={slug} --tool=<tool> --agentic` (without `--seed`) is the same contract but also advances checkpoints from the CLI — use it for non-interactive runs. Prompt-level `Skill(...)` chaining is how interactive Claude Code / codex sessions consume the scheme.
+
+Execution selection lives in `.aioson/context/agent-execution-{slug}.json`. Validate it before code with `aioson agent:execution:validate`; use `agent:execution:dispatch|resume` for execution. Generated manifests default to `external`: the installed Claude/Codex/OpenCode CLI runs headlessly in a fresh process and writes a bound report. Native subagent/fresh-session modes require an explicit bridge capability; prompt-level chaining is not evidence. The core cannot force a client to open a visible interactive chat window.
+
+Codex entries may use a canonical slug or a human form such as `"model": "GPT 5.6 Terra"`, plus an optional `"reasoning_effort": "high"`. Validation resolves the current local Codex model catalog in conservative tiers: exact slug, normalized display name, unique alias, then a uniquely safe fuzzy match. Version numbers must remain identical, and ambiguous matches pause before process spawn. The manifest remains unchanged; state, reports, CLI output, and telemetry keep `model_requested`, `model_resolved`, and `model_resolution_strategy` separately. When the catalog is unavailable, only `configured-default` and literal model IDs are accepted as unverified fallbacks. Explicit reasoning effort is never silently downgraded or moved to another provider.
+
+Cross-repository writes are opt-in per agent through `writable_roots`. Every path must exist, be a directory, contain no traversal, and is canonicalized before dispatch and recorded in state/report. Codex maps roots to repeated `exec --add-dir <absolute>` argv; Claude maps to `--add-dir`. OpenCode currently has no verified additional-writable-root flag, so a non-empty list returns `host_capability_missing` rather than widening access silently.
 
 ## Routing — deterministic, never LLM-chosen
 

package/template/.aioson/docs/dev/phase-loop.md

@@ -21,9 +21,8 @@ After finishing each phase:
    ```bash
    aioson verification:plan . --feature={slug} --trigger=per-phase --json
    ```
-   For every agent with `run: true`, dispatch it as a sub-agent on the plan's top-level `host` plus that agent's `mode` / `model`, scoped to this phase's changed files:
-   - `mode: native` → an in-harness sub-agent. On Claude Code use the Task tool with that `model` tier (e.g. `sonnet-4.6`); on codex/opencode use their own configured model. The sub-agent writes its `report` file (e.g. `qa-report-{slug}.md`) and returns it to @dev.
-   - `mode: external` → only the explicitly configured cross-vendor auditor (`cross_check`); never spawn one otherwise.
+   For every agent with `run: true`, use `aioson agent:execution:dispatch . --feature={slug} --agent={agent} --json`. The resolved manifest is authoritative for host/model/mode. Validate model aliases before dispatch and preserve the distinct requested/resolved model, resolution strategy, and optional reasoning effort in state and reports; ambiguity or an unsupported effort is a real pause before spawn. A `unsupported_capability` or `manifest_invalid` result is also a real pause: never imitate a sub-agent or fresh session in prose. Only `external` execution backed by an installed CLI, or a native capability explicitly exposed by the current harness, may run.
+   - `mode: external` → the portable default: an installed host CLI runs headlessly in a fresh process, waits for exit, and must write the bound JSON report. This creates an isolated headless context, not a new interactive chat window.
    Read the report: **PASS** → continue. **Bugs** → fix them within this phase, re-run `harness:check`, and re-dispatch — up to `phase_loop.max_fix_retries_per_phase` times, then stop and surface the failure instead of advancing.
 4. **Checkpoint, then keep going — do NOT end the turn.** Write the cold-start packet as a crash/interrupt safety net:
    ```bash