@aiwg/cli 2026.8.17 → 2026.8.19

package/dist/src/installation/manager.mjs

@@ -0,0 +1,264 @@
+import { execFileSync } from 'node:child_process';
+import {
+  accessSync,
+  constants,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  realpathSync,
+  renameSync,
+  statSync,
+  writeFileSync,
+} from 'node:fs';
+import path from 'node:path';
+import { resolveUserConfigDir } from '../config/user-config-dir.mjs';
+import { executeManagerCommand } from './manager-command.mjs';
+
+export const INSTALLATION_IDENTITY_VERSION = 1;
+export const INSTALLATION_FILE = 'installation.json';
+const METHODS = new Set(['npm', 'web', 'source']);
+const RUN_MODES = new Set(['normal', 'development']);
+const CHANNELS = new Set(['stable', 'next', 'nightly', 'edge']);
+const STRATEGIES = new Set(['npm-global', 'signed-web', 'source-git']);
+
+function canonicalPath(value) {
+  const resolved = path.resolve(value);
+  try { return realpathSync.native(resolved); } catch { return resolved; }
+}
+
+function packageName(root) {
+  try {
+    return JSON.parse(readFileSync(path.join(root, 'package.json'), 'utf8')).name ?? null;
+  } catch {
+    return null;
+  }
+}
+
+export function inferInstallationMethod(root) {
+  if (packageName(root) === '@aiwg/cli') return 'web';
+  if (existsSync(path.join(root, '.git'))) return 'source';
+  return 'npm';
+}
+
+function resolveExecutable(name, options = {}) {
+  const env = options.env ?? process.env;
+  const explicit = options.managerExecutable ?? env.AIWG_PACKAGE_MANAGER_EXECUTABLE;
+  if (explicit) return canonicalPath(explicit);
+  if (name === 'npm' && env.npm_execpath) return canonicalPath(env.npm_execpath);
+
+  const besideNode = path.join(path.dirname(process.execPath), process.platform === 'win32' ? `${name}.cmd` : name);
+  if (existsSync(besideNode)) return canonicalPath(besideNode);
+  try {
+    const finder = process.platform === 'win32' ? 'where.exe' : 'which';
+    const found = execFileSync(finder, [name], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] })
+      .split(/\r?\n/, 1)[0]?.trim();
+    return found ? canonicalPath(found) : null;
+  } catch {
+    return null;
+  }
+}
+
+function strategyFor(method) {
+  if (method === 'web') return 'signed-web';
+  if (method === 'source') return 'source-git';
+  return 'npm-global';
+}
+
+function executableIsUsable(file) {
+  try {
+    if (!statSync(file).isFile()) return false;
+    if (process.platform !== 'win32') accessSync(file, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function validateIdentity(value, file) {
+  const invalid = !value || typeof value !== 'object'
+    || value.schemaVersion !== INSTALLATION_IDENTITY_VERSION
+    || !METHODS.has(value.method)
+    || !RUN_MODES.has(value.runMode)
+    || !CHANNELS.has(value.channel)
+    || typeof value.root !== 'string'
+    || !path.isAbsolute(value.root)
+    || !STRATEGIES.has(value.updateStrategy)
+    || value.updateStrategy !== strategyFor(value.method)
+    || (value.managerExecutable !== null
+      && (typeof value.managerExecutable !== 'string' || !path.isAbsolute(value.managerExecutable)));
+  if (invalid) {
+    const error = new Error(`Invalid AIWG installation identity at ${file}. Run \`aiwg installation adopt\` to replace it.`);
+    error.code = 'AIWG_INSTALLATION_INVALID';
+    throw error;
+  }
+  return value;
+}
+
+export function installationFile(options = {}) {
+  return path.join(resolveUserConfigDir(options), INSTALLATION_FILE);
+}
+
+export function createInstallationIdentity(options) {
+  if (!options?.actualRoot) throw new Error('actualRoot is required to create an installation identity');
+  const root = canonicalPath(options.root ?? options.actualRoot);
+  const method = options.method ?? inferInstallationMethod(root);
+  const runMode = options.runMode ?? (method === 'source' ? 'development' : 'normal');
+  const requestedChannel = options.channel ?? (runMode === 'development' ? 'edge' : 'stable');
+  const channel = requestedChannel === 'latest'
+    ? 'stable'
+    : ['alpha', 'beta', 'rc'].includes(requestedChannel) ? 'next' : requestedChannel;
+  const executableName = method === 'npm' ? 'npm' : method === 'source' ? 'git' : null;
+  return {
+    schemaVersion: INSTALLATION_IDENTITY_VERSION,
+    runMode,
+    method,
+    root,
+    updateStrategy: options.updateStrategy ?? strategyFor(method),
+    managerExecutable: executableName ? resolveExecutable(executableName, options) : null,
+    channel,
+    edgePath: options.edgePath ? canonicalPath(options.edgePath) : (runMode === 'development' ? root : null),
+    checkOnStartup: options.checkOnStartup ?? true,
+    lastUpdateCheck: options.lastUpdateCheck ?? null,
+    updateCheckInterval: options.updateCheckInterval ?? 86_400_000,
+    recordedAt: options.recordedAt ?? new Date().toISOString(),
+  };
+}
+
+export function saveInstallationIdentity(identity, options = {}) {
+  const file = installationFile(options);
+  const validated = validateIdentity(identity, file);
+  mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+  const temporary = `${file}.${process.pid}.tmp`;
+  writeFileSync(temporary, `${JSON.stringify(validated, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+  renameSync(temporary, file);
+  return validated;
+}
+
+function readLegacy(options = {}) {
+  const file = path.join(resolveUserConfigDir(options), 'channel.json');
+  try { return JSON.parse(readFileSync(file, 'utf8')); } catch { return null; }
+}
+
+/** Load the canonical record, migrating legacy channel.json on first access. */
+export function loadInstallationIdentity(options = {}) {
+  const file = installationFile(options);
+  if (existsSync(file)) {
+    try { return validateIdentity(JSON.parse(readFileSync(file, 'utf8')), file); }
+    catch (error) {
+      if (error?.code === 'AIWG_INSTALLATION_INVALID') throw error;
+      const wrapped = new Error(`Cannot read AIWG installation identity at ${file}: ${error.message}`);
+      wrapped.code = 'AIWG_INSTALLATION_INVALID';
+      throw wrapped;
+    }
+  }
+  if (options.createIfMissing === false) return null;
+  if (!options.actualRoot) return null;
+
+  const legacy = options.legacyConfig ?? readLegacy(options) ?? {};
+  const development = legacy.devMode === true;
+  const root = development && legacy.edgePath ? legacy.edgePath : options.actualRoot;
+  const method = options.method ?? (development ? 'source' : inferInstallationMethod(root));
+  const identity = createInstallationIdentity({
+    ...options,
+    root,
+    method,
+    runMode: development ? 'development' : undefined,
+    channel: legacy.channel ?? options.channel,
+    edgePath: legacy.edgePath,
+    lastUpdateCheck: legacy.lastUpdateCheck,
+    updateCheckInterval: legacy.updateCheckInterval,
+    checkOnStartup: legacy.checkOnStartup,
+  });
+  return saveInstallationIdentity(identity, options);
+}
+
+export function inspectInstallation(options = {}) {
+  const actualRoot = canonicalPath(options.actualRoot);
+  const actualMethod = options.actualMethod ?? inferInstallationMethod(actualRoot);
+  const identity = options.identity ?? loadInstallationIdentity({ ...options, actualRoot });
+  if (!identity) return { state: 'unrecorded', identity: null, actualRoot, actualMethod, drift: ['installation identity is not recorded'] };
+
+  const drift = [];
+  const canonicalRoot = canonicalPath(identity.root);
+  if (!existsSync(canonicalRoot)) drift.push(`canonical root does not exist: ${canonicalRoot}`);
+  if (canonicalRoot !== actualRoot) drift.push(`actual root ${actualRoot} differs from canonical root ${canonicalRoot}`);
+  if (identity.method !== actualMethod) drift.push(`actual method ${actualMethod} differs from canonical method ${identity.method}`);
+  if (identity.method !== 'web' && !identity.managerExecutable) {
+    drift.push(`canonical ${identity.method} installation has no recorded manager executable`);
+  }
+  if (identity.managerExecutable && !executableIsUsable(identity.managerExecutable)) {
+    drift.push(`recorded manager executable is missing or not executable: ${identity.managerExecutable}`);
+  }
+  let managerProbe = null;
+  if (
+    options.probeManager === true &&
+    identity.managerExecutable &&
+    executableIsUsable(identity.managerExecutable)
+  ) {
+    try {
+      executeManagerCommand(identity.managerExecutable, ['--version'], {
+        ...options,
+        execute: options.executeManager,
+        execOptions: { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], timeout: 10_000 },
+      });
+      managerProbe = { state: 'usable' };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      managerProbe = { state: 'failed', error: message };
+      drift.push(`recorded manager executable cannot be invoked: ${message}`);
+    }
+  }
+  return {
+    state: drift.length === 0 ? 'aligned' : (existsSync(canonicalRoot) ? 'mismatch' : 'stale'),
+    identity,
+    canonicalRoot,
+    actualRoot,
+    actualMethod,
+    drift,
+    managerProbe,
+  };
+}
+
+export function formatInstallationDiagnostic(status) {
+  if (status.state === 'aligned') return 'Canonical installation is aligned.';
+  return [
+    'AIWG installation identity drift detected; update and refresh are blocked.',
+    ...status.drift.map((item) => `- ${item}`),
+    'Inspect: aiwg installation show',
+    'Adopt this installation: aiwg installation adopt',
+    'Switch deliberately: aiwg installation switch --root <path> --method <npm|web|source> [--manager <absolute-path>]',
+  ].join('\n');
+}
+
+export function assertCanonicalInstallation(options = {}) {
+  const status = inspectInstallation(options);
+  if (status.state !== 'aligned') {
+    const error = new Error(formatInstallationDiagnostic(status));
+    error.code = 'AIWG_INSTALLATION_DRIFT';
+    error.status = status;
+    throw error;
+  }
+  return status;
+}
+
+export function adoptInstallation(options) {
+  const inferred = inferInstallationMethod(options.actualRoot);
+  if (options.method && options.method !== inferred) {
+    throw new Error(`Cannot adopt ${options.actualRoot} as ${options.method}; package contents identify it as ${inferred}.`);
+  }
+  const identity = createInstallationIdentity({ ...options, root: options.actualRoot });
+  saveInstallationIdentity(identity, options);
+  return inspectInstallation({ ...options, actualRoot: identity.root, identity });
+}
+
+export function switchInstallation(options) {
+  if (!options?.root || !options?.method) throw new Error('switch requires root and method');
+  if (!existsSync(path.resolve(options.root))) throw new Error(`Installation root does not exist: ${path.resolve(options.root)}`);
+  const inferred = inferInstallationMethod(options.root);
+  if (options.method !== inferred) {
+    throw new Error(`Cannot switch ${options.root} as ${options.method}; package contents identify it as ${inferred}.`);
+  }
+  const identity = createInstallationIdentity({ ...options, actualRoot: options.root });
+  saveInstallationIdentity(identity, options);
+  return inspectInstallation({ ...options, actualRoot: identity.root, identity });
+}

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

@@ -10,6 +10,7 @@
  */
 import { A2AClient } from '../a2a/client.js';
 import { isTerminalTaskState, } from '../a2a/types.js';
+import { extractGraphMetadata } from '../flow/graph-metadata.js';
 const DEFAULT_POLL_INTERVAL_MS = 1000;
 const DEFAULT_MAX_POLLS = 300;
 export async function observeA2ATerminalState(registry, executor, missionId, a2aInstanceId, initialTask, opts = {}) {
@@ -18,7 +19,11 @@ export async function observeA2ATerminalState(registry, executor, missionId, a2a
             baseUrl: executor.transportEndpoints.rest,
             bearer: executor.token,
             instanceId: a2aInstanceId,
+            protocolVersion: opts.protocolVersion ?? '0.3',
+            protocolPolicy: opts.protocolVersion ?? '0.3',
         };
+        if (opts.selectedInterface)
+            clientOpts.selectedInterface = opts.selectedInterface;
         if (opts.fetch)
             clientOpts.fetch = opts.fetch;
         const client = new A2AClient(clientOpts);
@@ -90,21 +95,39 @@ function emitTerminalTask(registry, executorId, missionId, task) {
     }));
 }
 function makeEnvelope(event, executorId, missionId, task, data) {
+    const graph = extractGraphMetadata(task.metadata);
     return {
         event,
         executor_id: executorId,
         mission_id: missionId,
         ts: task.status.timestamp ?? new Date().toISOString(),
-        data,
+        data: {
+            ...data,
+            ...(graph ? {
+                graph_metadata: { ...graph, nodeState: taskStateToGraphState(task.status.state) },
+                graph_node_state: taskStateToGraphState(task.status.state),
+            } : {}),
+        },
     };
 }
+function taskStateToGraphState(state) {
+    switch (state) {
+        case 'submitted': return 'pending';
+        case 'working': return 'running';
+        case 'input-required':
+        case 'auth-required': return 'blocked-hitl';
+        case 'completed': return 'succeeded';
+        case 'failed':
+        case 'rejected': return 'failed';
+        case 'canceled': return 'canceled';
+        default: return 'unknown';
+    }
+}
 function taskStatusSummary(task) {
-    const status = task.status;
-    return typeof status.summary === 'string' ? status.summary : undefined;
+    return task.status.summary;
 }
 function exitCodeData(task) {
-    const status = task.status;
-    return typeof status.exit_code === 'number' ? { exit_code: status.exit_code } : {};
+    return task.status.exitCode !== undefined ? { exit_code: task.status.exitCode } : {};
 }
 function sleep(ms) {
     return new Promise((resolve) => {

package/dist/src/serve/dispatch-router.js

@@ -12,7 +12,7 @@
  *   v1 payload                       →  A2A Message
  *   --------------------------------    --------------------------------------
  *   mission_id                          message.messageId (idempotency key)
- *   objective                           parts[0] = { kind: 'text', text: ... }
+ *   objective                           parts[0] = normalized text content
  *   completion                          metadata.completion
  *   executor_filter                     metadata.executor_filter
  *   long_running                        metadata.long_running
@@ -39,7 +39,10 @@ export async function routeDispatch(executor, payload, opts = {}) {
     }
     catch (err) {
         // Only fall back on a 404 from the v2 path. Everything else propagates.
-        if (err instanceof A2AError && err.status === 404) {
+        const policy = opts.a2aProtocolPolicy ?? '0.3';
+        const allowLegacyFallback = policy !== '1.0'
+            && (opts.allowLegacyExecutorFallback ?? true);
+        if (allowLegacyFallback && err instanceof A2AError && err.status === 404) {
             // Capture sunset for the telemetry event if any was attached.
             const sunset = err.problem.code === 'aiwg.deprecation_strict' ? undefined : undefined;
             if (opts.onV1Fallback) {
@@ -62,6 +65,8 @@ async function dispatchV2(executor, payload, opts) {
         bearer: executor.token,
         instanceId: a2aInstanceId,
         requiredExtensions: opts.requiredExtensions ?? [A2A_RUNTIME_V1, A2A_IDEMPOTENCY_V1],
+        protocolPolicy: opts.a2aProtocolPolicy ?? '0.3',
+        allowProtocolFallback: opts.allowA2AProtocolFallback ?? false,
     };
     if (opts.fetch)
         clientOpts.fetch = opts.fetch;
@@ -69,7 +74,27 @@ async function dispatchV2(executor, payload, opts) {
         clientOpts.optionalExtensions = opts.optionalExtensions;
     if (opts.onDeprecation)
         clientOpts.onDeprecation = opts.onDeprecation;
-    const client = new A2AClient(clientOpts);
+    if (opts.onA2AProtocolFallback)
+        clientOpts.onProtocolFallback = opts.onA2AProtocolFallback;
+    if (opts.onA2AProtocolSelection) {
+        clientOpts.onProtocolSelection = info => opts.onA2AProtocolSelection?.(info);
+    }
+    // The deployed 0.3 compatibility route predates AgentCard negotiation. Model
+    // it as an explicit interface so headerless legacy selection is observable
+    // in registry, telemetry, audit, and dispatch results without adding a new
+    // discovery dependency to the compatibility path.
+    if (clientOpts.protocolPolicy === '0.3') {
+        clientOpts.selectedInterface = {
+            url: `${executor.transportEndpoints.rest.replace(/\/+$/, '')}/agents/${encodeURIComponent(a2aInstanceId)}`,
+            protocolBinding: 'REST',
+            protocolVersion: '0.3',
+            preference: 0,
+            legacy: true,
+        };
+    }
+    const client = clientOpts.protocolPolicy === '0.3'
+        ? new A2AClient(clientOpts)
+        : await A2AClient.negotiate(clientOpts);
     const message = payloadToMessage(payload);
     const result = await client.sendMessage(message);
     return {
@@ -79,6 +104,9 @@ async function dispatchV2(executor, payload, opts) {
         dispatchPath: 'v2',
         task: result.task,
         idempotentReplayed: result.idempotentReplayed,
+        a2aProtocolVersion: result.protocolVersion,
+        ...(result.selectedInterface ? { a2aInterface: result.selectedInterface } : {}),
+        ...(result.fallbackReason ? { a2aFallbackReason: result.fallbackReason } : {}),
     };
 }
 function resolveA2AInstanceId(executor, payload, opts) {
@@ -145,7 +173,7 @@ function payloadToMessage(payload) {
     return {
         messageId: payload.mission_id,
         role: 'user',
-        parts: [{ kind: 'text', text: payload.objective }],
+        parts: [{ type: 'text', text: payload.objective }],
         metadata,
     };
 }

package/dist/src/serve/executor-registry.js

@@ -232,6 +232,7 @@ export class ExecutorRegistry extends EventEmitter {
             // Upsert — preserve token and registeredAt
             existing.name = req.name;
             existing.a2aInstanceId = req.a2a_instance_id;
+            delete existing.a2aProtocol;
             existing.version = req.version;
             existing.specVersion = req.spec_version;
             existing.transportEndpoints = req.transport_endpoints;
@@ -614,6 +615,24 @@ export class ExecutorRegistry extends EventEmitter {
     getRegistration(executorId) {
         return this.executors.get(executorId);
     }
+    /** Publish the negotiated interface used for the most recent A2A dispatch. */
+    recordA2AProtocolSelection(executorId, selection) {
+        const executor = this.executors.get(executorId);
+        if (!executor)
+            return false;
+        executor.a2aProtocol = {
+            ...selection,
+            selectedAt: selection.selectedAt ?? new Date().toISOString(),
+        };
+        this.emit('executor:a2a_protocol_selected', {
+            executorId,
+            selectedVersion: selection.selectedVersion,
+            protocolBinding: selection.interface.protocolBinding,
+            interfaceUrl: selection.interface.url,
+            ...(selection.fallbackReason ? { fallbackReason: selection.fallbackReason } : {}),
+        });
+        return true;
+    }
     /**
      * Pick the best executor matching the given filter.
      *
@@ -708,6 +727,16 @@ function toSummary(e) {
     };
     if (e.a2aInstanceId)
         summary.a2a_instance_id = e.a2aInstanceId;
+    if (e.a2aProtocol) {
+        summary.a2a_protocol = {
+            policy: e.a2aProtocol.policy,
+            selected_version: e.a2aProtocol.selectedVersion,
+            protocol_binding: e.a2aProtocol.interface.protocolBinding,
+            interface_url: e.a2aProtocol.interface.url,
+            selected_at: e.a2aProtocol.selectedAt,
+            ...(e.a2aProtocol.fallbackReason ? { fallback_reason: e.a2aProtocol.fallbackReason } : {}),
+        };
+    }
     return summary;
 }
 // Singleton instance

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

@@ -46,6 +46,9 @@ export class MissionConductor {
      * crash-resilient resume path; their prior results are carried forward.
      */
     async conduct(plan, pool, resumeFrom) {
+        if (plan.cycles.some((cycle) => cycle.graph) && !plan.graph) {
+            throw new Error('Graph-projected worker cycles require MissionPlan.graph identity.');
+        }
         const carried = new Map();
         if (resumeFrom) {
             for (const c of resumeFrom.cycles) {
@@ -62,10 +65,17 @@ export class MissionConductor {
             totalCost: 0,
             checkpoint: { completed: [], pending: [], failed: [] },
             runtimesUsed: [],
+            ...(plan.graph ? { graph: structuredClone(plan.graph) } : {}),
         };
         ledger.activityLog.push(`mission ${plan.missionId} start — goal: ${plan.goal} — ${plan.cycles.length} cycle(s)` +
             (resumeFrom ? ` (resume: ${carried.size} carried)` : ''));
         for (const cycle of plan.cycles) {
+            const graph = plan.graph && cycle.graph ? {
+                ...structuredClone(plan.graph),
+                ...structuredClone(cycle.graph),
+                schemaVersion: 'graph.flow.aiwg.io/v1',
+                nodeRunId: cycle.graph.nodeRunId ?? `${plan.graph.runId}:${cycle.graph.nodeId}`,
+            } : undefined;
             // Resume: carry a previously-completed cycle forward, identical bookkeeping.
             const prior = carried.get(cycle.id);
             if (prior) {
@@ -86,6 +96,7 @@ export class MissionConductor {
                     routed: false,
                     reason: `no stack adapter registered for runtime '${cycle.runtime}'`,
                     cost: 0,
+                    ...(graph ? { graph } : {}),
                 };
                 ledger.cycles.push(result);
                 ledger.checkpoint.failed.push(cycle.id);
@@ -104,6 +115,7 @@ export class MissionConductor {
                     routed: false,
                     reason: `no connected executor advertises ${filter.capabilities.join(', ')}`,
                     cost: 0,
+                    ...(graph ? { graph } : {}),
                 };
                 ledger.cycles.push(result);
                 ledger.checkpoint.failed.push(cycle.id);
@@ -111,7 +123,7 @@ export class MissionConductor {
                 continue;
             }
             const executor = routing.selected.executor;
-            const invocation = adapter.invoke(cycle.prompt);
+            const invocation = adapter.invoke(cycle.prompt, graph);
             ledger.activityLog.push(`cycle ${cycle.id} → executor ${executor.name} (${executor.executorId}) on ${cycle.runtime}: ${invocation.describe}`);
             let output;
             let cost = 0;
@@ -129,6 +141,7 @@ export class MissionConductor {
                     routed: true,
                     reason: `worker error: ${err instanceof Error ? err.message : String(err)}`,
                     cost: 0,
+                    ...(graph ? { graph } : {}),
                 };
                 ledger.cycles.push(result);
                 ledger.checkpoint.failed.push(cycle.id);
@@ -144,6 +157,7 @@ export class MissionConductor {
                 reason: routing.selected.matchReason,
                 output,
                 cost,
+                ...(graph ? { graph } : {}),
             };
             ledger.cycles.push(result);
             ledger.checkpoint.completed.push(cycle.id);

package/dist/src/serve/stack-adapters.js

@@ -23,7 +23,7 @@ function makeAdapter(runtime, primitive) {
         runtime,
         runtimeCapability,
         primitive,
-        invoke(prompt) {
+        invoke(prompt, graph) {
             // prompt is carried by the dispatch payload; the descriptor records the
             // mechanism so the conductor's ledger is identical-shape across stacks.
             const trimmed = prompt.length > 60 ? `${prompt.slice(0, 57)}...` : prompt;
@@ -31,6 +31,7 @@ function makeAdapter(runtime, primitive) {
                 runtimeCapability,
                 primitive,
                 describe: `dispatch worker to ${runtime} executor via ${primitive} (${trimmed})`,
+                ...(graph ? { graph: structuredClone(graph) } : {}),
             };
         },
     };

package/dist/src/serve/telemetry.js

@@ -130,7 +130,10 @@ export const telemetryStore = new TelemetryStore();
 // Event Factory
 // ============================================================
 let eventCounter = 0;
-export function createEvent(type, sessionId, payload, missionId) {
+export function createEvent(type, sessionId, payload, missionId, graph) {
+    if (type.startsWith('graph.') && !graph) {
+        throw new Error(`Telemetry event '${type}' requires graph execution metadata.`);
+    }
     return {
         id: `evt-${Date.now()}-${++eventCounter}`,
         sessionId,
@@ -138,6 +141,7 @@ export function createEvent(type, sessionId, payload, missionId) {
         timestamp: new Date().toISOString(),
         type,
         payload,
+        ...(graph ? { graph: structuredClone(graph) } : {}),
     };
 }
 //# sourceMappingURL=telemetry.js.map

package/dist/src/smiths/context-pipeline/claude-hook.js

@@ -22,6 +22,7 @@
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import { buildProviderBootstrapBlock, PROVIDER_BOOTSTRAP_START, PROVIDER_BOOTSTRAP_END, } from './workspace-context.js';
+import { dominantLineEnding, withLineEnding } from './line-endings.js';
 export const CLAUDE_HOOK_START = '<!-- AIWG:claude-md-hook:start -->';
 export const CLAUDE_HOOK_END = '<!-- AIWG:claude-md-hook:end -->';
 function buildClaudeArtifactOutputPolicy(policy = {}) {
@@ -77,7 +78,7 @@ export async function ensureClaudeMdHook(projectPath, opts = {}) {
     catch {
         // Missing/legacy/temporarily malformed config receives the safe default.
     }
-    const block = buildClaudeHookBlock(policy);
+    let block = buildClaudeHookBlock(policy);
     // Case 1: CLAUDE.md does not exist — create a minimal one with just the block.
     let existing;
     try {
@@ -92,6 +93,8 @@ export async function ensureClaudeMdHook(projectPath, opts = {}) {
         }
         throw err;
     }
+    const lineEnding = dominantLineEnding(existing);
+    block = withLineEnding(block, lineEnding);
     const startIdx = existing.indexOf(CLAUDE_HOOK_START);
     const endIdx = existing.indexOf(CLAUDE_HOOK_END);
     // Case 2: marker block does not exist — append the block to end of file.
@@ -117,8 +120,8 @@ export async function ensureClaudeMdHook(projectPath, opts = {}) {
             return result;
         }
         // Ensure the file ends with a single newline before appending.
-        const trimmed = existing.replace(/\n+$/, '\n');
-        const updated = `${trimmed}\n${block}\n`;
+        const trimmed = existing.replace(/(?:\r?\n)+$/, lineEnding);
+        const updated = `${trimmed}${lineEnding}${block}${lineEnding}`;
         await fs.writeFile(claudeMdPath, updated, 'utf8');
         result.action = 'inserted';
         return result;
@@ -135,8 +138,8 @@ export async function ensureClaudeMdHook(projectPath, opts = {}) {
             await fs.writeFile(backupPath, existing, 'utf8');
             result.backupPath = backupPath;
         }
-        const trimmed = existing.replace(/\n+$/, '\n');
-        const updated = `${trimmed}\n${block}\n`;
+        const trimmed = existing.replace(/(?:\r?\n)+$/, lineEnding);
+        const updated = `${trimmed}${lineEnding}${block}${lineEnding}`;
         await fs.writeFile(claudeMdPath, updated, 'utf8');
         result.action = 'inserted';
         return result;

package/dist/src/smiths/context-pipeline/line-endings.js

@@ -0,0 +1,12 @@
+/** Select the majority line ending, preferring LF for ties and new files. */
+export function dominantLineEnding(content) {
+    const crlfCount = content.match(/\r\n/g)?.length ?? 0;
+    const newlineCount = content.match(/\n/g)?.length ?? 0;
+    const bareLfCount = newlineCount - crlfCount;
+    return crlfCount > bareLfCount ? '\r\n' : '\n';
+}
+/** Render generated text using the line-ending convention of existing content. */
+export function withLineEnding(content, lineEnding) {
+    return content.replace(/\r?\n/g, lineEnding);
+}
+//# sourceMappingURL=line-endings.js.map

package/dist/src/smiths/context-pipeline/managed-hook.js

@@ -14,6 +14,7 @@
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import { buildProviderBootstrapBlock } from './workspace-context.js';
+import { dominantLineEnding, withLineEnding } from './line-endings.js';
 export const CONTEXT_HOOK_START = '<!-- AIWG:context-hook:start -->';
 export const CONTEXT_HOOK_END = '<!-- AIWG:context-hook:end -->';
 /** The managed block — loads canonical workspace context before framework context. */
@@ -42,7 +43,7 @@ export function hasContextHook(content) {
  */
 export async function ensureManagedHook(filePath, opts = {}) {
     const base = path.basename(filePath);
-    const block = buildContextHookBlock(opts.provider);
+    let block = buildContextHookBlock(opts.provider);
     const result = { path: filePath, action: 'skipped', warnings: [] };
     let existing;
     try {
@@ -56,6 +57,8 @@ export async function ensureManagedHook(filePath, opts = {}) {
         }
         throw err;
     }
+    const lineEnding = dominantLineEnding(existing);
+    block = withLineEnding(block, lineEnding);
     // Already has both bare includes (operator wired them by hand) — nothing to do.
     if (!existing.includes(CONTEXT_HOOK_START) && /^[ \t]*@WORKSPACE\.md[ \t]*$/m.test(existing) && /^[ \t]*@AIWG\.md[ \t]*$/m.test(existing)) {
         result.action = 'unchanged';
@@ -65,16 +68,16 @@ export async function ensureManagedHook(filePath, opts = {}) {
     const e = existing.indexOf(CONTEXT_HOOK_END);
     // No managed block — append it to the end, preserving everything above.
     if (s === -1 && e === -1) {
-        const trimmed = existing.replace(/\n+$/, '\n');
-        await fs.writeFile(filePath, `${trimmed}\n${block}\n`, 'utf8');
+        const trimmed = existing.replace(/(?:\r?\n)+$/, lineEnding);
+        await fs.writeFile(filePath, `${trimmed}${lineEnding}${block}${lineEnding}`, 'utf8');
         result.action = 'inserted';
         return result;
     }
     // Malformed (one marker only) — repair only with --force to avoid clobbering.
     if (s === -1 || e === -1) {
         if (opts.force) {
-            const trimmed = existing.replace(/\n+$/, '\n');
-            await fs.writeFile(filePath, `${trimmed}\n${block}\n`, 'utf8');
+            const trimmed = existing.replace(/(?:\r?\n)+$/, lineEnding);
+            await fs.writeFile(filePath, `${trimmed}${lineEnding}${block}${lineEnding}`, 'utf8');
             result.action = 'inserted';
             return result;
         }