@aiwg/cli 2026.10.10 → 2026.10.12

package/dist/src/mcp/tools/worker-invoke.mjs

@@ -178,6 +178,13 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 import { mcpError, mcpJson } from '../helpers.mjs';
 import { buildShellStopControl, waitForUnitTermination } from './worker-shell-control.mjs';
 import { launchPreparedShellWorker, sweepWorkerStdin } from './worker-stdin-runtime.mjs';
+// NOTE: no static import of ../../config/worker-context.js here. That
+// module is TypeScript: a literal relative import resolves under vitest
+// but throws ERR_MODULE_NOT_FOUND under raw node (e.g. `node
+// src/mcp/cli.mjs`, which test/unit/mcp exercises directly). The
+// request-time loader below resolves it through importImpl (dist when
+// built, source otherwise), so merely loading this bridge never touches
+// it. See tools/_resolve-impl.mjs (#3062).
 
 const execFileAsync = promisify(execFile);
 
@@ -642,6 +649,64 @@ function describeGateFailures(failures) {
   return `worker dispatch gate blocked: ${failures.map(f => `${f.signal} (${f.reason})`).join('; ')}`;
 }
 
+/** Request-time loader for the TypeScript worker-context module (see the
+ * import note above): resolved through importImpl so production uses the
+ * compiled `dist` tree while a checkout falls back to source. Cached for
+ * the process lifetime; only request paths that actually ensure worker
+ * context ever trigger the load. */
+let cachedWorkerContextModule = null;
+async function loadWorkerContextModule() {
+  if (!cachedWorkerContextModule) cachedWorkerContextModule = await importImpl('config/worker-context.js');
+  return cachedWorkerContextModule;
+}
+
+/** Map the worker CLI to its provider and ensure its bootstrap is present
+ * in the worker workdir (#3685 round 2). Deploys the resolved union set
+ * (config providers plus orchestration CLIs) in one pass when the worker
+ * provider's bootstrap is missing; an unmappable CLI refuses with the
+ * typed diagnostic, since no deploy could target it. */
+async function ensureWorkerContextForInvocation({ invocation, config }) {
+  const { ensureWorkerContextBootstrap, mapCliToProviderId, resolveWorkerContextProvidersFromConfig, WorkerContextBootstrapError } =
+    await loadWorkerContextModule();
+  const cli = invocation?.selected?.cli;
+  const mapped = mapCliToProviderId(cli, config?.parallelism);
+  if (!('provider' in mapped) || !mapped.provider) {
+    throw new WorkerContextBootstrapError(
+      `cannot ensure worker context: CLI '${cli}' maps to no AIWG provider (${mapped.skipped ?? 'unmapped'})`,
+      `configure parallelism.clis.${cli} with a providers:<id> adapter, or dispatch a CLI whose adapter maps to a known provider`,
+      { workdir: invocation?.cwd },
+    );
+  }
+  let providers = [mapped.provider];
+  try {
+    providers = [...new Set([...resolveWorkerContextProvidersFromConfig(config).providers, mapped.provider])];
+  } catch {
+    providers = [mapped.provider];
+  }
+  return ensureWorkerContextBootstrap({ workdir: invocation?.cwd, provider: mapped.provider, providers });
+}
+
+/** Refuse a failed bootstrap ensure as a typed blocked diagnostic that
+ * names the remedy — never a bare string the operator cannot act on.
+ * `code`/`remedy`/`provider`/`workdir` survive on any error object that
+ * carries them (the tools-side ensure throws a duck-typed refusal, not
+ * necessarily this module's class instance); only genuinely bare failures
+ * fall back to the generic code and remedy. */
+function toWorkerContextDiagnostic(error) {
+  const fields = (error !== null && typeof error === 'object') ? error : {};
+  // Duck-typed on purpose: the worker-context module loads lazily (see
+  // above), so no class identity is available at module scope. Every
+  // refusal path sets `code`/`remedy` on the thrown object instead.
+  const code = (typeof fields.code === 'string' && fields.code ? fields.code : 'OG_WORKER_CONTEXT_UNAVAILABLE');
+  const remedy = (typeof fields.remedy === 'string' && fields.remedy ? fields.remedy
+    : 'ensure the worker CLI maps to a known AIWG provider and the aiwg CLI is installed (AIWG_BIN), then retry the run');
+  return { code,
+    message: error instanceof Error ? error.message : String(error?.message ?? error),
+    remedy,
+    ...(fields.provider !== undefined ? { provider: fields.provider } : {}),
+    ...(fields.workdir !== undefined ? { workdir: fields.workdir } : {}) };
+}
+
 // Audited observer; refresh the historical baseline graph after rebase.
 const waitForUnitTerminationBaseline = waitForUnitTermination;
 export { waitForUnitTerminationBaseline as __testOnlyWaitForUnitTerminationBaseline };
@@ -758,6 +823,7 @@ export class ChildProcessTransport {
     // cap since a long-lived connection could otherwise grow it unbounded.
     this._rawResponses = new Map();
     this._buffer = undefined;
+    this._bufferBytes = 0;
   }
 
   async start() {
@@ -769,7 +835,7 @@ export class ChildProcessTransport {
       try {
         // Check each frame BEFORE concatenation or UTF-8 decoding.
         let offset = 0;
-        let frameBytes = this._buffer?.length ?? 0;
+        let frameBytes = this._bufferBytes;
         while (offset < chunk.length) {
           const newline = chunk.indexOf(10, offset);
           const end = newline === -1 ? chunk.length : newline;
@@ -782,8 +848,7 @@ export class ChildProcessTransport {
           frameBytes = 0;
           offset = newline + 1;
         }
-        this._buffer = this._buffer ? Buffer.concat([this._buffer, chunk]) : chunk;
-        this._drain();
+        this._drain(chunk);
       } catch (error) { this.onerror?.(error); }
     });
     child.stdout?.on('error', error => this.onerror?.(error));
@@ -799,6 +864,7 @@ export class ChildProcessTransport {
     if (this._closed) return;
     this._closed = true;
     this._buffer = undefined;
+    this._bufferBytes = 0;
     this._rawResponses.clear();
     this.onclose?.();
   }
@@ -807,6 +873,7 @@ export class ChildProcessTransport {
     if (this._failure) return;
     this._failure = Object.assign(new Error(code), { code });
     this._buffer = undefined;
+    this._bufferBytes = 0;
     this._rawResponses.clear();
     // Start stopping before pipe closure can exit the leader; onclose rejects
     // pending SDK requests immediately while termination proof is awaited.
@@ -825,14 +892,26 @@ export class ChildProcessTransport {
   // (own-property-preserving, retained in `_rawResponses` — see
   // constructor doc) and once through the SDK's own `JSONRPCMessageSchema`
   // (routed to `onmessage`, unchanged behavior for the Client/Protocol).
-  _drain() {
-    while (this._buffer) {
-      const index = this._buffer.indexOf('\n');
-      if (index === -1) return;
-      const line = this._buffer.toString('utf8', 0, index).replace(/\r$/, '');
-      this._buffer = this._buffer.subarray(index + 1);
+  _drain(chunk) {
+    // Retain fragments without copying or rescanning the growing partial
+    // frame on every pipe read. Join once, only when a newline arrives.
+    let offset = 0;
+    while (offset < chunk.length) {
+      const newline = chunk.indexOf(10, offset);
+      const end = newline === -1 ? chunk.length : newline;
+      if (end > offset) {
+        (this._buffer ??= []).push(chunk.subarray(offset, end));
+        this._bufferBytes += end - offset;
+      }
+      if (newline === -1) return;
+      const frame = this._buffer?.length === 1
+        ? this._buffer[0] : Buffer.concat(this._buffer ?? [], this._bufferBytes);
+      const line = frame.toString('utf8').replace(/\r$/, '');
+      this._buffer = undefined;
+      this._bufferBytes = 0;
       this._handleLine(line);
-      if (this._buffer?.length === 0) this._buffer = undefined;
+      if (this._closed || this._failure) return;
+      offset = newline + 1;
     }
   }
 
@@ -905,6 +984,7 @@ export class ChildProcessTransport {
       try { signalChild(child, 'SIGKILL'); } catch { /* already gone */ }
     }
     this._buffer = undefined;
+    this._bufferBytes = 0;
   }
 }
 
@@ -1745,6 +1825,24 @@ export async function registerWorkerInvokeToolset(server, options = {}) {
     }
     const { root, snapshot, drivers, invocation } = prefix;
 
+    // #3685 round 2: the worker CLI's AIWG bootstrap must be present in
+    // the worker workdir before dispatch — a context-free worker would run
+    // with no project rules/skills/hooks. Present: no-op. Missing: exactly
+    // one `aiwg use all` pass into the workdir (never elsewhere). A failed
+    // ensure refuses as `blocked` with the typed diagnostic (never a
+    // launch). Default on; `ensureWorkerContext: false` skips (synthetic
+    // tests), a function value replaces the ensure.
+    if (options.ensureWorkerContext !== false) {
+      try {
+        const ensure = typeof options.ensureWorkerContext === 'function'
+          ? options.ensureWorkerContext
+          : ensureWorkerContextForInvocation;
+        await ensure({ invocation, config: snapshot.config });
+      } catch (error) {
+        return markTerminal({ status: 'blocked', termination: 'confirmed', diagnostics: [toWorkerContextDiagnostic(error)] });
+      }
+    }
+
     // =========================================================================
     // #2915 round 8 (D6): ONE decision, immediately after the prefix, from
     // the launcher's own pure eligibility predicate,

package/dist/src/mission-protocol/canonical-codecs.js

@@ -0,0 +1,270 @@
+// Canonical Mission projections and legacy transport codecs.
+import { assertMissionWorkerHandoff } from './codecs.js';
+import { MISSION_API_VERSION } from './types.js';
+const TERMINAL = new Set(['completed', 'failed', 'incomplete', 'cancelled']);
+function object(value, label = 'Mission input') {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error(`${label} must be an object.`);
+    return value;
+}
+function string(value) {
+    return typeof value === 'string' && value.length ? value : undefined;
+}
+function requiredId(record) {
+    const metadata = record.metadata && typeof record.metadata === 'object' ? record.metadata : {};
+    const id = string(record.missionId) ?? string(record.mission_id) ?? string(record.id)
+        ?? string(record.taskId) ?? string(record.task_id) ?? string(record.responseId) ?? string(metadata.id);
+    if (!id)
+        throw new Error('Mission source is missing a stable identifier.');
+    return id;
+}
+export function normalizeMissionState(nativeState) {
+    const state = String(nativeState ?? 'unknown').toLowerCase().replace(/_/g, '-');
+    if (['done', 'completed', 'succeeded', 'success'].includes(state))
+        return 'completed';
+    if (['aborted', 'cancelled', 'canceled'].includes(state))
+        return 'cancelled';
+    if (['failed', 'error', 'rejected', 'timed-out'].includes(state))
+        return 'failed';
+    if (['incomplete', 'budget-exhausted', 'max-iterations', 'max-tokens'].includes(state))
+        return 'incomplete';
+    if (['running', 'in-progress', 'working', 'started', 'assigned', 'admitted', 'starting'].includes(state))
+        return 'running';
+    if (['pending', 'submitted', 'queued', 'runnable', 'scheduled'].includes(state))
+        return 'pending';
+    if (['blocked', 'blocked-hitl', 'input-required', 'auth-required', 'paused', 'suspended'].includes(state))
+        return 'blocked';
+    if (['operator-review', 'operator-review-required', 'manual-review'].includes(state))
+        return 'operator-review';
+    if (['unknown', 'disconnected', 'detached', 'unreachable'].includes(state))
+        return 'unknown';
+    return 'unknown';
+}
+function knownKeysFor(source) {
+    const common = ['id', 'missionId', 'mission_id', 'taskId', 'task_id', 'responseId', 'title', 'goal', 'objective', 'prompt', 'completion', 'completionCriterion', 'completion_criterion', 'status', 'state', 'nativeState', 'createdAt', 'created_at', 'updatedAt', 'updated_at', 'metadata', 'spec', 'provenance', 'extensions', 'artifacts', 'output', 'partialOutput', 'error', 'checkpoint', 'cycles', 'activityLog', 'totalCost', 'runtimesUsed', 'apiVersion', 'api_version', 'schemaVersion', 'schema_version', 'kind', 'session_id', 'previous_response_id'];
+    if (source === 'uhp-2026-08-11')
+        common.push('object', 'model', 'incomplete_details', 'store', 'usage');
+    return new Set(common);
+}
+function extensions(record, source) {
+    const explicit = record.extensions && typeof record.extensions === 'object' ? structuredClone(record.extensions) : {};
+    if (record.metadata && typeof record.metadata === 'object')
+        explicit.metadata = structuredClone(record.metadata);
+    if (record.status && typeof record.status === 'object')
+        explicit.nativeStatus = structuredClone(record.status);
+    for (const [key, value] of Object.entries(record))
+        if (!knownKeysFor(source).has(key))
+            explicit[key] = structuredClone(value);
+    return explicit;
+}
+function artifacts(record) {
+    const values = Array.isArray(record.artifacts) ? record.artifacts : [];
+    return values.flatMap((item, index) => {
+        if (!item || typeof item !== 'object')
+            return [];
+        const artifact = item;
+        const id = string(artifact.id) ?? string(artifact.fileId) ?? string(artifact.file_id) ?? string(artifact.uri) ?? `artifact-${index}`;
+        return [{
+                id,
+                kind: string(artifact.kind) ?? 'other',
+                ...(string(artifact.uri) ? { uri: string(artifact.uri) } : {}),
+                ...(string(artifact.sha256) ? { sha256: string(artifact.sha256) } : {}),
+                ...(string(artifact.mediaType) ?? string(artifact.media_type) ? { mediaType: string(artifact.mediaType) ?? string(artifact.media_type) } : {}),
+                extensions: structuredClone(artifact),
+            }];
+    });
+}
+function uhpOutputArtifacts(record) {
+    const found = new Map();
+    function visit(value) {
+        if (Array.isArray(value)) {
+            value.forEach(visit);
+            return;
+        }
+        if (!value || typeof value !== 'object')
+            return;
+        const item = value;
+        const id = string(item.file_id);
+        if (id)
+            found.set(id, { id, kind: 'uhp-file', ...(string(item.media_type) ? { mediaType: string(item.media_type) } : {}), extensions: { 'uhp.file': structuredClone(item) } });
+        Object.values(item).forEach(visit);
+    }
+    visit(record.output);
+    return [...found.values()];
+}
+function nativeStateFor(source, record, statusRecord) {
+    const explicit = string(statusRecord.state) ?? string(record.nativeState) ?? string(record.status)
+        ?? string(record.state) ?? string(record.observed_state) ?? string(record.observedState) ?? string(record.nodeState);
+    if (explicit)
+        return explicit;
+    if (source === 'mission-ledger' && record.checkpoint && typeof record.checkpoint === 'object') {
+        const checkpoint = record.checkpoint;
+        if (Array.isArray(checkpoint.pending) && checkpoint.pending.length)
+            return 'running';
+        if (Array.isArray(checkpoint.failed) && checkpoint.failed.length)
+            return 'failed';
+        if (Array.isArray(checkpoint.completed) && checkpoint.completed.length)
+            return 'completed';
+    }
+    return 'unknown';
+}
+function sourceVersion(source, record) {
+    if (source === 'canonical')
+        return string(record.apiVersion) ?? 'unknown';
+    if (source === 'uhp-2026-08-11')
+        return '2026-08-11';
+    if (source === 'executor-v1')
+        return 'executor.aiwg.io/v1';
+    if (source === 'fleet-workload-v1')
+        return 'fleet-workload/v1';
+    if (source === 'graph-flow-v1')
+        return 'graph.flow.aiwg.io/v1';
+    if (source === 'activity-v1')
+        return 'activity.aiwg.io/v1';
+    return string(record.apiVersion) ?? string(record.api_version) ?? string(record.schemaVersion) ?? string(record.schema_version) ?? 'unversioned';
+}
+function assertSupported(version) {
+    const supported = new Set(['unversioned', MISSION_API_VERSION, '2026-08-11', 'executor.aiwg.io/v1', 'fleet-workload/v1', 'graph.flow.aiwg.io/v1', 'activity.aiwg.io/v1']);
+    if (supported.has(version))
+        return;
+    const major = version.match(/(?:^|\/)v(\d+)(?:$|[.-])/)?.[1];
+    if (major && major !== '1')
+        throw new Error(`Unsupported Mission source major version '${version}'; supported major is v1.`);
+    throw new Error(`Unsupported Mission source version '${version}'.`);
+}
+export function validateCanonicalMission(value) {
+    const record = object(value, 'Canonical Mission');
+    assertMissionWorkerHandoff(record, 'canonical');
+    if (record.apiVersion !== MISSION_API_VERSION)
+        throw new Error(`Unsupported canonical Mission version '${String(record.apiVersion)}'.`);
+    if (record.kind !== 'Mission')
+        throw new Error("Canonical Mission kind must be 'Mission'.");
+    const metadata = object(record.metadata, 'Mission metadata');
+    const spec = object(record.spec, 'Mission spec');
+    const status = object(record.status, 'Mission status');
+    const provenance = object(record.provenance, 'Mission provenance');
+    if (!string(metadata.id) || !string(spec.objective) || !string(provenance.sourceContract) || !string(provenance.sourceVersion))
+        throw new Error('Canonical Mission is missing required identity, objective, or provenance.');
+    const state = normalizeMissionState(status.state);
+    if (status.state !== state)
+        throw new Error(`Canonical Mission state '${String(status.state)}' is not normalized.`);
+    if (status.terminal !== TERMINAL.has(state))
+        throw new Error(`Canonical Mission terminal flag contradicts state '${state}'.`);
+    if (!Array.isArray(status.artifacts))
+        throw new Error('Canonical Mission artifacts must be an array.');
+    return structuredClone(value);
+}
+export function decodeMission(input, source, workerConsumer) {
+    const record = object(input);
+    assertMissionWorkerHandoff(record, source, workerConsumer);
+    if (source === 'canonical') {
+        const value = validateCanonicalMission(record);
+        return { value, sourceVersion: MISSION_API_VERSION, warnings: [], preservedExtensions: structuredClone(value.extensions ?? {}), lossReport: [] };
+    }
+    const version = sourceVersion(source, record);
+    assertSupported(version);
+    const statusRecord = record.status && typeof record.status === 'object' ? record.status : {};
+    const nativeState = nativeStateFor(source, record, statusRecord);
+    const state = normalizeMissionState(nativeState);
+    const objective = string(record.goal) ?? string(record.objective) ?? string(record.title) ?? string(record.prompt) ?? '(legacy mission objective unavailable)';
+    const completionCriterion = string(record.completionCriterion) ?? string(record.completion_criterion) ?? string(record.completion);
+    const preserved = extensions(record, source);
+    const warnings = [];
+    const lossReport = [];
+    if (objective.startsWith('(legacy'))
+        warnings.push('Source did not contain a mission objective; placeholder retained.');
+    if (state === 'unknown' && nativeState !== 'unknown')
+        warnings.push(`Unknown native state '${nativeState}' preserved beside normalized unknown state.`);
+    const sourceArtifacts = artifacts(record);
+    if (source === 'uhp-2026-08-11') {
+        const ids = new Set(sourceArtifacts.map(artifact => artifact.id));
+        for (const artifact of uhpOutputArtifacts(record))
+            if (!ids.has(artifact.id))
+                sourceArtifacts.push(artifact);
+    }
+    const budgets = record.budgets && typeof record.budgets === 'object' ? record.budgets : undefined;
+    const lineage = Array.isArray(record.lineage) ? record.lineage.flatMap(item => {
+        if (!item || typeof item !== 'object')
+            return [];
+        const entry = item;
+        return string(entry.relation) && string(entry.id) ? [{ relation: string(entry.relation), id: string(entry.id) }] : [];
+    }) : undefined;
+    const value = {
+        apiVersion: MISSION_API_VERSION,
+        kind: 'Mission',
+        metadata: {
+            id: requiredId(record),
+            ...(string(record.createdAt) ?? string(record.created_at) ? { createdAt: string(record.createdAt) ?? string(record.created_at) } : {}),
+            ...(string(record.updatedAt) ?? string(record.updated_at) ? { updatedAt: string(record.updatedAt) ?? string(record.updated_at) } : {}),
+            ...(string(record.previous_response_id) ? { previousId: string(record.previous_response_id) } : {}),
+            ...(lineage?.length ? { lineage } : {}),
+        },
+        spec: { objective, ...(completionCriterion ? { completionCriterion } : {}), ...(budgets ? { budgets: structuredClone(budgets) } : {}) },
+        status: {
+            state,
+            terminal: TERMINAL.has(state),
+            nativeState,
+            artifacts: sourceArtifacts,
+            ...(record.output !== undefined || record.partialOutput !== undefined || record.partial_output !== undefined ? { partialOutput: structuredClone(record.partialOutput ?? record.partial_output ?? record.output) } : {}),
+        },
+        provenance: { sourceContract: source, sourceVersion: version, ...(source === 'a2a' || source.startsWith('uhp') ? { transport: source.split('-')[0] } : {}), sourceId: requiredId(record) },
+        ...(Object.keys(preserved).length ? { extensions: { [`aiwg.source.${source}`]: preserved } } : {}),
+    };
+    return { value, sourceVersion: version, warnings, preservedExtensions: preserved, lossReport };
+}
+function projectionLosses(value, target) {
+    const losses = [];
+    if (value.status.verification?.length)
+        losses.push({ path: '/status/verification', reason: `${target} has no native verification ledger`, severity: 'warning' });
+    if (value.metadata.lineage?.length && !['mission-ledger', 'fleet-workload-v1', 'canonical'].includes(target))
+        losses.push({ path: '/metadata/lineage', reason: `${target} cannot represent full lineage`, severity: 'required' });
+    if (value.spec.budgets && !['fleet-workload-v1', 'canonical'].includes(target))
+        losses.push({ path: '/spec/budgets', reason: `${target} cannot represent every canonical budget`, severity: 'warning' });
+    return losses;
+}
+export function encodeMission(value, target, options = {}) {
+    assertMissionWorkerHandoff(value, target, options.workerConsumer);
+    const mission = validateCanonicalMission(value);
+    if (target === 'canonical')
+        return { value: mission, targetVersion: MISSION_API_VERSION, warnings: [], lossReport: [] };
+    const lossReport = projectionLosses(mission, target);
+    const required = lossReport.filter(loss => loss.severity === 'required');
+    if (required.length && !options.allowLoss)
+        throw new Error(`Projection to ${target} would silently lose required semantics: ${required.map(loss => loss.path).join(', ')}.`);
+    const base = {
+        missionId: mission.metadata.id,
+        goal: mission.spec.objective,
+        completionCriterion: mission.spec.completionCriterion,
+        status: mission.status.nativeState ?? mission.status.state,
+        artifacts: structuredClone(mission.status.artifacts),
+        partialOutput: structuredClone(mission.status.partialOutput),
+        lineage: structuredClone(mission.metadata.lineage ?? []),
+        extensions: {
+            'aiwg.mission.canonical': { apiVersion: mission.apiVersion, state: mission.status.state, lossReport },
+            ...(mission.extensions ?? {}),
+        },
+    };
+    let projected = base;
+    if (target === 'mission-plan')
+        projected = { missionId: base.missionId, goal: base.goal, completionCriterion: base.completionCriterion ?? '', cycles: [], extensions: base.extensions };
+    else if (target === 'mission-ledger')
+        projected = { ...base, activityLog: [], cycles: [], totalCost: 0, checkpoint: { completed: [], pending: [], failed: [] }, runtimesUsed: [] };
+    else if (target === 'uhp-2026-08-11')
+        projected = { id: mission.provenance.sourceId ?? mission.metadata.id, object: 'response', created_at: 0, status: base.status, model: '', output: mission.status.partialOutput ?? [], metadata: base.extensions };
+    else if (target === 'a2a')
+        projected = { id: mission.provenance.sourceId ?? mission.metadata.id, status: { state: base.status }, artifacts: base.artifacts, partialOutput: base.partialOutput, metadata: base.extensions };
+    else if (target === 'graph-flow-v1')
+        projected = { schemaVersion: 'graph.flow.aiwg.io/v1', runId: mission.metadata.id, nodeState: mission.status.state, metadata: base.extensions };
+    else if (target === 'cockpit')
+        projected = { id: mission.metadata.id, session_id: mission.metadata.id, source: mission.provenance.transport ?? mission.provenance.sourceContract, title: mission.spec.objective, completion: mission.spec.completionCriterion, status: mission.status.state, artifacts: base.artifacts, partialOutput: base.partialOutput, extensions: base.extensions };
+    else if (target === 'activity-v1')
+        projected = { event: 'mission.projected', missionId: mission.metadata.id, objective: mission.spec.objective, state: mission.status.state, metadata: base.extensions };
+    else if (target === 'executor-v1')
+        projected = { mission_id: mission.metadata.id, objective: mission.spec.objective, completion_criterion: mission.spec.completionCriterion, state: base.status, artifacts: base.artifacts, partial_output: base.partialOutput, metadata: base.extensions };
+    else if (target === 'fleet-workload-v1')
+        projected = { mission_id: mission.metadata.id, objective: mission.spec.objective, completion_criterion: mission.spec.completionCriterion, observed_state: base.status, budgets: mission.spec.budgets, artifacts: base.artifacts, partial_output: base.partialOutput, lineage: base.lineage, metadata: base.extensions };
+    else if (target === 'mission-control-session')
+        projected = { id: mission.metadata.id, objective: mission.spec.objective, status: mission.status.state, completion: mission.spec.completionCriterion, artifacts: base.artifacts, partialOutput: base.partialOutput, extensions: base.extensions };
+    return { value: projected, targetVersion: target, warnings: lossReport.map(loss => `${loss.path}: ${loss.reason}`), lossReport };
+}
+//# sourceMappingURL=canonical-codecs.js.map