comisai 1.0.45 → 1.0.46

package/node_modules/@comis/daemon/dist/api/graph-handlers/graph-helpers.js

@@ -9,15 +9,14 @@
  * no factory: every helper is a pure function or interface so the dependency
  * graph stays one-directional (mutate / query / export → graph-helpers →
  * graph-repair). The conservative weak-model repair branch lives in the sibling
- * graph-repair.ts (DEFER-174-FILESIZE-01).
+ * graph-repair.ts.
  *
  * @module
  */
 import { parseExecutionGraph, validateAndSortGraph, systemGetEnv, } from "@comis/core";
-// DEFER-174-FILESIZE-01: the routing predicate, repair context, and the
-// conservative deterministic weak-model repair branch (AUTHOR-01, Phase 174-03)
-// live in the sibling `graph-repair.ts` to keep this file under the
-// graph-handlers/ 500-line cap (§2.8 shrink-only — behavior byte-identical).
+// The routing predicate, repair context, and the conservative deterministic
+// weak-model repair branch live in the sibling `graph-repair.ts` to keep this
+// file under the graph-handlers/ 500-line cap.
 // `isWeakCapabilityClass` + the two repair types are re-exported below so the
 // canonical import surface of `./graph-helpers.js` is unchanged (the
 // graph-helpers tests import `isWeakCapabilityClass` from this module).
@@ -48,17 +47,17 @@ export function transformNodes(rawNodes) {
         const node = raw;
         const rawTypeId = node.type_id ?? node.typeId;
         const rawTypeConfig = node.type_config ?? node.typeConfig;
-        // Bug-1 (OR-01) — collapse the redundant `agent` node type, in ALL its forms,
+        // Collapse the redundant `agent` node type, in ALL its forms,
         // to a regular single-agent node. The `agent` driver's config
         // (`{agent, model?, max_steps?}`) merely duplicates fields a regular
         // {agent, task} node already carries. Weak models emit it three malformed
         // ways, each tripping the validator's both-or-neither refine: (1) type_id:
-        // "agent" with NO type_config; (2) type_config:{agent:X} with NO type_id (the
-        // live 8-node NVDA DAG); (3) type_id:"agent" WITH type_config:{agent:X}.
+        // "agent" with NO type_config; (2) type_config:{agent:X} with NO type_id
+        // (observed in production); (3) type_id:"agent" WITH type_config:{agent:X}.
         // Collapse all three to a regular node (lifting agent/model/max_steps out of
         // the config), keeping the both-or-neither rule strict for the SIX real typed
         // nodes (debate/vote/refine/collaborate/approval-gate/map-reduce — none of
-        // which use a bare `agent` config). See design/small-model-orchestration-fidelity.md §4.
+        // which use a bare `agent` config).
         const tc = (rawTypeConfig !== null && typeof rawTypeConfig === "object" && !Array.isArray(rawTypeConfig))
             ? rawTypeConfig : undefined;
         // A "bare agent config" is the agent-driver shape: an `agent` string plus at
@@ -83,7 +82,7 @@ export function transformNodes(rawNodes) {
             ...(node.barrier_mode ?? node.barrierMode
                 ? { barrierMode: node.barrier_mode ?? node.barrierMode } : {}),
             ...(node.retries !== undefined ? { retries: node.retries } : {}),
-            // P0-A: forward the per-node tokenBudget override (GraphNodeSchema field, highest-
+            // Forward the per-node tokenBudget override (GraphNodeSchema field, highest-
             // precedence budget source — resolveNodeBudgetWithSource capSource "node"). Without
             // this it was silently dropped here, so an author-set per-node cap never bound the node.
             ...((node.token_budget ?? node.tokenBudget) !== undefined
@@ -103,9 +102,9 @@ export function transformNodes(rawNodes) {
  * parseExecutionGraph, and validates with validateAndSortGraph. Throws
  * descriptive errors on parse or validation failure.
  *
- * ASYNC (AUTHOR-01 / Phase 174-03): the weak-model invalid branch may run the
+ * ASYNC: the weak-model invalid branch may run the
  * conservative repair (graph-repair.ts), so the function returns a Promise. ALL
- * call sites await it (3 production in graph-mutate.ts + the O3 test call sites).
+ * call sites await it (3 production in graph-mutate.ts + the test call sites).
  *
  *   - Capable tier (frontier / mid / undefined): the existing direct path —
  *     byte-identical, no behavior change. The repairProducer gate resolves the
@@ -148,23 +147,24 @@ export async function buildGraphInput(params, capabilityClass, repair) {
         // Graph is already valid — return immediately without repair.
         return validateResult.value;
     }
-    // Weak + INVALID. AUTHOR-01: the conservative, gated, deterministic repair
-    // (extracted into graph-repair.ts — DEFER-174-FILESIZE-01; behavior unchanged).
+    // Weak + INVALID: the conservative, gated, deterministic repair
+    // (extracted into graph-repair.ts).
     // (FLAGS-OFF can never reach here — capabilityClass resolves undefined when the
     // gate is off, so isWeakCapabilityClass is false above and the capable path
     // ran. This is reached ONLY when repairProducer is on AND the server-resolved
     // tier is weak.) An unambiguous match re-governed clean returns the repaired
     // graph; an ambiguous shape throws a structured did-you-mean from within the
-    // repair helper (T-174-FALSESYNTH); no-match / gate-off / a repaired graph that
-    // itself fails re-validation falls through to the fail-closed throw below.
+    // repair helper (never a silently guessed graph); no-match / gate-off / a
+    // repaired graph that itself fails re-validation falls through to the
+    // fail-closed throw below.
     const repaired = attemptWeakModelRepair(rawGraph, capabilityClass, repair);
     if (repaired.kind === "repaired") {
         return repaired.value;
     }
-    // FLAGS-OFF (and no-match / failed-repair): the existing fail-closed throw.
-    // Phase 174 (the former Phase 157) IS the repair consumer above; this throw
-    // remains the recourse when the gate is off or no conservative match exists.
-    throw new Error(`Graph validation failed (weak model, Phase 157 repair deferred): ${validateResult.error.message}`);
+    // No-match / failed-repair: the fail-closed throw. The repair branch above
+    // is the only consumer of an invalid weak-tier graph; this throw remains the
+    // recourse when the gate is off or no conservative match exists.
+    throw new Error(`Graph validation failed (weak model, automatic repair not yet wired): ${validateResult.error.message}`);
 }
 // ---------------------------------------------------------------------------
 // Graph Warnings (soft validation)

package/node_modules/@comis/daemon/dist/api/graph-handlers/graph-mutate-telemetry.d.ts

@@ -20,18 +20,18 @@ export type SynthPattern = (typeof SYNTH_PATTERNS)[number];
 export declare const isSynthPattern: (v: string) => v is SynthPattern;
 /** The authoring telemetry/audit helpers bound over GraphHandlerDeps. */
 export interface GraphMutateTelemetry {
-    /** TELEM-01: emit a counts-only `pipeline:authored` per authoring invocation. */
+    /** Emit a counts-only `pipeline:authored` per authoring invocation. */
     emitPipelineAuthored: (action: "define" | "execute", schemaValid: boolean, rawParams: Record<string, unknown>) => void;
-    /** AUTHOR-01: resolve the calling agent's tier SERVER-SIDE, gated on repairProducer. */
+    /** Resolve the calling agent's tier SERVER-SIDE, gated on repairProducer. */
     resolveAuthoringTier: (d: GraphHandlerDeps, rawParams: Record<string, unknown>) => "frontier" | "mid" | "small" | "nano" | undefined;
-    /** AUTHOR-01: assemble the repair context buildGraphInput needs for the gated branch. */
+    /** Assemble the repair context buildGraphInput needs for the gated branch. */
     repairContext: (d: GraphHandlerDeps, rawParams: Record<string, unknown>) => BuildGraphRepairContext;
-    /** AUTHOR-02: best-effort audit emit for a from_intent synthesis. */
+    /** Best-effort audit emit for a from_intent synthesis. */
     emitGraphSynthesized: (pattern: SynthPattern, nodeCount: number, rawParams: Record<string, unknown>) => void;
 }
 /**
  * Build the authoring telemetry/audit helpers over the injected deps. The
  * emitters are best-effort (try/catch guarded) — telemetry can never break the
- * operation it measures (WR-01, Phase 173 review).
+ * operation it measures.
  */
 export declare function createGraphMutateTelemetry(deps: GraphHandlerDeps): GraphMutateTelemetry;

package/node_modules/@comis/daemon/dist/api/graph-handlers/graph-mutate-telemetry.js

@@ -21,21 +21,20 @@ export const isSynthPattern = (v) => SYNTH_PATTERNS.includes(v);
 /**
  * Build the authoring telemetry/audit helpers over the injected deps. The
  * emitters are best-effort (try/catch guarded) — telemetry can never break the
- * operation it measures (WR-01, Phase 173 review).
+ * operation it measures.
  */
 export function createGraphMutateTelemetry(deps) {
-    // TELEM-01 (Phase 173-02): emit a counts-only `pipeline:authored` per
-    // authoring invocation (define + execute), where schema validity and the
-    // resolved capabilityClass tier converge. Counts/ids/closed-enums ONLY — no
-    // node task, type_config value, label, or any pipeline body reaches the bus
-    // (§2.7 / D-EVENT). The tier is resolved DAEMON-SIDE from the RAW _agentId
-    // (Spoofing mitigation T-173-03) via the injected resolver — never a
-    // tool-supplied param — and fail-safes to "unknown" when unresolvable
-    // (Pitfall 2: record honestly, never silently drop, never default to
+    // Emit a counts-only `pipeline:authored` per authoring invocation (define +
+    // execute), where schema validity and the resolved capabilityClass tier
+    // converge. Counts/ids/closed-enums ONLY — no node task, type_config value,
+    // label, or any pipeline body reaches the bus (§2.7). The tier is resolved
+    // DAEMON-SIDE from the RAW _agentId (spoofing mitigation) via the injected
+    // resolver — never a tool-supplied param — and fail-safes to "unknown" when
+    // unresolvable (record honestly, never silently drop, never default to
     // "frontier"). `repaired` is the literal false: the weak-model repair
-    // producer is Phase 174 / AUTHOR-01 and is NOT wired here.
+    // producer is a separate path (see graph-repair.ts) and is NOT wired here.
     //
-    // METRIC DENOMINATOR (Phase 173 review WR-02): an authoring invocation is
+    // METRIC DENOMINATOR: an authoring invocation is
     // counted on every CONTRACT-PARSE-REACHABLE path — graph.define emits on a
     // strict-contract parse rejection AND a buildGraphInput throw; graph.execute
     // (a loose z.record contract) emits on the buildGraphInput throw. The bespoke
@@ -45,7 +44,7 @@ export function createGraphMutateTelemetry(deps) {
     // deliberate (documented in fleet-findings.ts's pipeline_authoring finding +
     // docs/developer-guide/event-bus.mdx).
     const emitPipelineAuthored = (action, schemaValid, rawParams) => {
-        // WR-01 (Phase 173 review): the emit MUST be best-effort — telemetry can
+        // The emit MUST be best-effort — telemetry can
         // never break the operation it measures. `deps.eventBus.emit` delegates to
         // Node's EventEmitter with NO listener error isolation, and the subscribed
         // `pipeline:authored` listener pushes into the obs diagnostic buffer whose
@@ -77,17 +76,17 @@ export function createGraphMutateTelemetry(deps) {
             }, "pipeline-authoring telemetry emit failed (best-effort)");
         }
     };
-    // AUTHOR-01 (Phase 174-03): resolve the calling agent's capabilityClass tier
-    // for the buildGraphInput repair decision, GATED on repairProducer. When the
-    // gate is off (or absent) this returns undefined so buildGraphInput takes the
-    // capable direct path — byte-identical to pre-174 (D-GATED-OFF). The tier is
-    // resolved SERVER-SIDE from the RAW _agentId (Spoofing mitigation T-174-SPOOF /
-    // T-173-03), reusing 173's injected resolveCapabilityClass — the tool-supplied
-    // capabilityClass param is NEVER read for the tier.
+    // Resolve the calling agent's capabilityClass tier for the buildGraphInput
+    // repair decision, GATED on repairProducer. When the gate is off (or absent)
+    // this returns undefined so buildGraphInput takes the capable direct path —
+    // byte-identical to the ungated behavior. The tier is resolved SERVER-SIDE
+    // from the RAW _agentId (spoofing mitigation), reusing the injected
+    // resolveCapabilityClass — the tool-supplied capabilityClass param is NEVER
+    // read for the tier.
     const resolveAuthoringTier = (d, rawParams) => d.authoringConfig?.repairProducer
         ? d.resolveCapabilityClass?.(rawParams._agentId)
         : undefined;
-    // AUTHOR-01: assemble the repair context buildGraphInput needs for the gated
+    // Assemble the repair context buildGraphInput needs for the gated
     // weak-model branch (the injected matcher + gate + best-effort emit inputs).
     // Correlation ids ride from the RAW params (envelope-only — never body).
     const repairContext = (d, rawParams) => ({
@@ -98,8 +97,8 @@ export function createGraphMutateTelemetry(deps) {
         agentId: rawParams._agentId,
         sessionKey: rawParams._callerSessionKey,
     });
-    // AUTHOR-02 (Phase 174-04): best-effort audit emit for a from_intent synthesis
-    // (mirrors emitPipelineAuthored's WR-01 guard — telemetry never breaks the
+    // Best-effort audit emit for a from_intent synthesis
+    // (mirrors emitPipelineAuthored's guard — telemetry never breaks the
     // measured op). Counts/ids/closed-enums ONLY (pattern + GOVERNED node count +
     // correlation ids; NEVER the graph body / node task / one-line intent — §2.7).
     // Called AFTER buildGraphInput + validateTypeConfigs, so it reflects a GOVERNED graph.

package/node_modules/@comis/daemon/dist/api/graph-handlers/graph-mutate.js

@@ -37,7 +37,7 @@ export function bindGraphMutateHandlers(deps) {
     const { emitPipelineAuthored, resolveAuthoringTier, repairContext, emitGraphSynthesized } = createGraphMutateTelemetry(deps);
     return {
         [GraphDefineContract.method]: async (rawParams) => {
-            // CAP-03/05 (v8 §3.7): in-process capability gate — the agent loop skips
+            // In-process capability gate — the agent loop skips
             // checkScope, so orch:graph is enforced here, reading the injected
             // _capabilities from raw params BEFORE the strip.
             requireCapability(rawParams._capabilities, "orch:graph");
@@ -49,7 +49,7 @@ export function bindGraphMutateHandlers(deps) {
                 throw new Error("Missing required parameter: nodes");
             }
             const userParams = stripInternalFields(rawParams);
-            // WR-02 (Phase 173 review): a present-but-malformed authoring call that
+            // A present-but-malformed authoring call that
             // fails the STRICT GraphDefineContract z.object (e.g. a wrong-typed
             // contract field) throws HERE, before buildGraphInput — yet it is a
             // genuine small-model "authored an invalid pipeline" attempt. Emit
@@ -67,13 +67,13 @@ export function bindGraphMutateHandlers(deps) {
                 emitPipelineAuthored("define", false, rawParams);
                 throw e;
             }
-            // AUTHOR-01 (Phase 174-03): resolve the calling agent's tier SERVER-SIDE,
+            // Resolve the calling agent's tier SERVER-SIDE,
             // gated on repairProducer. FLAGS-OFF (or absent) ⇒ undefined ⇒ the capable
-            // direct-emit path ⇒ byte-identical to pre-174. NEVER read the tool-supplied
-            // userParams.capabilityClass for the tier (the spoofing surface 173 closed,
-            // T-174-SPOOF / T-173-03 — a weak model claiming "frontier" to skip repair).
+            // direct-emit path ⇒ byte-identical to the ungated behavior. NEVER read the
+            // tool-supplied userParams.capabilityClass for the tier — that is a spoofing
+            // surface (a weak model claiming "frontier" to skip repair).
             const capabilityClass = resolveAuthoringTier(deps, rawParams);
-            // TELEM-01: capture the REAL buildGraphInput parse+validate verdict.
+            // Capture the REAL buildGraphInput parse+validate verdict.
             // buildGraphInput THROWS on parse/validate failure — emit schemaValid:false
             // and re-throw (the existing user-facing error contract is unchanged);
             // on success emit schemaValid:true BEFORE the later type_config/warning
@@ -103,36 +103,36 @@ export function bindGraphMutateHandlers(deps) {
             return result;
         },
         [GraphExecuteContract.method]: async (rawParams) => {
-            // CAP-03/05 (v8 §3.7): in-process capability gate (see graph.define).
+            // In-process capability gate (see graph.define).
             requireCapability(rawParams._capabilities, "orch:graph");
             // Bespoke pre-Zod validation FIRST.
             if (!deps.securityConfig.agentToAgent?.enabled) {
                 throw new Error("Agent-to-agent messaging is disabled by policy.");
             }
-            // AUTHOR-02 (Phase 174-04): read the from_intent marker BEFORE the strip
+            // Read the from_intent marker BEFORE the strip
             // (mirrors the _agentId/_callerSessionKey precedent — internal fields are
             // read from rawParams). It is the in-band signal the from_intent tool sets
             // so the daemon can GATE + AUDIT the synthesis at this chokepoint (the
             // synthesizer runs in the skills tool, separated from here by JSON-RPC).
             const synthPattern = rawParams._synthesizedFromIntent;
-            // FLAGS-OFF refusal (D-GATED-OFF / T-174-INTENT-GATE): refuse a from_intent
+            // FLAGS-OFF refusal: refuse a from_intent
             // dispatch when orchestration.authoring.intentAction is off, BEFORE any
             // graph runs. A non-from_intent execute (no marker) is wholly unaffected —
-            // byte-identical to pre-174.
+            // byte-identical to the ungated behavior.
             if (synthPattern && !deps.authoringConfig?.intentAction) {
-                // Typed (OBS-RPC-REFUSAL-CLASS): a gated-off policy refusal is a caller
+                // Typed: a gated-off policy refusal is a caller
                 // precondition failure, not an internal handler fault — classifyRpcError maps
                 // PreconditionError to precondition/warn so it doesn't read as a fleet ERROR.
                 throw new PreconditionError("from_intent authoring is disabled by policy (orchestration.authoring.intentAction).");
             }
             const userParams = stripInternalFields(rawParams);
-            // M-1 (T-174-MARKER-LEAK): _synthesizedFromIntent is NOT in
+            // Marker-leak guard: _synthesizedFromIntent is NOT in
             // INTERNAL_FIELD_NAMES (a single-use graph-handler-local marker, not a
             // shared dispatcher field), and GraphExecuteContract.request is a loose
             // z.record — so the strip alone leaves it on userParams → it would reach
             // buildGraphInput. Remove it explicitly so it never reaches the graph builder.
             delete userParams._synthesizedFromIntent;
-            // WR-02 (Phase 173 review): unlike graph.define, GraphExecuteContract is a
+            // Unlike graph.define, GraphExecuteContract is a
             // LOOSE z.record(z.string(), z.unknown()) — it accepts essentially any
             // object, so a present-but-malformed authoring call does NOT throw here.
             // It instead reaches buildGraphInput below, which already emits
@@ -140,11 +140,11 @@ export function bindGraphMutateHandlers(deps) {
             // contract-parse-level denominator gap on the execute path; no emit guard
             // is needed around this parse.
             GraphExecuteContract.request.parse(userParams);
-            // AUTHOR-01 (Phase 174-03): server-side gated tier — see graph.define.
+            // Server-side gated tier — see graph.define.
             // FLAGS-OFF ⇒ undefined ⇒ capable path (byte-identical). The tool-supplied
-            // userParams.capabilityClass is never read for the tier (T-174-SPOOF).
+            // userParams.capabilityClass is never read for the tier (spoofing surface).
             const capabilityClass = resolveAuthoringTier(deps, rawParams);
-            // TELEM-01: same try/catch verdict capture as graph.define — emit
+            // Same try/catch verdict capture as graph.define — emit
             // schemaValid:false on a parse/validate throw (still re-throwing), true
             // on success, before the coordinator dispatch.
             let validated;
@@ -157,8 +157,8 @@ export function bindGraphMutateHandlers(deps) {
             }
             emitPipelineAuthored("execute", true, rawParams);
             validateTypeConfigs(validated.graph, deps.nodeTypeRegistry);
-            // AUTHOR-02 (Phase 174-04): emit the synthesis audit AFTER governance
-            // succeeded, so it reflects a GOVERNED graph (T-174-SYNTH-EMIT best-effort).
+            // Emit the synthesis audit AFTER governance
+            // succeeded, so it reflects a GOVERNED graph (best-effort emit).
             // Only when the marker was set AND intentAction is on (FLAGS-OFF already threw).
             if (synthPattern && deps.authoringConfig?.intentAction && isSynthPattern(synthPattern)) {
                 emitGraphSynthesized(synthPattern, validated.graph.nodes.length, rawParams);
@@ -227,7 +227,7 @@ export function bindGraphMutateHandlers(deps) {
             return result;
         },
         [GraphCancelContract.method]: async (rawParams) => {
-            // CAP-03/05 (v8 §3.7): in-process capability gate (see graph.define).
+            // In-process capability gate (see graph.define).
             requireCapability(rawParams._capabilities, "orch:graph");
             // Bespoke pre-Zod validation FIRST.
             if (!deps.securityConfig.agentToAgent?.enabled) {
@@ -253,7 +253,7 @@ export function bindGraphMutateHandlers(deps) {
         // Named graph persistence
         // -----------------------------------------------------------------
         [GraphSaveContract.method]: async (rawParams) => {
-            // CAP-03/05 (v8 §3.7): in-process capability gate (see graph.define).
+            // In-process capability gate (see graph.define).
             requireCapability(rawParams._capabilities, "orch:graph");
             // Bespoke pre-Zod validation FIRST.
             if (!deps.namedGraphStore) {
@@ -269,12 +269,12 @@ export function bindGraphMutateHandlers(deps) {
             const tenantId = deps.tenantId ?? "default";
             const agentId = rawParams.agentId ?? deps.defaultAgentId;
             // Validate structure (typeId/typeConfig pairing, DAG sort, Zod schema).
-            // AUTHOR-01 (Phase 174-03): server-side gated tier — see graph.define.
+            // Server-side gated tier — see graph.define.
             // FLAGS-OFF ⇒ undefined ⇒ capable direct path (byte-identical).
             const capabilityClass = resolveAuthoringTier(deps, rawParams);
             const validated = await buildGraphInput(userParams, capabilityClass, repairContext(deps, rawParams));
             validateTypeConfigs(validated.graph, deps.nodeTypeRegistry);
-            // DEFER-174-SAVE (IN-01): persists ORIGINAL raw nodes, not the validated/repaired graph (pre-existing graph.save behavior; rationale: deferred-items.md).
+            // Deliberate: persists the ORIGINAL raw nodes, not the validated/repaired graph — the raw form preserves the author's input verbatim, and a loaded graph passes through buildGraphInput validation again when executed.
             deps.namedGraphStore.save({
                 id,
                 tenantId,
@@ -290,7 +290,7 @@ export function bindGraphMutateHandlers(deps) {
             return result;
         },
         [GraphDeleteContract.method]: async (rawParams) => {
-            // CAP-03/05 (v8 §3.7): in-process capability gate (see graph.define).
+            // In-process capability gate (see graph.define).
             requireCapability(rawParams._capabilities, "orch:graph");
             // Bespoke pre-Zod validation FIRST.
             if (!deps.namedGraphStore) {
@@ -313,7 +313,7 @@ export function bindGraphMutateHandlers(deps) {
             return result;
         },
         [GraphDeleteRunContract.method]: async (rawParams) => {
-            // CAP-03/05 (v8 §3.7): in-process capability gate (see graph.define).
+            // In-process capability gate (see graph.define).
             // graph.deleteRun is a mutating graph op → orch:graph (HANDLER_CAPABILITY_MAP).
             requireCapability(rawParams._capabilities, "orch:graph");
             // Bespoke pre-Zod validation FIRST.

package/node_modules/@comis/daemon/dist/api/graph-handlers/graph-repair.d.ts

@@ -1,8 +1,8 @@
 /**
- * Graph repair (AUTHOR-01, Phase 174-03).
+ * Graph repair.
  *
  * The conservative, gated, deterministic weak-model repair branch extracted out
- * of `graph-helpers.ts` (DEFER-174-FILESIZE-01 — a §2.8 shrink-only refactor to
+ * of `graph-helpers.ts` (a §2.8 shrink-only refactor to
  * keep the graph-handlers/ subdir under its 500-line cap). Pure extraction: the
  * behavior, throw messages, and the `graph:repaired` emit shape are byte-identical
  * to the in-line block they replace. `buildGraphInput` (graph-helpers.ts) calls
@@ -36,9 +36,9 @@ type ValidatedGraphResult = Extract<ReturnType<typeof validateAndSortGraph>, {
     ok: true;
 }>["value"];
 /**
- * Optional repair context for buildGraphInput's weak-model branch (AUTHOR-01).
+ * Optional repair context for buildGraphInput's weak-model branch.
  * Carries the injected gate + matcher + the best-effort emit inputs. Absent in
- * legacy callers (tests that pass only params + capabilityClass) ⇒ the repair
+ * callers that pass only params + capabilityClass (unit tests) ⇒ the repair
  * branch is never entered ⇒ byte-identical fail-closed behavior.
  */
 export interface BuildGraphRepairContext {
@@ -46,7 +46,7 @@ export interface BuildGraphRepairContext {
      * The orchestration.authoring gate (config.orchestration.authoring). When
      * `repairProducer` is true AND the calling agent resolves to a weak tier, an
      * invalid graph routes to the conservative deterministic repair instead of the
-     * fail-closed Phase-157 throw. Shape mirrors GraphHandlerDeps.authoringConfig.
+     * fail-closed invalid-graph throw. Shape mirrors GraphHandlerDeps.authoringConfig.
      */
     authoringConfig?: {
         repairProducer: boolean;
@@ -82,10 +82,11 @@ interface RawGraphForRepair {
  * Result of the weak-model repair attempt.
  *   - "repaired": an unambiguous match was re-governed clean → return `value`.
  *   - "fall-through": no-match, gate off, or a repaired graph that itself failed
- *     re-validation → the caller throws its existing fail-closed Phase-157 error
- *     (so the throw message stays owned by buildGraphInput, byte-identical).
+ *     re-validation → the caller throws its existing fail-closed invalid-graph
+ *     error (so the throw message stays owned by buildGraphInput, byte-identical).
  * The "ambiguous" verdict throws a structured did-you-mean directly here
- * (T-174-FALSESYNTH — no synthesis on an ambiguous shape).
+ * (no synthesis on an ambiguous shape — a wrong guess would silently run the
+ * wrong pipeline).
  */
 export type WeakModelRepairResult = {
     kind: "repaired";
@@ -94,8 +95,8 @@ export type WeakModelRepairResult = {
     kind: "fall-through";
 };
 /**
- * The conservative, gated, deterministic repair for a weak + INVALID graph
- * (AUTHOR-01). Reached ONLY when repairProducer is on AND the server-resolved
+ * The conservative, gated, deterministic repair for a weak + INVALID graph.
+ * Reached ONLY when repairProducer is on AND the server-resolved
  * tier is weak (FLAGS-OFF can never reach here — capabilityClass resolves
  * undefined when the gate is off, so isWeakCapabilityClass is false upstream and
  * the capable path ran).

package/node_modules/@comis/daemon/dist/api/graph-handlers/graph-repair.js

@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: Apache-2.0
 // @allow-throw: RPC handler module — all throws are caught and converted to JSON-RPC error responses by rpc-dispatch.ts:306-321.
 /**
- * Graph repair (AUTHOR-01, Phase 174-03).
+ * Graph repair.
  *
  * The conservative, gated, deterministic weak-model repair branch extracted out
- * of `graph-helpers.ts` (DEFER-174-FILESIZE-01 — a §2.8 shrink-only refactor to
+ * of `graph-helpers.ts` (a §2.8 shrink-only refactor to
  * keep the graph-handlers/ subdir under its 500-line cap). Pure extraction: the
  * behavior, throw messages, and the `graph:repaired` emit shape are byte-identical
  * to the in-line block they replace. `buildGraphInput` (graph-helpers.ts) calls
@@ -32,8 +32,8 @@ export function isWeakCapabilityClass(capabilityClass) {
     return capabilityClass === "small" || capabilityClass === "nano";
 }
 /**
- * The conservative, gated, deterministic repair for a weak + INVALID graph
- * (AUTHOR-01). Reached ONLY when repairProducer is on AND the server-resolved
+ * The conservative, gated, deterministic repair for a weak + INVALID graph.
+ * Reached ONLY when repairProducer is on AND the server-resolved
  * tier is weak (FLAGS-OFF can never reach here — capabilityClass resolves
  * undefined when the gate is off, so isWeakCapabilityClass is false upstream and
  * the capable path ran).
@@ -49,10 +49,10 @@ export function isWeakCapabilityClass(capabilityClass) {
 export function attemptWeakModelRepair(rawGraph, capabilityClass, repair) {
     if (repair?.authoringConfig?.repairProducer && repair.repairMatch) {
         // Match the ORIGINAL (snake/camel-normalized) raw graph by shape. The
-        // matcher is pure + deterministic (no model reprompt — D-CONSERVATIVE).
+        // matcher is pure + deterministic (no model reprompt).
         const m = repair.repairMatch(rawGraph);
         if (m.kind === "matched") {
-            // Re-run the SAME governance on the repaired graph (D-SAME-VALIDATION §9):
+            // Re-run the SAME governance on the repaired graph:
             // parse → topo-sort. A repaired graph is NEVER returned unvalidated.
             const reparsed = parseExecutionGraph({ nodes: m.filledNodes, label: rawGraph.label });
             if (reparsed.ok) {
@@ -66,7 +66,7 @@ export function attemptWeakModelRepair(rawGraph, capabilityClass, repair) {
             // existing throw (never return an unvalidated graph).
         }
         else if (m.kind === "ambiguous") {
-            // T-174-FALSESYNTH: no synthesis on an ambiguous shape — surface the
+            // No synthesis on an ambiguous shape — surface the
             // plausible templates so the model can pick one explicitly.
             throw new Error(`Graph invalid and ambiguous. Did you mean one of these templates: ${m.candidates.join(", ")}? Use the from_intent action with an explicit pattern.`);
         }
@@ -75,10 +75,10 @@ export function attemptWeakModelRepair(rawGraph, capabilityClass, repair) {
     return { kind: "fall-through" };
 }
 /**
- * Best-effort emit of graph:repaired (AUTHOR-01). Mirrors the 173
+ * Best-effort emit of graph:repaired. Mirrors the
  * emitPipelineAuthored guard: telemetry MUST NEVER break the operation it
  * measures (the bus has no listener error isolation; a diagnostic-buffer SQLite
- * flush can throw). Counts/ids/enums ONLY — never the graph body (§2.7 / D-EVENT).
+ * flush can throw). Counts/ids/enums ONLY — never the graph body (§2.7).
  */
 function emitGraphRepaired(repair, pattern, nodeCount, capabilityClass) {
     try {

package/node_modules/@comis/daemon/dist/api/grok-adapter.d.ts

@@ -1,44 +1,44 @@
 /**
- * xAI Grok Imagine video adapter (GROK-01 / GROK-02).
+ * xAI Grok Imagine video adapter.
  *
  * A `VideoGenerationPort` over the xAI REST video API. Unlike the FAL adapter
  * (an SDK queue) and the Veo adapter (an SDK LRO), xAI ships NO JS SDK for video
  * — this adapter is RAW `fetch` against `api.x.ai/v1/videos`:
  *   - submit:  `POST /v1/videos/generations { model, prompt, ... }` → the REST
- *              `request_id` is the durable, secret-free jobId (VPORT-03) —
+ *              `request_id` is the durable, secret-free jobId —
  *              DIFFERS from Veo's `operation.name`.
  *   - poll:    `GET /v1/videos/{request_id}` → a `status` STRING union
  *              `pending | done | failed | expired`. The `failed`+`expired`
  *              terminals DIFFER from FAL (no failed status) and Veo (an
  *              `operation.error` object) — both map to the normalized `"failed"`.
- *   - fetch:   `status:"done"` → `video.url` fetched → a Buffer (DEL-01:
- *              download BEFORE return so the expiring CDN URL can never orphan
- *              the job); `usage.cost_in_usd_ticks / 1e10` → the ACTUAL cost.
+ *   - fetch:   `status:"done"` → `video.url` fetched → a Buffer (download BEFORE
+ *              return so the expiring CDN URL can never orphan the job);
+ *              `usage.cost_in_usd_ticks / 1e10` → the ACTUAL cost.
  *
  * WIRE-ENCODING DIFFERENCES (vs FAL/Veo): `duration` is an INTEGER seconds value
  * (NOT the FAL `${n}s` string, NOT Veo's `durationSeconds`); resolution is
  * `480p`/`720p` ONLY (the corrected live-doc drift — NOT 1080p; validated
- * upstream by the Phase 191 VIDEO_MODELS matrix, passed through here). The model
+ * upstream by the VIDEO_MODELS matrix, passed through here). The model
  * default is `grok-imagine-video` — the ONLY documented GA id; gate any
  * `-preview` behind config.
  *
- * COST (GROK-02): `reconcileTicksToUsd` converts `cost_in_usd_ticks` to USD
+ * COST: `reconcileTicksToUsd` converts `cost_in_usd_ticks` to USD
  * (1 USD = 1e10 ticks, CITED docs.x.ai) and GUARDS against a non-number / NaN /
  * non-finite / NEGATIVE value — a spoofed-negative `cost_in_usd_ticks` must NOT
  * produce a negative `costUsd` that under-reports spend and bypasses the SHIPPED
- * cost ceiling (T-190-09). An invalid/absent value → `undefined`, so the handler
+ * cost ceiling. An invalid/absent value → `undefined`, so the handler
  * falls back to the pre-submit estimate.
  *
- * AUTH (A1 — key-primary, OAuth defensive): the `XAI_API_KEY` Bearer is the
+ * AUTH (key-primary, OAuth defensive): the `XAI_API_KEY` Bearer is the
  * WIRED/proven PRIMARY path. A SuperGrok OAuth branch is built DEFENSIVELY in the
- * codex-image-adapter per-call-bearer shape so CRED-01's key-or-OAuth contract
- * holds structurally — BUT there is NO xai/SuperGrok OAuth provider registered in
- * the codebase today (`oauthManager.getSupportedProviders()` returns only
- * `openai-codex`), so the OAuth branch is forward-looking: it activates when/if
- * pi-ai adds an xAI OAuth provider. Key-auth is the documented common case; GROK
- * is NOT blocked on OAuth. The static `XAI_API_KEY` is BOOT-BOUND (captured at
- * construction, rotation needs a daemon restart); only the defensive OAuth branch
- * is per-call-fresh (WR-03 — see `resolveBearer`).
+ * codex-image-adapter per-call-bearer shape so the key-or-OAuth availability
+ * contract holds structurally — BUT there is NO xai/SuperGrok OAuth provider
+ * registered in the codebase today (`oauthManager.getSupportedProviders()` returns
+ * only `openai-codex`), so the OAuth branch is forward-looking: it activates
+ * when/if pi-ai adds an xAI OAuth provider. Key-auth is the documented common
+ * case; Grok is NOT blocked on OAuth. The static `XAI_API_KEY` is BOOT-BOUND
+ * (captured at construction, rotation needs a daemon restart); only the defensive
+ * OAuth branch is per-call-fresh (see `resolveBearer`).
  *
  * PLACEMENT: this adapter lives in `@comis/daemon/src/api/` (NOT `@comis/skills`,
  * where `fal-adapter.ts` lives). The OAuth path needs the daemon-side
@@ -50,7 +50,7 @@
  *
  * SECURITY: the bearer (key OR OAuth token) flows ONLY into the `Authorization`
  * header — NEVER to a logger. The `request_id` jobId is opaque + secret-free
- * (safe to log — VPORT-03). If `opts.logger` is used, only `{ model, jobId, step }`
+ * (safe to log). If `opts.logger` is used, only `{ model, jobId, step }`
  * shapes are logged.
  *
  * @module
@@ -58,18 +58,18 @@
 import type { OAuthTokenManager, VideoGenerationPort } from "@comis/core";
 import type { ComisLogger } from "@comis/infra";
 /**
- * The ASSUMED SuperGrok OAuth provider id (A1 — UNVERIFIED/forward-looking). No
+ * The ASSUMED SuperGrok OAuth provider id (UNVERIFIED/forward-looking). No
  * xai OAuth provider is registered in the codebase today; this id is used only by
  * the defensive OAuth branch and activates when/if pi-ai adds one.
  *
- * IN-02 (Phase 190): EXPORTED as the single source of truth — the boot selector
+ * EXPORTED as the single source of truth — the boot selector
  * (setup-video-provider.ts) gates `oauthManager.hasCredentials(...)` on this SAME
  * constant rather than a bare `"xai"` literal, so the selector's credsAvailable
  * gate can never drift from what the adapter actually resolves if a future xai
  * OAuth provider registers under a different id.
  */
 export declare const XAI_OAUTH_PROVIDER_ID = "xai";
-/** Options bounding the result download (WR-01). Copied from fal-adapter.ts. */
+/** Options bounding the result download. Copied from fal-adapter.ts. */
 export interface VideoFetchResultOpts {
     signal?: AbortSignal;
     maxBytes?: number;
@@ -80,8 +80,8 @@ export interface VideoFetchResultOpts {
  * @param opts.apiKey       - The `XAI_API_KEY` Bearer (the PRIMARY, wired path;
  *   flows ONLY into the `Authorization` header, never logged). Exactly one of
  *   `apiKey`/`oauthManager` is the auth source; the key wins when present.
- * @param opts.oauthManager - The DEFENSIVE SuperGrok OAuth manager (A1 —
- *   forward-looking; no xai OAuth provider registered today). Its `getApiKey`
+ * @param opts.oauthManager - The DEFENSIVE SuperGrok OAuth manager
+ *   (forward-looking; no xai OAuth provider registered today). Its `getApiKey`
  *   refreshes inside on expiry; `hasCredentials` backs `isAvailable`.
  * @param opts.oauthProfiles - The agent's `Record<provider, profileId>` map,
  *   passed to `getApiKey` for per-agent profile preference.