@jaimevalasek/aioson 1.17.2 → 1.18.0

package/src/commands/live.js

@@ -19,7 +19,7 @@ const {
 const { ensureDir, exists } = require('../utils');
 const { SUPPORTED_PROMPT_TOOLS } = require('../prompt-tool');
 const { isTmuxAvailable, launchTmuxSession, buildSessionName, hasSession, attachSession } = require('../lib/tmux-launcher');
-const { resolveResumeArgs } = require('../lib/tool-capabilities');
+const { resolvePermissionModeArgs, resolveResumeArgs } = require('../lib/tool-capabilities');
 
 const LIVE_EVENTS_LIMIT = 10;
 const LIVE_MESSAGE_LIMIT = 500;
@@ -116,14 +116,16 @@ function parseJsonOption(value) {
   }
 }
 
-// Combine `--resume` (mapped per-tool via TOOL_CAPS) with user-provided `--tool-args`.
-// Resume args go FIRST so that codex `resume --last` (subcommand) lands at argv[1].
-function buildLaunchArgs(options, tool) {
-  const resumeOpt = options.resume !== undefined ? options.resume : options.Resume;
-  const resumeArgs = resolveResumeArgs(tool, resumeOpt);
-  const userArgs = parseToolArgs(options['tool-args'] || options.toolArgs);
-  return [...resumeArgs, ...userArgs];
-}
+// Combine `--resume` (mapped per-tool via TOOL_CAPS) with user-provided `--tool-args`.
+// Resume args go FIRST so that codex `resume --last` (subcommand) lands at argv[1].
+function buildLaunchArgs(options, tool) {
+  const resumeOpt = options.resume !== undefined ? options.resume : options.Resume;
+  const resumeArgs = resolveResumeArgs(tool, resumeOpt);
+  const permissionMode = options['permission-mode'] || options.permissionMode;
+  const permissionArgs = resolvePermissionModeArgs(tool, permissionMode);
+  const userArgs = parseToolArgs(options['tool-args'] || options.toolArgs);
+  return [...resumeArgs, ...permissionArgs, ...userArgs];
+}
 
 function parseToolArgs(value) {
   if (value === undefined || value === null || value === '') return [];
@@ -234,7 +236,7 @@ async function resolveExecutablePath(command) {
     .filter(Boolean);
 
   const extensions = process.platform === 'win32'
-    ? Array.from(new Set(['', ...String(process.env.PATHEXT || '.EXE;.CMD;.BAT;.COM').split(';').map((entry) => entry.toLowerCase())]))
+    ? Array.from(new Set([...String(process.env.PATHEXT || '.EXE;.CMD;.BAT;.COM').split(';').map((entry) => entry.toLowerCase())]))
     : [''];
 
   for (const dir of pathEntries) {
@@ -1235,57 +1237,80 @@ async function runLiveStart({ args, options = {}, logger, t }) {
           };
         }
       } else {
-        // Non-tmux reuse logic (original behavior)
+        // Non-tmux reuse logic
         const existingTool = state.tool_session || null;
         if (existingTool && existingTool !== tool) {
-          throw new Error(t('live.tool_mismatch', { existing: existingTool, requested: tool }));
-        }
-
-        const attach = Boolean(options.attach);
-        let attachChild = null;
-        let attachResult = null;
-
-        if (attach && !noLaunch) {
-          attachChild = spawn(binaryPath, buildLaunchArgs(options, tool), {
-            cwd: targetDir,
-            env: process.env,
-            stdio: 'inherit'
+          // Auto-close stale session when tool changed (same pattern as tmux recovery above)
+          updateRun(db, {
+            runKey: existing.run.run_key,
+            status: 'completed',
+            summary: `Auto-closed: tool changed from ${existingTool} to ${tool}`,
+            eventType: 'session_closed',
+            phase: 'live',
+            message: `Tool mismatch — auto-closed previous ${existingTool} session`
           });
-          state.child_pid = attachChild.pid || null;
           if (existing.task?.task_key) {
-            const taskMeta = parseTaskMeta(existing.task);
-            taskMeta.child_pid = state.child_pid;
-            updateTask(db, { taskKey: existing.task.task_key, metaJson: taskMeta });
+            updateTask(db, {
+              taskKey: existing.task.task_key,
+              status: 'completed',
+              goal: `Auto-closed after tool change to ${tool}`
+            });
+          }
+          await clearAgentSession(runtimeDir, agentName);
+          if (!options.json) {
+            logger.log(t('live.tool_mismatch_auto_closed', { existing: existingTool, requested: tool }) ||
+              `Previous session (${existingTool}) auto-closed — starting new with ${tool}`);
+          }
+          // Fall through to create a new session below
+        } else {
+          // Tools match (or no previous tool) — reuse existing session
+          const attach = Boolean(options.attach);
+          let attachChild = null;
+          let attachResult = null;
+
+          if (attach && !noLaunch) {
+            attachChild = spawn(binaryPath, buildLaunchArgs(options, tool), {
+              cwd: targetDir,
+              env: process.env,
+              stdio: 'inherit',
+              shell: process.platform === 'win32'
+            });
+            state.child_pid = attachChild.pid || null;
+            if (existing.task?.task_key) {
+              const taskMeta = parseTaskMeta(existing.task);
+              taskMeta.child_pid = state.child_pid;
+              updateTask(db, { taskKey: existing.task.task_key, metaJson: taskMeta });
+            }
           }
-        }
 
-        await writeLiveState(runtimeDir, existing.sessionKey, state);
+          await writeLiveState(runtimeDir, existing.sessionKey, state);
 
-        if (!options.json) {
-          logger.log(t('live.session_already_active', { agent: agentName, session: existing.sessionKey, runKey: existing.run.run_key, dbPath }));
-        }
+          if (!options.json) {
+            logger.log(t('live.session_already_active', { agent: agentName, session: existing.sessionKey, runKey: existing.run.run_key, dbPath }));
+          }
 
-        if (attachChild) {
-          attachResult = await waitForChild(attachChild);
-        }
+          if (attachChild) {
+            attachResult = await waitForChild(attachChild);
+          }
 
-        return {
-          ok: true,
-          targetDir,
-          dbPath,
-          agent: existing.agentName,
-          tool: state.tool_session || tool,
-          taskKey: existing.task?.task_key || existing.sessionRef?.taskKey || null,
-          runKey: existing.run.run_key,
-          sessionKey: existing.sessionKey,
-          pid: state.child_pid || null,
-          processState: detectProcessState(state.child_pid),
-          reused: true,
-          open: true,
-          attached: attach,
-          childExitCode: attachResult?.code ?? null,
-          childSignal: attachResult?.signal ?? null
-        };
+          return {
+            ok: true,
+            targetDir,
+            dbPath,
+            agent: existing.agentName,
+            tool: state.tool_session || tool,
+            taskKey: existing.task?.task_key || existing.sessionRef?.taskKey || null,
+            runKey: existing.run.run_key,
+            sessionKey: existing.sessionKey,
+            pid: state.child_pid || null,
+            processState: detectProcessState(state.child_pid),
+            reused: true,
+            open: true,
+            attached: attach,
+            childExitCode: attachResult?.code ?? null,
+            childSignal: attachResult?.signal ?? null
+          };
+        }
       }
     }
 
@@ -1356,7 +1381,8 @@ async function runLiveStart({ args, options = {}, logger, t }) {
           child = spawn(binaryPath, buildLaunchArgs(options, tool), {
             cwd: targetDir,
             env: process.env,
-            stdio: 'inherit'
+            stdio: 'inherit',
+            shell: process.platform === 'win32'
           });
           taskMeta.child_pid = child.pid || null;
           updateTask(db, {
@@ -1368,7 +1394,8 @@ async function runLiveStart({ args, options = {}, logger, t }) {
         child = spawn(binaryPath, buildLaunchArgs(options, tool), {
           cwd: targetDir,
           env: process.env,
-          stdio: 'inherit'
+          stdio: 'inherit',
+          shell: process.platform === 'win32'
         });
         taskMeta.child_pid = child.pid || null;
         updateTask(db, {

package/src/commands/op-capture.js

@@ -27,6 +27,8 @@ const { captureSignal, readProposal, VALID_SIGNAL_TYPES } = require('../operator
 const { promoteProposal } = require('../operator-memory/decision');
 const { emitDossierEvent } = require('../lib/dossier-telemetry');
 
+const CONFIRMATIONS_JSONL = '.aioson/runtime/session-confirmations.jsonl';
+
 const PROMOTION_THRESHOLD = 2;
 
 function existsCheckFactory(identity) {
@@ -55,6 +57,8 @@ First detection writes to proposals/{slug}.md. Second detection promotes to deci
   const quote = options.quote;
   const proposal = options.proposal;
   const sourceAgent = options['source-agent'] || options.sourceAgent || 'unknown';
+  const featureSlug = options.feature ? String(options.feature) : null;
+  const sessionId = options['session-id'] || options.sessionId || null;
 
   if (!signal || !proposal) {
     const err = `op:capture — required: --signal=<type> --proposal=<paraphrase>. Got signal=${signal}, proposal=${proposal ? 'present' : 'missing'}.`;
@@ -95,7 +99,9 @@ First detection writes to proposals/{slug}.md. Second detection promotes to deci
       signal_type: signal,
       quote,
       proposal,
-      source_agent: sourceAgent
+      source_agent: sourceAgent,
+      feature_slug: featureSlug,
+      session_id: sessionId
     });
   } catch (err) {
     const errMsg = `op:capture failed: ${err.message}`;
@@ -104,6 +110,24 @@ First detection writes to proposals/{slug}.md. Second detection promotes to deci
     return { ok: false, exitCode: 1, error: errMsg };
   }
 
+  // M2: append confirmation signals to session accumulator for decision_rationale
+  if (signal === 'confirmation') {
+    try {
+      const accPath = path.join(targetDir, CONFIRMATIONS_JSONL);
+      const accDir = path.dirname(accPath);
+      fs.mkdirSync(accDir, { recursive: true });
+      const entry = JSON.stringify({
+        agent: sourceAgent,
+        decision: proposal,
+        quote: quote || null,
+        timestamp: new Date().toISOString()
+      });
+      fs.appendFileSync(accPath, entry + '\n', 'utf8');
+    } catch {
+      // best-effort — never block op:capture
+    }
+  }
+
   const count = result.proposal.detected_count;
 
   if (count >= PROMOTION_THRESHOLD) {
@@ -142,5 +166,6 @@ First detection writes to proposals/{slug}.md. Second detection promotes to deci
 
 module.exports = {
   runOpCapture,
-  PROMOTION_THRESHOLD
+  PROMOTION_THRESHOLD,
+  CONFIRMATIONS_JSONL
 };

package/src/commands/op-list.js

@@ -21,13 +21,15 @@ const { readDecision } = require('../operator-memory/decision');
 
 async function runOpList({ args = [], options = {}, logger }) {
   if (options.help === true || args.includes('--help') || args.includes('-h')) {
-    if (logger) logger.log('op:list [--proposals] [--include-archived] [--format=table|json] — list active decisions.');
+    if (logger) logger.log('op:list [--proposals] [--include-archived] [--feature=<slug>] [--agent=<name>] [--format=table|json] — list active decisions.');
     return { ok: true };
   }
 
   const format = options.format || 'table';
   const showProposals = Boolean(options.proposals);
   const includeArchived = Boolean(options['include-archived']);
+  const filterFeature = options.feature ? String(options.feature) : null;
+  const filterAgent = options.agent ? String(options.agent) : null;
 
   const resolved = resolveIdentity();
   ensureStorageTree(resolved.identity);
@@ -65,9 +67,39 @@ async function runOpList({ args = [], options = {}, logger }) {
     }
   }
 
+  // M3: apply --feature and --agent filters (BR-AO-07: AND-composable)
+  if (filterFeature) {
+    items = items.filter((item) => item.feature_slug === filterFeature);
+  }
+  if (filterAgent) {
+    items = items.filter((item) => item.source_agent === filterAgent);
+  }
+
   if (format === 'json' || options.json) {
+    // BR-AO-09: structured JSON output when --feature is used
+    if (filterFeature) {
+      const decisions = items.map((item) => ({
+        agent: item.source_agent || 'unknown',
+        signal: item.signal_type || null,
+        quote: Array.isArray(item.quotes) ? (item.quotes[item.quotes.length - 1] || null) : null,
+        proposal: item.proposal || item.body || item.title || null,
+        timestamp: item.last_reinforced || item.last_detected || null,
+        session_id: item.session_id || null
+      }));
+      const result = {
+        ok: true,
+        feature: filterFeature,
+        decisions,
+        total: decisions.length
+      };
+      if (options.json) return result;
+      if (logger) logger.log(JSON.stringify(result, null, 2));
+      return result;
+    }
+
     const result = {
       ok: true,
+      feature: null,
       identity: resolved.identity,
       identity_source: resolved.source,
       tier: showProposals ? 'proposals' : (includeArchived ? 'active+archive' : 'active'),

package/src/commands/store-system.js

@@ -6,6 +6,33 @@ const { exists, ensureDir } = require('../utils');
 const { readConfig } = require('./config');
 const { readWorkspace, findProjectRoot } = require('./workspace');
 
+let _terser = null;
+function getTerser() {
+  if (!_terser) _terser = require('terser');
+  return _terser;
+}
+
+async function createZipBuffer(files) {
+  const archiver = require('archiver');
+  const { PassThrough } = require('stream');
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    const stream = new PassThrough();
+    stream.on('data', (chunk) => chunks.push(chunk));
+    stream.on('end', () => resolve(Buffer.concat(chunks)));
+    stream.on('error', reject);
+
+    const archive = archiver('zip', { zlib: { level: 9 } });
+    archive.on('error', reject);
+    archive.pipe(stream);
+
+    for (const [relPath, content] of Object.entries(files)) {
+      archive.append(content, { name: relPath });
+    }
+    archive.finalize();
+  });
+}
+
 const DEFAULT_BASE_URL = 'https://aioson.com';
 const SYSTEM_PACKAGES_DIR = '.aioson/system-packages';
 const BACKUPS_DIR = '.aioson/.backups';
@@ -25,6 +52,17 @@ const SYSTEM_ALLOWED_EXTS = new Set([
   '.gitignore',
 ]);
 
+const SYSTEM_BUILD_ALLOWED_EXTS = new Set([
+  '.js', '.jsx', '.mjs', '.cjs',
+  '.json', '.jsonc',
+  '.css',
+  '.html',
+  '.svg', '.ico',
+  '.sql',
+  '.yaml', '.yml',
+  '.prisma',
+]);
+
 // Dirs/files to skip when collecting sources
 const SKIP_DIRS = new Set([
   'node_modules', '.git', 'dist', 'build', '.turbo', '.next',
@@ -33,13 +71,21 @@ const SKIP_DIRS = new Set([
   '.aioson', '.claude', '.gemini', '.codex', 'researchs',
 ]);
 
+const SKIP_DIRS_BUILD = new Set([
+  'node_modules', '.git', '.turbo', '.next',
+  '.cache', 'coverage', '.nyc_output',
+  'src', 'dashboard/src',
+  '.aioson', '.claude', '.gemini', '.codex', 'researchs',
+]);
+
 const SKIP_FILES = new Set([
   'package-lock.json', 'yarn.lock', 'pnpm-lock.yaml',
   'bun.lockb',
 ]);
 
-const MAX_FILE_BYTES = 512 * 1024;        // 512 KB per file
-const MAX_PACKAGE_BYTES = 20 * 1024 * 1024; // 20 MB total
+const MAX_FILE_BYTES = 512 * 1024;             // 512 KB per file (source)
+const MAX_FILE_BYTES_BUILD = 2 * 1024 * 1024;  // 2 MB per file (compiled bundles)
+const MAX_PACKAGE_BYTES = 20 * 1024 * 1024;    // 20 MB total
 
 /**
  * Parseia lista de emails autorizados a partir de:
@@ -114,15 +160,18 @@ async function storeGet(url, token) {
  * Collect all eligible source files under `dir`.
  * Returns { relativePath: content } — only text files with allowed extensions.
  */
-async function collectSystemFiles(dir) {
+async function collectSystemFiles(dir, { buildMode = false } = {}) {
   const files = {};
   let totalBytes = 0;
   const errors = [];
+  const skipDirs = buildMode ? SKIP_DIRS_BUILD : SKIP_DIRS;
+  const allowedExts = buildMode ? SYSTEM_BUILD_ALLOWED_EXTS : SYSTEM_ALLOWED_EXTS;
 
   async function walk(current, rel) {
     const entries = await fs.readdir(current, { withFileTypes: true });
     for (const entry of entries) {
-      if (SKIP_DIRS.has(entry.name)) continue;
+      if (skipDirs.has(entry.name)) continue;
+      if (rel && skipDirs.has(`${rel}/${entry.name}`)) continue;
       if (SKIP_FILES.has(entry.name)) continue;
 
       const fullPath = path.join(current, entry.name);
@@ -137,12 +186,12 @@ async function collectSystemFiles(dir) {
         ? `.${entry.name.split('.').pop().toLowerCase()}`
         : '';
 
-      // Allow dotfiles with no extension (like .gitignore) that match skip list check
-      if (!SYSTEM_ALLOWED_EXTS.has(ext) && ext !== '') continue;
+      if (!allowedExts.has(ext) && ext !== '') continue;
 
       try {
         const stat = await fs.stat(fullPath);
-        if (stat.size > MAX_FILE_BYTES) {
+        const maxBytes = buildMode ? MAX_FILE_BYTES_BUILD : MAX_FILE_BYTES;
+        if (stat.size > maxBytes) {
           errors.push(`File too large (skipped): "${relPath}" (${(stat.size / 1024).toFixed(0)} KB)`);
           continue;
         }
@@ -151,7 +200,25 @@ async function collectSystemFiles(dir) {
           errors.push(`Package exceeds ${MAX_PACKAGE_BYTES / 1024 / 1024} MB limit — stop collecting.`);
           return;
         }
-        const content = await fs.readFile(fullPath, 'utf8');
+        let content = await fs.readFile(fullPath, 'utf8');
+
+        if (buildMode && (ext === '.js' || ext === '.mjs' || ext === '.cjs')) {
+          try {
+            const terser = getTerser();
+            const result = await terser.minify(content, {
+              compress: { passes: 2, drop_console: false },
+              mangle: {
+                toplevel: true,
+                properties: { regex: /^_/ },
+              },
+              format: { comments: false },
+            });
+            if (result.code) content = result.code;
+          } catch {
+            // terser failed on this file — keep original compiled JS
+          }
+        }
+
         files[relPath] = content;
       } catch {
         // binary or unreadable — skip silently
@@ -231,13 +298,27 @@ async function runSystemPublish({ args, options, logger, t }) {
   const config = await readConfig();
   const token = requireToken(config, t);
   const dir = path.resolve(process.cwd(), args[0] || '.');
+  const buildMode = Boolean(options.build);
 
   logger.log(t('system.publish_reading_manifest'));
   const manifest = await readSystemJson(dir, t);
   logger.log(t('system.package_manifest_ok', { slug: manifest.slug, version: manifest.version, name: manifest.name }));
 
-  logger.log(t('system.package_collecting_files'));
-  const { files, totalBytes, errors } = await collectSystemFiles(dir);
+  if (buildMode) {
+    const buildCmd = manifest.build_command || 'npm run build';
+    logger.log(`Building: ${buildCmd}`);
+    const { execSync } = require('child_process');
+    try {
+      execSync(buildCmd, { cwd: dir, stdio: 'inherit', timeout: 300_000 });
+    } catch (e) {
+      throw new Error(`Build failed: ${e.message}`);
+    }
+    logger.log('Build complete. Collecting compiled output (source excluded)...');
+  } else {
+    logger.log(t('system.package_collecting_files'));
+  }
+
+  const { files, totalBytes, errors } = await collectSystemFiles(dir, { buildMode });
 
   if (errors.length > 0) {
     for (const e of errors) logger.log(`  [WARN] ${e}`);
@@ -268,13 +349,24 @@ async function runSystemPublish({ args, options, logger, t }) {
     return { ok: true, dryRun: true, manifest, fileCount, totalBytes, visibility, authorizedEmails };
   }
 
+  logger.log('Creating ZIP package...');
+  const zipBuffer = await createZipBuffer(files);
+  const MAX_ZIP_BYTES = 2 * 1024 * 1024;
+  if (zipBuffer.length > MAX_ZIP_BYTES) {
+    throw new Error(`ZIP exceeds 2 MB limit (${(zipBuffer.length / 1024 / 1024).toFixed(2)} MB). Reduce the number of files or bundle size.`);
+  }
+  const zipBase64 = zipBuffer.toString('base64');
+  const zipKb = (zipBuffer.length / 1024).toFixed(1);
+  logger.log(`ZIP: ${zipKb} KB (${fileCount} files)`);
+
   logger.log(t('system.publish_sending'));
   const baseUrl = resolveBaseUrl(config);
   const response = await storePost(`${baseUrl}/api/store/systems/publish`, {
     kind: 'aioson.store.system',
     slug: manifest.slug,
     version: manifest.version,
-    files,
+    zipBase64,
+    files: buildMode ? undefined : files,
     manifest,
     visibility,
     paid,
@@ -283,7 +375,7 @@ async function runSystemPublish({ args, options, logger, t }) {
   }, token);
 
   logger.log(t('system.publish_done', { slug: manifest.slug, url: `${baseUrl}/store/systems/${manifest.slug}` }));
-  logger.log(t('system.publish_summary', { files: fileCount, kb: (totalBytes / 1024).toFixed(1) }));
+  logger.log(t('system.publish_summary', { files: fileCount, kb: zipKb }));
   return { ok: true, manifest, fileCount, totalBytes, visibility, paid, response };
 }
 

package/src/commands/tool-capabilities.js

@@ -6,9 +6,9 @@ const { TOOL_CAPS, getToolCapabilities, listSupportedTools } = require('../lib/t
 // so external clients (AIOSON Play, IDE extensions) can drive UI without
 // hard-coding their own copy of this lookup.
 //
-// Usage:
-//   aioson tool:capabilities --json
-//   aioson tool:capabilities --tool=claude --json
+// Usage:
+//   aioson tool:capabilities --json
+//   aioson tool:capabilities --tool=claude --json
 async function runToolCapabilities({ args: _args, options = {}, logger, t: _t }) {
   const tool = options.tool ? String(options.tool).trim() : null;
 
@@ -22,8 +22,8 @@ async function runToolCapabilities({ args: _args, options = {}, logger, t: _t })
     payload = { tool: tool.toLowerCase(), capabilities: caps };
   } else {
     payload = {
-      tools: TOOL_CAPS,
-      schema_version: 1,
+      tools: TOOL_CAPS,
+      schema_version: 2,
     };
   }
 
@@ -37,8 +37,8 @@ async function runToolCapabilities({ args: _args, options = {}, logger, t: _t })
     const caps = payload.capabilities;
     logger.log(`Tool: ${payload.tool}`);
     logger.log(`  binary:                ${caps.binary}`);
-    logger.log(`  install_command:       ${caps.install_command}`);
-    logger.log(`  supports_resume:       ${caps.supports_resume}`);
+    logger.log(`  install_command:       ${caps.install_command}`);
+    logger.log(`  supports_resume:       ${caps.supports_resume}`);
     if (caps.supports_resume) {
       logger.log(`  resume_last:           ${(caps.resume_last || []).join(' ')}`);
       logger.log(`  supports_session_id:   ${caps.supports_session_id}`);
@@ -48,9 +48,13 @@ async function runToolCapabilities({ args: _args, options = {}, logger, t: _t })
       logger.log(`  supports_session_picker: ${caps.supports_session_picker}`);
       if (caps.supports_session_picker) {
         logger.log(`  session_picker:        ${(caps.session_picker || []).join(' ')}`);
-      }
-    }
-  } else {
+      }
+    }
+    logger.log(`  supports_yolo:         ${caps.supports_yolo}`);
+    if (caps.supports_yolo) {
+      logger.log(`  yolo_args:             ${(caps.yolo_args || []).join(' ')}`);
+    }
+  } else {
     logger.log(`Supported tools: ${listSupportedTools().join(', ')}`);
     logger.log(`Run with --tool=<name> for details, or --json for the full map.`);
   }

package/src/commands/workflow-heal.js

@@ -12,6 +12,7 @@
  */
 
 const path = require('node:path');
+const fs = require('node:fs/promises');
 const {
   loadOrCreateState,
   activateStage,
@@ -26,6 +27,28 @@ const {
   incrementRetryCount,
   buildHealingActivation
 } = require('../self-healing');
+const { CHECKPOINTS_DIR } = require('./gate-approve');
+
+const GATE_ORDER = ['D', 'C', 'B', 'A'];
+
+async function readLatestCheckpoint(targetDir, slug) {
+  const dir = path.join(targetDir, CHECKPOINTS_DIR);
+  try {
+    const files = await fs.readdir(dir);
+    const matching = files
+      .filter((f) => f.endsWith(`-${slug}.json`))
+      .sort((a, b) => {
+        const gateA = a.replace('gate-', '').charAt(0);
+        const gateB = b.replace('gate-', '').charAt(0);
+        return GATE_ORDER.indexOf(gateA) - GATE_ORDER.indexOf(gateB);
+      });
+    if (matching.length === 0) return null;
+    const raw = await fs.readFile(path.join(dir, matching[0]), 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
 
 async function runWorkflowHeal({ args, options, logger, t }) {
   const targetDir = path.resolve(process.cwd(), args[0] || '.');
@@ -58,6 +81,10 @@ async function runWorkflowHeal({ args, options, logger, t }) {
     return { ok: false, reason: 'stage_not_in_sequence' };
   }
 
+  // M1 checkpoint-at-gate: read latest checkpoint for recovery context (EC-AO-02: graceful fallback)
+  const featureSlug = state.featureSlug || null;
+  const checkpoint = featureSlug ? await readLatestCheckpoint(targetDir, featureSlug) : null;
+
   // Build healing activation
   let activation;
   try {
@@ -74,6 +101,24 @@ async function runWorkflowHeal({ args, options, logger, t }) {
     return { ok: false, reason: 'activation_failed', error: err.message };
   }
 
+  if (checkpoint) {
+    const sanitize = (s) => String(s || '').replace(/[\r\n]+/g, ' ').slice(0, 200);
+    const files = Array.isArray(checkpoint.prerequisites_snapshot)
+      ? checkpoint.prerequisites_snapshot.map((s) => sanitize(s && s.file)).join(', ') || 'none'
+      : 'none';
+    const cpBlock = [
+      '',
+      '## Checkpoint Recovery Context (auto-injected by AIOSON motor)',
+      '',
+      `> Last approved gate: **${sanitize(checkpoint.gate)}** (${sanitize(checkpoint.timestamp)})`,
+      `> Approved by: ${sanitize(checkpoint.agent)}`,
+      `> Artifacts at gate time: ${files}`,
+      ''
+    ].join('\n');
+    activation.prompt = activation.prompt + cpBlock;
+    activation.checkpoint = checkpoint;
+  }
+
   // Increment retry counter
   const newCount = await incrementRetryCount(targetDir, stage, activation.prompt.substring(0, 200));
 
@@ -127,10 +172,11 @@ async function runWorkflowHeal({ args, options, logger, t }) {
     retryCount: newCount,
     maxRetries: 3,
     runtime,
+    checkpoint: checkpoint || null,
     agent: activation.agent,
     instructionPath: activation.instructionPath,
     prompt: activation.prompt
   };
 }
 
-module.exports = { runWorkflowHeal };
+module.exports = { runWorkflowHeal, readLatestCheckpoint };

package/src/i18n/messages/en.js

@@ -219,7 +219,7 @@ module.exports = {
     help_runtime_emit:
       'aioson runtime:emit [path] --agent=<name> [--type=<event>] [--summary=<text>] [--title=<text>] [--refs=<file[,file2]>] [--plan-step=<id>] [--meta=<json>] [--json] [--locale=en]',
     help_live_start:
-      'aioson live:start [path] --tool=codex|claude|gemini|opencode --agent=<name> [--tool-bin=<binary>] [--tool-args=<args>] [--title=<text>] [--goal=<text>] [--plan=<file>] [--session=<key>] [--message=<text>] [--attach] [--no-launch] [--tmux] [--json] [--locale=en]',
+      'aioson live:start [path] --tool=codex|claude|gemini|opencode --agent=<name> [--tool-bin=<binary>] [--permission-mode=default|yolo] [--tool-args=<args>] [--title=<text>] [--goal=<text>] [--plan=<file>] [--session=<key>] [--message=<text>] [--attach] [--no-launch] [--tmux] [--json] [--locale=en]',
     help_live_status:
       'aioson live:status [path] [--agent=<name>] [--limit=8] [--watch=2] [--format=compact|tmux-bar] [--json] [--locale=en]',
     help_live_handoff:
@@ -1090,10 +1090,11 @@ module.exports = {
     plan_not_found: 'Plan file not found: {plan}',
     no_active_session: 'No active live session found for {agent}.',
     session_not_active: 'Live session for {agent} is not active.',
-    json_requires_no_launch: '--json requires --no-launch for live:start because foreground launch is interactive.',
-    tool_binary_not_found: 'Tool binary not found in PATH: {binary}',
-    tool_mismatch: 'Active session uses tool "{existing}" but --tool={requested} was given. Close the session first or use the same tool.',
-    micro_task_already_open: 'A live micro-task is already open for {agent}. Emit task_completed before task_started again.',
+    json_requires_no_launch: '--json requires --no-launch for live:start because foreground launch is interactive.',
+    tool_binary_not_found: 'Tool binary not found in PATH: {binary}',
+    tool_mismatch: 'Active session uses tool "{existing}" but --tool={requested} was given. Close the session first or use the same tool.',
+    tool_mismatch_auto_closed: 'Previous live session used "{existing}" and was auto-closed. Starting a new session with "{requested}".',
+    micro_task_already_open: 'A live micro-task is already open for {agent}. Emit task_completed before task_started again.',
     handoff_same_agent: 'live:handoff requires different --agent and --to values.',
     handoff_agent_mismatch: 'No active live session found for {agent}.',
     watch_json_conflict: '--watch cannot be combined with --json.',