@aiwg/cli 2026.9.6 → 2026.9.9

package/dist/src/mcp/registry.mjs

@@ -1,4 +1,5 @@
 import { manageOmpMcp } from './omp-config.mjs';
+import { replaceServer } from './toml-editor.mjs';
 import { resolveOmpPaths } from '../providers/omp-paths.mjs';
 /**
  * MCP Server Registry (Runtime ESM)
@@ -269,18 +270,31 @@ function buildServerConfig(server, provider) {
   }
 }
 
+function tomlString(value) {
+  if (typeof value !== 'string' || [...value].some(char => {
+    const point = char.codePointAt(0);
+    return point >= 0xd800 && point <= 0xdfff;
+  })) throw new Error('TOML values must be strings containing valid Unicode scalar values');
+  // JSON escapes align with TOML basic strings except DEL must also be escaped.
+  return JSON.stringify(value).replace(/\u007f/g, '\\u007f');
+}
+
+function tomlKey(value) {
+  return typeof value === 'string' && /^[A-Za-z0-9_-]+$/.test(value) ? value : tomlString(value);
+}
+
 function buildServerToml(server) {
   const lines = [];
-  lines.push(`[mcp_servers.${server.name}]`);
+  lines.push(`[mcp_servers.${tomlKey(server.name)}]`);
 
   if (server.type === 'stdio') {
-    lines.push(`command = "${server.command}"`);
+    lines.push(`command = ${tomlString(server.command)}`);
     if (server.args && server.args.length > 0) {
-      const argsStr = server.args.map(a => `"${a}"`).join(', ');
+      const argsStr = server.args.map(a => tomlString(a)).join(', ');
       lines.push(`args = [${argsStr}]`);
     }
   } else {
-    lines.push(`url = "${server.url}"`);
+    lines.push(`url = ${tomlString(server.url)}`);
   }
 
   lines.push(`startup_timeout_sec = 10.0`);
@@ -344,12 +358,20 @@ async function injectJson(registry, servers, configPath, provider, dryRun, resul
     const content = await readFile(configPath, 'utf-8');
     existing = JSON.parse(content);
   } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new Error(`Refusing to overwrite malformed MCP config ${configPath}: invalid JSON`);
+    }
     if (normalizeRuntimeProviderId(provider) === 'antigravity' && error?.code !== 'ENOENT') {
       throw new Error(`Refusing to overwrite malformed MCP config ${configPath}: ${error.message}`);
     }
+    if (error?.code !== 'ENOENT') throw error;
   }
 
   const mcpKey = getMcpInjectionDefinition(provider)?.serversKey || 'mcpServers';
+  const isObject = value => value !== null && typeof value === 'object' && !Array.isArray(value);
+  if (!isObject(existing) || (Object.hasOwn(existing, mcpKey) && !isObject(existing[mcpKey]))) {
+    throw new Error('MCP configuration must contain an object root and an object server map');
+  }
   const existingServers = existing[mcpKey] || {};
   const newServers = { ...existingServers };
 
@@ -381,30 +403,17 @@ async function injectToml(registry, servers, configPath, provider, dryRun, resul
   let existing = '';
   try {
     existing = await readFile(configPath, 'utf-8');
-  } catch {
-    // File doesn't exist
+  } catch (error) {
+    if (error.code !== 'ENOENT') throw error;
   }
 
-  const sectionsToAdd = [];
-
   for (const server of servers) {
-    const sectionHeader = `[mcp_servers.${server.name}]`;
-    if (existing.includes(sectionHeader)) {
-      const sectionRegex = new RegExp(
-        `\\[mcp_servers\\.${escapeRegex(server.name)}\\][\\s\\S]*?(?=\\n\\[|$)`,
-      );
-      existing = existing.replace(sectionRegex, buildServerToml(server));
-      result.alreadyPresent.push(server.name);
-    } else {
-      sectionsToAdd.push(buildServerToml(server));
-    }
+    const edited = replaceServer(existing, server.name, buildServerToml(server));
+    existing = edited.text;
+    if (edited.alreadyPresent) result.alreadyPresent.push(server.name);
     result.serversInjected.push(server.name);
   }
 
-  if (sectionsToAdd.length > 0) {
-    existing = existing.trimEnd() + '\n\n' + sectionsToAdd.join('\n\n') + '\n';
-  }
-
   if (!dryRun) {
     await mkdir(resolve(configPath, '..'), { recursive: true });
     await writeFile(configPath, existing, 'utf-8');
@@ -417,8 +426,4 @@ async function injectToml(registry, servers, configPath, provider, dryRun, resul
   return result;
 }
 
-function escapeRegex(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-
 export const SUPPORTED_PROVIDERS = listMcpInjectProviderIds();

package/dist/src/mcp/toml-editor.mjs

@@ -0,0 +1,117 @@
+// Pure source-range editing; provider filesystem access belongs to the caller.
+import { parseTOML } from 'toml-eslint-parser';
+
+const keys = node => node.key.keys.map(key => key.type === 'TOMLBare' ? key.name : key.value);
+const starts = (path, prefix) => prefix.every((key, index) => path[index] === key);
+function parse(text) {
+  try { return parseTOML(text, { tomlVersion: '1.0.0' }); }
+  catch { throw new Error('Invalid TOML configuration; no changes made'); }
+}
+
+export function replaceServer(text, name, section) {
+  const ast = parse(text);
+  const target = ['mcp_servers', name];
+  const replacement = parse(section).body[0].body;
+  if (replacement.length !== 1 || replacement[0].type !== 'TOMLTable' ||
+      replacement[0].resolvedKey.length !== 2 || !starts(replacement[0].resolvedKey, target)) {
+    throw new Error('Invalid replacement server definition');
+  }
+  const inline = '{ ' + replacement[0].body.map(node => section.slice(...node.range)).join(', ') + ' }';
+  const encodedName = section.slice(...replacement[0].key.keys[1].range);
+  const edits = [];
+  let present = false;
+  let placed = false;
+  const edit = (range, value = '') => edits.push({ start: range[0], end: range[1], value });
+
+  function inspectValue(node, path) {
+    if (path[0] === 'mcp_servers') {
+      if (path.length <= 2 && node.type !== 'TOMLInlineTable') {
+        throw new Error('MCP configuration and server entries must be TOML tables');
+      }
+      if (starts(path, target)) present = true;
+    }
+    if (node.type === 'TOMLInlineTable') {
+      for (const entry of node.body) inspectValue(entry.value, [...path, ...keys(entry)]);
+    }
+  }
+  for (const node of ast.body[0].body) {
+    if (node.type === 'TOMLTable') {
+      const path = node.resolvedKey;
+      if (path[0] === 'mcp_servers' &&
+          (typeof path[1] === 'number' || typeof path[2] === 'number')) {
+        throw new Error('MCP configuration and server entries must not be TOML arrays of tables');
+      }
+      if (starts(path, target)) present = true;
+      for (const entry of node.body) inspectValue(entry.value, [...path, ...keys(entry)]);
+    } else inspectValue(node.value, keys(node));
+  }
+
+  const selectedTables = ast.body[0].body.filter(node => node.type === 'TOMLTable' && starts(node.resolvedKey, target));
+  if (selectedTables.length === 1 && text.slice(...selectedTables[0].range) === section) {
+    return { text, alreadyPresent: true };
+  }
+  if (selectedTables.length === 1 && selectedTables[0].resolvedKey.length === 2) {
+    const [start, end] = selectedTables[0].range;
+    if (!ast.comments.some(comment => comment.range[0] >= start && comment.range[0] < end)) {
+      const output = text.slice(0, start) + section + text.slice(end);
+      parse(output);
+      return { text: output, alreadyPresent: true };
+    }
+  }
+
+  function editInlineMap(node) {
+    const entries = node.body;
+    const selected = entries.map((entry, index) => keys(entry)[0] === name ? index : -1).filter(index => index >= 0);
+    if (selected.length === 0) {
+      edit([node.range[1] - 1, node.range[1] - 1], `${entries.length ? ', ' : ''}${encodedName} = ${inline}`);
+    } else {
+      const first = selected[0];
+      if (keys(entries[first]).length === 1) edit(entries[first].value.range, inline);
+      else edit(entries[first].range, `${encodedName} = ${inline}`);
+      // Keep the first selected entry as the replacement anchor. Remove each
+      // subsequent contiguous run together with one separator, never a neighbor.
+      for (let cursor = 1; cursor < selected.length;) {
+        const start = selected[cursor];
+        let end = start;
+        while (cursor + 1 < selected.length && selected[cursor + 1] === end + 1) {
+          cursor++;
+          end++;
+        }
+        if (end + 1 < entries.length) edit([entries[start].range[0], entries[end + 1].range[0]]);
+        else edit([entries[start - 1].range[1], entries[end].range[1]]);
+        cursor++;
+      }
+    }
+    placed = true;
+  }
+  function planEntry(entry, base) {
+    const path = [...base, ...keys(entry)];
+    if (path.length === 1 && path[0] === 'mcp_servers') {
+      editInlineMap(entry.value);
+    } else if (starts(path, target)) {
+      if (path.length === 2) {
+        edit(entry.value.range, inline);
+        placed = true;
+      } else edit(entry.range);
+    }
+  }
+  for (const node of ast.body[0].body) {
+    if (node.type !== 'TOMLTable') { planEntry(node, []); continue; }
+    if (starts(node.resolvedKey, target)) {
+      const closing = ast.tokens.filter(token => token.range[0] >= node.key.range[1] && token.value === ']');
+      const last = closing[node.kind === 'array' ? 1 : 0];
+      if (!last) throw new Error('Invalid TOML table range');
+      edit([node.range[0], last.range[1]]);
+      for (const entry of node.body) edit(entry.range);
+    } else for (const entry of node.body) planEntry(entry, node.resolvedKey);
+  }
+  edits.sort((a, b) => a.start - b.start || a.end - b.end);
+  for (let index = 1; index < edits.length; index++) {
+    if (edits[index].start < edits[index - 1].end) throw new Error('Overlapping TOML edit ranges');
+  }
+  let output = text;
+  for (const change of edits.reverse()) output = output.slice(0, change.start) + change.value + output.slice(change.end);
+  if (!placed) output += `${output.endsWith('\n') ? '' : '\n'}\n${section}\n`;
+  parse(output);
+  return { text: output, alreadyPresent: present };
+}

package/dist/src/mcp/tools/orchestration.mjs

@@ -235,13 +235,13 @@ export function registerMissionToolset(server) {
       session_id: z.string().describe('Existing Mission Control session id from mc-start / mc-list'),
       objective: z.string().describe('Mission objective'),
       completion: z.string().describe('Measurable completion criterion'),
-      max_iterations: z.number().int().positive().optional().describe('Ralph iteration cap'),
-      max_total_tokens: z.number().int().positive().optional().describe('Hard cumulative token ceiling'),
-      max_output_tokens: z.number().int().positive().optional().describe('Hard cumulative output-token ceiling'),
-      max_tool_calls: z.number().int().positive().optional().describe('Hard cumulative tool-call ceiling'),
-      max_total_cost: z.number().positive().optional().describe('Hard cumulative provider-reported spend ceiling'),
-      max_wall_clock_minutes: z.number().positive().optional().describe('Hard cumulative runtime ceiling'),
-      exploration_quota: z.number().int().positive().optional().describe('Require structural variant after this many flat cycles (off unless declared; no default K)'),
+      max_iterations: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).optional().describe('Ralph iteration cap'),
+      max_total_tokens: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).optional().describe('Hard cumulative token ceiling'),
+      max_output_tokens: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).optional().describe('Hard cumulative output-token ceiling'),
+      max_tool_calls: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).optional().describe('Hard cumulative tool-call ceiling'),
+      max_total_cost: z.number().positive().finite().optional().describe('Hard cumulative provider-reported spend ceiling'),
+      max_wall_clock_minutes: z.number().positive().finite().optional().describe('Hard cumulative runtime ceiling'),
+      exploration_quota: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).optional().describe('Require structural variant after this many flat cycles (off unless declared; no default K)'),
       budget_stop_policy: z.enum(['completion-wins', 'budget-wins']).optional().describe('Stop semantics when the completing iteration crosses a ceiling (default: completion-wins)'),
       project_dir: z.string().optional().describe('Project directory for CLI dispatch'),
       confirmed: z.boolean().default(false).describe('Required for durable/long-running mission dispatch'),

package/dist/src/mcp/tools/subsystems.mjs

@@ -413,13 +413,13 @@ function registerMcToolset(server) {
       session_id: z.string().describe('Session id'),
       objective: z.string().describe('Mission objective'),
       completion: z.string().optional().describe('Completion criteria'),
-      max_iterations: z.number().int().positive().optional().describe('Ralph iteration cap'),
-      max_total_tokens: z.number().int().positive().optional().describe('Hard cumulative token ceiling'),
-      max_output_tokens: z.number().int().positive().optional().describe('Hard cumulative output-token ceiling'),
-      max_tool_calls: z.number().int().positive().optional().describe('Hard cumulative tool-call ceiling'),
-      max_total_cost: z.number().positive().optional().describe('Hard cumulative provider-reported spend ceiling'),
-      max_wall_clock_minutes: z.number().positive().optional().describe('Hard cumulative runtime ceiling'),
-      exploration_quota: z.number().int().positive().optional().describe('Require structural variant after this many flat cycles (off unless declared; no default K)'),
+      max_iterations: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).optional().describe('Ralph iteration cap'),
+      max_total_tokens: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).optional().describe('Hard cumulative token ceiling'),
+      max_output_tokens: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).optional().describe('Hard cumulative output-token ceiling'),
+      max_tool_calls: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).optional().describe('Hard cumulative tool-call ceiling'),
+      max_total_cost: z.number().positive().finite().optional().describe('Hard cumulative provider-reported spend ceiling'),
+      max_wall_clock_minutes: z.number().positive().finite().optional().describe('Hard cumulative runtime ceiling'),
+      exploration_quota: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).optional().describe('Require structural variant after this many flat cycles (off unless declared; no default K)'),
       budget_stop_policy: z.enum(['completion-wins', 'budget-wins']).optional().describe('Stop semantics when the completing iteration crosses a ceiling (default: completion-wins)'),
     },
     buildArgs: ({

package/dist/src/memory/context-pack.js

@@ -265,6 +265,7 @@ export function buildContextPack(task, candidates, options = {}) {
     };
 }
 export function buildWorkspaceContextPack(projectRoot, task, options = {}) {
+    const started = performance.now();
     if (!task.trim())
         throw new Error('context task must be nonblank');
     const root = realpathSync(projectRoot);
@@ -277,6 +278,9 @@ export function buildWorkspaceContextPack(projectRoot, task, options = {}) {
             return indexed.length > 0 ? indexed : wikiCandidates(root, taskTerms, maxFiles);
         })(),
     ];
-    return buildContextPack(task, candidates, { ...options, maxFiles });
+    const pack = buildContextPack(task, candidates, { ...options, maxFiles });
+    // Workspace callers need retrieval plus assembly latency, not assembly alone.
+    pack.metrics.elapsedMs = Number((performance.now() - started).toFixed(3));
+    return pack;
 }
 //# sourceMappingURL=context-pack.js.map

package/dist/src/plugin/skill-command-translator.js

@@ -11,8 +11,63 @@
  * @implements .aiwg/architecture/adr-skills-canonical-extension-type.md
  * @issue #550
  */
+import { createHash } from 'node:crypto';
 import fs from 'fs/promises';
 import path from 'path';
+/**
+ * Ownership signal for generated command files (#2507).
+ *
+ * Command wrappers were written as bare files: no `aiwg:managed` marker and no
+ * `.aiwg-manifest.json` entry. AIWG could neither count them as deployed nor
+ * recognise them as its own, so a later run reported the wrappers it had just
+ * written as unmanaged artifacts the operator should delete. They now carry the
+ * same signals as any other deployed artifact, tagged `skill-command` so the
+ * flat-command prune leaves them to the skills prune that governs their source.
+ */
+const MANAGED_SIDECAR = '.aiwg-manifest.json';
+const MANAGED_MARKER_PATTERN = /^(?:<!--\s*aiwg:managed\s|#\s*aiwg:managed\s)/m;
+function addManagedMarker(content, version, source) {
+    if (MANAGED_MARKER_PATTERN.test(content))
+        return content;
+    if (content.startsWith('---\n')) {
+        return content.replace(/^---\n/, `---\n# aiwg:managed v${version} ${source}\n`);
+    }
+    return `<!-- aiwg:managed v${version} ${source} -->\n${content}`;
+}
+/**
+ * Merge generated command entries into a directory's managed sidecar.
+ *
+ * Best-effort: a translation that cannot record ownership still produced a
+ * usable command file, so a sidecar failure must not fail the deploy.
+ */
+async function recordManagedCommands(targetDir, entries, version, source) {
+    if (entries.length === 0)
+        return;
+    const sidecarPath = path.join(targetDir, MANAGED_SIDECAR);
+    let sidecar = { managed: {} };
+    try {
+        const parsed = JSON.parse(await fs.readFile(sidecarPath, 'utf-8'));
+        if (parsed && typeof parsed === 'object' && parsed.managed)
+            sidecar = parsed;
+    }
+    catch {
+        // No sidecar yet, or unreadable — start a fresh managed map.
+    }
+    for (const entry of entries) {
+        sidecar.managed[entry.filename] = {
+            hash: `sha256:${createHash('sha256').update(entry.content).digest('hex')}`,
+            source,
+            version,
+            kind: 'skill-command',
+        };
+    }
+    try {
+        await fs.writeFile(sidecarPath, `${JSON.stringify(sidecar, null, 2)}\n`, 'utf-8');
+    }
+    catch {
+        // Non-fatal — the command files themselves are already written.
+    }
+}
 // ============================================
 // Provider Configuration
 // ============================================
@@ -280,6 +335,9 @@ export async function translateSkillsToCommands(skillsDir, options) {
         errors: [],
         totalProcessed: 0,
     };
+    // Ownership records for the commands this call writes (#2507).
+    const managedEntries = [];
+    const promptEntries = [];
     // Check if this provider needs commands. nameFilter overrides the
     // provider gating: when an operator passes an explicit filter (e.g. Claude
     // flow→command emission per PUW-015 #1116), they're opting in to selective
@@ -328,7 +386,7 @@ export async function translateSkillsToCommands(skillsDir, options) {
                 continue;
             }
             // Generate command content
-            const commandContent = generateCommandContent(skillName, frontmatter, body, options.provider);
+            const commandContent = addManagedMarker(generateCommandContent(skillName, frontmatter, body, options.provider), options.deployVersion ?? 'unknown', 'bundled');
             const commandFilename = `${skillName}.md`;
             const translated = {
                 sourcePath: skillMdPath,
@@ -353,7 +411,9 @@ export async function translateSkillsToCommands(skillsDir, options) {
                     const promptPath = path.join(promptsDir, `${skillName}.prompt.md`);
                     await fs.mkdir(promptsDir, { recursive: true });
                     await fs.writeFile(promptPath, commandContent, 'utf-8');
+                    promptEntries.push({ filename: `${skillName}.prompt.md`, content: commandContent });
                 }
+                managedEntries.push({ filename: commandFilename, content: commandContent });
             }
             result.translated.push(translated);
             if (options.verbose) {
@@ -373,6 +433,15 @@ export async function translateSkillsToCommands(skillsDir, options) {
             }
         }
     }
+    if (!options.dryRun) {
+        const version = options.deployVersion ?? 'unknown';
+        await recordManagedCommands(options.targetDir, managedEntries, version, 'bundled');
+        if (promptEntries.length > 0) {
+            const projectRoot = options.projectPath
+                ?? path.dirname(path.dirname(options.targetDir));
+            await recordManagedCommands(path.join(projectRoot, '.github', 'prompts'), promptEntries, version, 'bundled');
+        }
+    }
     return result;
 }
 /**

package/dist/src/serve/a2a-terminal-observer.js

@@ -8,12 +8,24 @@
  *
  * @issue #1374
  */
-import { A2AClient } from '../a2a/client.js';
+import { A2AClient, A2A_HITL_PROMPT_V1 } from '../a2a/client.js';
 import { isTerminalTaskState, } from '../a2a/types.js';
 import { extractGraphMetadata } from '../flow/graph-metadata.js';
+import { extractHitlEnvelope } from '../a2a/hitl.js';
 const DEFAULT_POLL_INTERVAL_MS = 1000;
 const DEFAULT_MAX_POLLS = 300;
 export async function observeA2ATerminalState(registry, executor, missionId, a2aInstanceId, initialTask, opts = {}) {
+    const mission = registry.getMission(missionId);
+    if (mission && !(mission.a2a?.taskId === initialTask.id
+        && mission.a2a.instanceId === a2aInstanceId)) {
+        mission.a2a = {
+            instanceId: a2aInstanceId, taskId: initialTask.id,
+            ...(initialTask.contextId ? { contextId: initialTask.contextId } : {}),
+            protocolVersion: opts.protocolVersion ?? '0.3',
+            ...(opts.selectedInterface ? { selectedInterface: opts.selectedInterface } : {}),
+            acceptedPrompts: new Set(),
+        };
+    }
     try {
         const clientOpts = {
             baseUrl: executor.transportEndpoints.rest,
@@ -21,6 +33,7 @@ export async function observeA2ATerminalState(registry, executor, missionId, a2a
             instanceId: a2aInstanceId,
             protocolVersion: opts.protocolVersion ?? '0.3',
             protocolPolicy: opts.protocolVersion ?? '0.3',
+            optionalExtensions: [A2A_HITL_PROMPT_V1],
         };
         if (opts.selectedInterface)
             clientOpts.selectedInterface = opts.selectedInterface;
@@ -38,6 +51,9 @@ export async function observeA2ATerminalState(registry, executor, missionId, a2a
                 break;
             await sleep(opts.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS);
             task = await client.getTask(task.id);
+            if (task.id !== initialTask.id || task.contextId !== initialTask.contextId) {
+                throw new Error('A2A observer task binding changed');
+            }
             emitNonTerminalProgress(registry, executor.executorId, missionId, task);
         }
         registry.failMission(missionId, `A2A task ${initialTask.id} did not reach a terminal state before observer timeout`);
@@ -58,10 +74,12 @@ function emitNonTerminalProgress(registry, executorId, missionId, task) {
         return;
     }
     if (state === 'input-required') {
+        const prompt = extractHitlEnvelope(task);
         registry.handleEvent(makeEnvelope('mission.hitl_required', executorId, missionId, task, {
             state: 'hitl-required',
             a2a_task_id: task.id,
             summary: taskStatusSummary(task),
+            ...(prompt?.ok ? { hitl_id: prompt.envelope.prompt_id, hitl_prompt: prompt.envelope } : {}),
         }));
     }
 }

package/dist/src/serve/mission-hitl.js

@@ -0,0 +1,91 @@
+/** A2A approval routing for the public mission API. */
+import { createHash, randomUUID } from 'node:crypto';
+import Ajv from 'ajv';
+import { A2AClient, A2A_HITL_PROMPT_V1 } from '../a2a/client.js';
+import { buildHitlResponseMessage, extractHitlEnvelope } from '../a2a/hitl.js';
+export async function respondToA2AMission(registry, missionId, promptId, response, opts = {}) {
+    const mission = registry.getMission(missionId);
+    const binding = mission?.a2a;
+    const executor = mission && registry.getRegistration(mission.executorId);
+    if (!mission || !binding || !executor)
+        return reply(404, 'mission_binding_not_found');
+    if (binding.responding || binding.acceptedPrompts.has(promptId))
+        return reply(409, 'approval_already_submitted');
+    if (['done', 'failed', 'aborted'].includes(mission.state))
+        return reply(409, 'mission_terminal');
+    binding.responding = true;
+    try {
+        const client = new A2AClient({
+            baseUrl: executor.transportEndpoints.rest,
+            bearer: executor.token,
+            instanceId: binding.instanceId,
+            protocolVersion: binding.protocolVersion,
+            protocolPolicy: binding.protocolVersion,
+            optionalExtensions: [A2A_HITL_PROMPT_V1],
+            ...(binding.selectedInterface ? { selectedInterface: binding.selectedInterface } : {}),
+            ...(opts.fetch ? { fetch: opts.fetch } : {}),
+        });
+        // Re-read the owning task: cached mission events can outlive a prompt.
+        const task = await client.getTask(binding.taskId);
+        if (task.id !== binding.taskId || task.contextId !== binding.contextId)
+            return reply(409, 'task_binding_mismatch');
+        const extracted = extractHitlEnvelope(task);
+        if (!extracted?.ok)
+            return reply(409, 'no_valid_pending_approval');
+        const prompt = extracted.envelope;
+        if (prompt.prompt_id !== promptId)
+            return reply(409, 'approval_prompt_mismatch');
+        if (prompt.deadline && Date.parse(prompt.deadline) <= Date.now())
+            return reply(410, 'approval_expired');
+        // The local mission API has no authenticated operator identity. Never
+        // accept a caller-supplied name as authority for a restricted prompt.
+        if (prompt.allowed_responders && !prompt.allowed_responders.includes('any'))
+            return reply(403, 'authenticated_responder_required');
+        try {
+            const validate = new Ajv({ allErrors: true, strict: true }).compile(prompt.response_schema);
+            if ('$async' in validate && validate.$async === true)
+                return reply(422, 'approval_schema_unsupported');
+            if (!validate(response))
+                return reply(422, 'approval_response_invalid');
+        }
+        catch {
+            return reply(422, 'approval_schema_unsupported');
+        }
+        if (registry.getMission(missionId) !== mission || mission.a2a !== binding
+            || ['done', 'failed', 'aborted'].includes(mission.state)) {
+            return reply(409, 'mission_changed_during_approval');
+        }
+        const digest = createHash('sha256').update(JSON.stringify(response)).digest('hex');
+        const attempts = binding.attempts ??= new Map();
+        const previous = attempts.get(promptId);
+        if (previous && previous.digest !== digest)
+            return reply(409, 'approval_retry_payload_changed');
+        const attempt = previous ?? { messageId: randomUUID(), digest };
+        attempts.set(promptId, attempt);
+        const result = await client.sendMessage(buildHitlResponseMessage({
+            promptId, response, messageId: attempt.messageId, taskId: binding.taskId,
+            ...(binding.contextId ? { contextId: binding.contextId } : {}),
+        }));
+        if (result.task.id !== binding.taskId || result.task.contextId !== binding.contextId)
+            return reply(502, 'approval_result_binding_mismatch');
+        binding.acceptedPrompts.add(promptId);
+        // Audit correlation only; approval payloads can contain sensitive data.
+        registry.handleEvent({
+            event: 'mission.progress', executor_id: mission.executorId, mission_id: missionId,
+            ts: new Date().toISOString(),
+            data: { action: 'hitl_response_accepted', hitl_id: promptId, a2a_task_id: binding.taskId },
+        });
+        return { status: 200, body: { ok: true } };
+    }
+    catch {
+        // Preserve the binding for a retry; the next attempt rechecks executor state.
+        return reply(502, 'approval_forward_failed');
+    }
+    finally {
+        binding.responding = false;
+    }
+}
+function reply(status, error) {
+    return { status, body: { error } };
+}
+//# sourceMappingURL=mission-hitl.js.map

package/dist/src/sessions/import-lease.js

@@ -49,9 +49,12 @@ export async function acquireImportLease(databasePath, runId, options = {}) {
                 heartbeatAt: observed,
             };
             await writeOwner(ownerPath, owner);
+            let heartbeatWrite = Promise.resolve();
             const timer = setInterval(() => {
                 owner.heartbeatAt = now().toISOString();
-                void writeOwner(ownerPath, owner).catch(() => undefined);
+                heartbeatWrite = heartbeatWrite
+                    .then(() => writeOwner(ownerPath, owner))
+                    .catch(() => undefined);
             }, heartbeatMs);
             timer.unref();
             let released = false;
@@ -63,6 +66,7 @@ export async function acquireImportLease(databasePath, runId, options = {}) {
                         return;
                     released = true;
                     clearInterval(timer);
+                    await heartbeatWrite;
                     const current = await readOwner(ownerPath);
                     if (current?.runId === owner.runId) {
                         await rm(lockPath, { recursive: true, force: true });