comisai 1.0.45 → 1.0.46

package/node_modules/@comis/core/dist/config/schema-skills.js

@@ -103,36 +103,36 @@ const ToolDiscoverySchema = z.strictObject({
      *  BM25 scores are normalized to [0, 1] before this floor applies,
      *  matching the semantics of minHybridScore. A value of 0.8 means
      *  "return only tools scoring >= 80% of the top match". Values > 1.0 fail
-     *  validation at config load (stale raw-score overrides would produce zero
-     *  matches under the new normalized semantics; fail-fast surfaces the
+     *  validation at config load (a raw-score override above 1.0 would produce
+     *  zero matches under the normalized semantics; fail-fast surfaces the
      *  error immediately). */
     minBm25Score: z.number().min(0).max(1).default(0.8),
     /** Minimum combined score (0..1 normalized) for hybrid mode. Default 0.35. */
     minHybridScore: z.number().min(0).max(1).default(0.35),
 });
 /**
- * One allowlist entry for the interactive terminal driver (spec §6).
+ * One allowlist entry for the interactive terminal driver.
  *
  * `z.strictObject` at EVERY level: unknown/typo'd keys throw at config load
  * rather than being silently dropped, so an operator-declared restriction is
  * always actually parsed. The `allow` list is operator config only —
- * never agent-extensible. The whole spec §6 shape is modelled now even though
- * the initial worker consumes only a subset (`match` + `scope`); later work
- * consumes the rest, and the full allow-set must round-trip.
+ * never agent-extensible. The whole entry shape is modelled even though
+ * the worker consumes only a subset (`match` + `scope`); the full allow-set
+ * must round-trip regardless.
  *
  * `~/.comis` is NOT represented here — it is an always-on, non-configurable
- * carve-out (§3.4), deliberately not an operator-dialable field.
+ * carve-out, deliberately not an operator-dialable field.
  */
 const TerminalAllowEntrySchema = z.strictObject({
     /** Stable entry id the agent passes to terminal_session_create as `allowId`. */
     id: z.string().min(1),
-    /** Canonical-binary match (§3.2): operator absolute path, optional argv-prefix + content hash pin. */
+    /** Canonical-binary match: operator absolute path, optional argv-prefix + content hash pin. */
     match: z.strictObject({
         path: z.string(),
         argsPrefix: z.array(z.string()).optional(),
         hash: z.string().optional(),
     }),
-    /** Least-privilege sandbox scope materialized per session (the full matrix lands later). */
+    /** Least-privilege sandbox scope materialized per session (not every scope dimension is materialized yet). */
     scope: z.strictObject({
         filesystem: z.enum(["workspace", "listed-paths", "home", "full"]).default("workspace"),
         paths: z.array(z.string()).optional(),
@@ -141,9 +141,9 @@ const TerminalAllowEntrySchema = z.strictObject({
         credentialPaths: z.array(z.string()).default([]),
         uid: z.enum(["dedicated", "daemon"]).default("dedicated"),
     }),
-    /** Auto-answer policy for safe interaction prompts (§4.5). */
+    /** Auto-answer policy for safe interaction prompts. */
     autoAnswer: z.enum(["none", "safe-only", "all"]).default("safe-only"),
-    /** Optional safe-pattern allowlist feeding the interaction classifier (§4.5). */
+    /** Optional safe-pattern allowlist feeding the interaction classifier. */
     hintPatterns: z.array(z.string()).optional(),
     /** Explicit operator risk acknowledgement — `acknowledgedRisk` must be literal true. */
     consent: z.strictObject({
@@ -152,13 +152,13 @@ const TerminalAllowEntrySchema = z.strictObject({
     }),
     /**
      * Per-entry resource caps (all optional). `wallClockMs` / `maxInteractions` are the
-     * ENDURANCE-DIALABLE caps (ENDURE-01): each is `.int().optional()`, so `undefined` ⇒
-     * NO cap (today's behavior, I1) and an operator dials it to a 40h+ horizon. They stay
+     * endurance-dialable caps: each is `.int().optional()`, so `undefined` ⇒
+     * NO cap and an operator dials it to a 40h+ horizon. They stay
      * cap-only knobs with NO `.default()` on purpose — adding a default would impose a cap
-     * where there is none today (I1). The high-default + reaper-exclusion + cap-named
-     * `failed` reason are the daemon's runtime concern (165-08's reaper wiring), not a
-     * schema default. A cap eviction names the cap that fired (I9 — never evicted for
-     * duration/quietness alone).
+     * where the contract is "absent means uncapped". The high-default + reaper-exclusion +
+     * cap-named `failed` reason are the daemon's runtime concern (the reaper wiring), not a
+     * schema default. A cap eviction names the cap that fired — a session is never evicted
+     * for duration/quietness alone.
      */
     limits: z
         .strictObject({
@@ -170,9 +170,9 @@ const TerminalAllowEntrySchema = z.strictObject({
         .optional(),
     /** Require operator approval at session_create for this entry. */
     approveOnCreate: z.boolean().optional(),
-    /** PTY backend; tmux is required for long-run mode (§4.6). */
+    /** PTY backend; tmux is required for long-run mode. */
     backend: z.enum(["spawn", "tmux"]).optional(),
-    /** Optional hardening tier (§3.9). */
+    /** Optional hardening tier. */
     hardening: z.enum(["none", "broker-decoy"]).default("none"),
     /** Broker-decoy binding (only meaningful when hardening = "broker-decoy"). */
     brokerDecoy: z
@@ -184,7 +184,7 @@ const TerminalAllowEntrySchema = z.strictObject({
         .optional(),
 });
 /**
- * Closed configuration schema for the interactive terminal driver (spec §6).
+ * Closed configuration schema for the interactive terminal driver.
  *
  * Operator-dialable, never agent-dialable. Closed by construction (every level
  * is `z.strictObject`) so unknown/typo'd keys are rejected at config load —
@@ -200,12 +200,12 @@ export const TerminalDriverConfigSchema = z.strictObject({
         maxConcurrentAttentionTurns: z.number().int(),
         /**
          * The operator-dialable cgroup `TasksMax` ceiling bounding the concurrent-session
-         * subprocess footprint vs. the systemd `TasksMax` (OPS-05; T-124-22). The tmux
-         * backend (124-08) makes a worker's named sessions outlive the worker, so N
+         * subprocess footprint vs. the systemd `TasksMax`. The tmux
+         * backend makes a worker's named sessions outlive the worker, so N
          * memory-hungry sessions share one cgroup; this bounds the fork footprint so an
          * unbounded fan-out cannot OOM/fork-starve the daemon. Absent ⇒ bounded by
          * `maxSessions` alone (no extra ceiling). Optional + positive — adding it keeps the
-         * `worker` block a `strictObject` (an unknown/typo'd worker key still rejects, OPS-02).
+         * `worker` block a `strictObject` (an unknown/typo'd worker key still rejects).
          */
         tasksMax: z.number().int().positive().optional(),
     }),
@@ -218,36 +218,36 @@ export const TerminalDriverConfigSchema = z.strictObject({
     redactSecrets: z.boolean(),
     audit: z.strictObject({ enabled: z.boolean() }),
     /**
-     * Autonomous-drive policy (v2.24, additive — design §4 "Config surface"). OPTIONAL +
-     * `strictObject`: a config with NO `drive` block is byte-identical to today (I1). Phase 164
-     * introduced `mode` (DRIVE-02) + `readMode` (READ-01); Phase 165 (165-05) adds the three
-     * endurance/durability fields `durable` (DUR-01) / `heartbeatMs` (LIVE-01) / `maxCostUsd`
-     * (ENDURE-01); Phase 166 (166-02) COMPLETES this SAME block with the two user-facing
-     * notification fields `notify` (NOTIFY-01) / `heartbeatNotifyMs` (NOTIFY-02, §7.1.4). The
-     * optional-block + per-field-`.default(...)` discipline lets each phase's additions stay
-     * independent (an unknown/typo'd `drive.*` key still rejects, OPS-02). The per-field defaults
-     * preserve today's effective behavior — `mode:"auto"` only promotes a genuinely-long drive;
-     * `readMode:"digest"` is already the tool's effective default; `durable:false` /
-     * `heartbeatMs:90_000` / `maxCostUsd:null` are inert. §7.1.5 LOCKED: `durable:true` is
+     * Autonomous-drive policy. OPTIONAL + `strictObject`: the block is purely
+     * additive — a config with NO `drive` block parses cleanly and yields the inert
+     * baseline behavior. The block carries
+     * the promotion mode (`mode`) + default wake-read shape (`readMode`), the three
+     * endurance/durability fields (`durable` / `heartbeatMs` / `maxCostUsd`), and the two
+     * user-facing notification fields (`notify` / `heartbeatNotifyMs`). The
+     * optional-block + per-field-`.default(...)` discipline keeps each field's addition
+     * independent (an unknown/typo'd `drive.*` key still rejects). The per-field defaults
+     * preserve the inert baseline — `mode:"auto"` only promotes a genuinely-long drive;
+     * `readMode:"digest"` is already the tool's effective default; `heartbeatMs:90_000` /
+     * `maxCostUsd:null` are inert. LOCKED: `durable:true` is
      * ACCEPTED at config-validation even on a tmux-less host (tmux availability is a RUNTIME
      * property — degrade + WARN, never a config-time hard-require). Changing/adding a default
      * regenerates the `section-registry-parity` snapshot (a validate-only gate).
      */
     drive: z
         .strictObject({
-        /** Auto-promote (default) / never (= today's inline behavior) / always-at-first-wait (DRIVE-02). */
+        /** Auto-promote (default) / never promote (the inline drive) / always promote at first wait. */
         mode: z.enum(["auto", "attached", "detached"]).default("auto"),
-        /** Default wake-read shape (READ-01): a bounded digest / only changed rows / the whole bounded screen. */
+        /** Default wake-read shape: a bounded digest / only changed rows / the whole bounded screen. */
         readMode: z.enum(["digest", "diff", "full"]).default("digest"),
         /**
-         * DUR-01 — make the drive DURABLE: launch the driven CLI inside a detached
+         * Make the drive DURABLE: launch the driven CLI inside a detached
          * tmux server (implying `backend:"tmux"` at runtime) so a worker/daemon exit
          * leaves it running, and re-attach (never restart, never double-drive) on
-         * daemon restart. DEFAULT `true` (2026-06-16): the tmux backend is now both
-         * DRIVEABLE (the node-pty `attach` rework — streams + accepts input) and
-         * SURVIVE-A-RESTART (the deployed unit ships `KillMode=process` + the data-dir
+         * daemon restart. DEFAULT `true`: the tmux backend is both
+         * DRIVEABLE (the node-pty `attach` path — streams + accepts input) and
+         * SURVIVES-A-RESTART (the deployed unit ships `KillMode=process` + the data-dir
          * tmux socket), so it is the default working setup; set `durable:false` to opt
-         * out to the non-durable pty drive. §7.1.5 LOCKED: `durable:true` is ACCEPTED
+         * out to the non-durable pty drive. LOCKED: `durable:true` is ACCEPTED
          * HERE even on a tmux-less host — tmux availability is a RUNTIME property; an
          * unavailable/failed re-attach degrades to a non-durable drive + a logged WARN
          * (and an honest `failed` on a subsequent restart), NOT a config-validation
@@ -257,42 +257,42 @@ export const TerminalDriverConfigSchema = z.strictObject({
          */
         durable: z.boolean().default(true),
         /**
-         * LIVE-01 — the INTERNAL coarse liveness-backstop interval (ms). A safety net
-         * UNDER the event-driven wake (I2): on a tick with NO intervening transition it
+         * The INTERNAL coarse liveness-backstop interval (ms). A safety net
+         * UNDER the event-driven wake: on a tick with NO intervening transition it
          * performs a SINGLE liveness check and synthesizes `stuck` only when genuinely
-         * hung — a legitimately-busy long compile/test is busy, NOT `stuck` (I9). NEVER
+         * hung — a legitimately-busy long compile/test is busy, NOT `stuck`. NEVER
          * a hot-path poll (no per-tick screen read). Default 90_000 (90s). This is the
-         * internal liveness tick, NOT the user-facing progress heartbeat (Phase 166).
+         * internal liveness tick, NOT the user-facing progress heartbeat
+         * (`heartbeatNotifyMs` below).
          */
         heartbeatMs: z.number().int().positive().default(90_000),
         /**
-         * ENDURE-01 — an optional per-drive SPEND CEILING (USD) over the whole run.
+         * An optional per-drive SPEND CEILING (USD) over the whole run.
          * On breach the drive escalates/stops — never silent overspend. `null` (default)
-         * = uncapped, preserving today's behavior (I1). Carries no privilege/path/
-         * credential (I5) — it bounds cost only.
+         * = uncapped. Carries no privilege/path/credential — it bounds cost only.
          */
         maxCostUsd: z.number().nullable().default(null),
         /**
-         * NOTIFY-01 — which terminal-outcome notifications reach the USER: `terminal`
+         * Which terminal-outcome notifications reach the USER: `terminal`
          * (default) = `done`/`needs-you`/`failed` only; `all` = RESERVED for a future
          * per-wake debug stream and **currently behaves exactly like `terminal`** (the
-         * per-wake notification is not yet implemented — WR-02); `none` = non-escalation
-         * suppressed. I4: an escalation STILL fires under `none` (a needs-you IS a terminal
-         * notification) — `notify` NEVER weakens SEC-12 escalate-always / SEC-11 loop-guard,
-         * it only gates the uninteresting middle. Default `terminal` preserves the
-         * conservative spam-free posture. Carries no privilege/path/credential (I5) — a
-         * policy knob only.
+         * per-wake notification is not yet implemented); `none` = non-escalation
+         * suppressed. An escalation STILL fires under `none` (a needs-you IS a terminal
+         * notification) — `notify` NEVER weakens the escalate-always guarantee or the
+         * interaction loop-guard, it only gates the uninteresting middle. Default
+         * `terminal` preserves the conservative spam-free posture. Carries no
+         * privilege/path/credential — a policy knob only.
          */
         notify: z.enum(["terminal", "all", "none"]).default("terminal"),
         /**
-         * NOTIFY-02 (§7.1.4) — the user-facing progress-heartbeat cadence (ms) for a
-         * PROMOTED long drive: a coarse, content-free one-liner from the journal (I3) so a
-         * 40h drive is not 40h of silence. `0` = terminal-only (no heartbeat; today's
-         * behavior). Default 3_600_000 (1h) — a spam-free coarse cadence. `.int().nonnegative()`
+         * The user-facing progress-heartbeat cadence (ms) for a
+         * PROMOTED long drive: a coarse, content-free one-liner from the journal so a
+         * 40h drive is not 40h of silence. `0` = terminal-only (no heartbeat).
+         * Default 3_600_000 (1h) — a spam-free coarse cadence. `.int().nonnegative()`
          * (NOT `.positive()`) BECAUSE `0` is the meaningful "terminal-only" value — this is
          * DISTINCT from `heartbeatMs` (the INTERNAL liveness backstop above, `.positive()`,
-         * NOT a user message). A short (unpromoted) drive emits none (I1). Carries no
-         * privilege/path/credential (I5) — a cadence knob only.
+         * NOT a user message). A short (unpromoted) drive emits none. Carries no
+         * privilege/path/credential — a cadence knob only.
          */
         heartbeatNotifyMs: z.number().int().nonnegative().default(3_600_000),
     })
@@ -320,13 +320,13 @@ export const SkillsConfigSchema = z.strictObject({
     /** Debounce interval in milliseconds for file change coalescing (default: 400). */
     watchDebounceMs: z.number().int().min(100).max(5000).default(400),
     /**
-     * Interactive terminal driver (v2.11) — the operator allowlist + worker caps + scope
-     * matrix (spec §6). OPTIONAL + fail-closed by construction: when absent (the default),
+     * Interactive terminal driver — the operator allowlist + worker caps + scope
+     * matrix. OPTIONAL + fail-closed by construction: when absent (the default),
      * the daemon wires an EMPTY allow-set (every `terminal_session_create` rejects before
-     * any spawn) and NO reaper. P5/Phase 124 threads this into the daemon's
+     * any spawn) and NO reaper. The daemon threads this into its
      * `TerminalWiringDeps` so the allow-set populates (per-session caps go live) and
      * `worker.{maxSessions,idleTtlMs,stuckMs}` feed the reaper. The whole shape is a closed
-     * `z.strictObject` (OPS-02): an unknown/typo'd terminal key rejects at config load.
+     * `z.strictObject`: an unknown/typo'd terminal key rejects at config load.
      */
     terminal: TerminalDriverConfigSchema.optional(),
 });

package/node_modules/@comis/core/dist/config/schema-streaming.d.ts

@@ -43,7 +43,7 @@ export declare const TableModeSchema: z.ZodDefault<z.ZodEnum<{
  * Reply mode for outbound messages in conversations.
  *
  * - `off`: Never set replyTo on outbound messages
- * - `first`: Set replyTo on the first chunk only (default, current behavior)
+ * - `first`: Set replyTo on the first chunk only (default)
  * - `all`: Set replyTo on all chunks
  */
 export declare const ReplyModeSchema: z.ZodDefault<z.ZodEnum<{

package/node_modules/@comis/core/dist/config/schema-streaming.js

@@ -38,7 +38,7 @@ export const TableModeSchema = z
  * Reply mode for outbound messages in conversations.
  *
  * - `off`: Never set replyTo on outbound messages
- * - `first`: Set replyTo on the first chunk only (default, current behavior)
+ * - `first`: Set replyTo on the first chunk only (default)
  * - `all`: Set replyTo on all chunks
  */
 export const ReplyModeSchema = z.enum(["off", "first", "all"]).default("first");

package/node_modules/@comis/core/dist/config/schema-verbosity.d.ts

@@ -1,6 +1,5 @@
 /**
  * Verbosity configuration schema for channel-aware response style hints.
- * Channel-aware response style hints.
  */
 import { z } from "zod";
 export declare const VerbosityLevelSchema: z.ZodEnum<{

package/node_modules/@comis/core/dist/config/schema-verbosity.js

@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 /**
  * Verbosity configuration schema for channel-aware response style hints.
- * Channel-aware response style hints.
  */
 import { z } from "zod";
 export const VerbosityLevelSchema = z.enum(["auto", "terse", "concise", "standard", "detailed"]);

package/node_modules/@comis/core/dist/config/schema.d.ts

@@ -427,6 +427,7 @@ export declare const AppConfigSchema: z.ZodObject<{
                 "orch:analyze": "orch:analyze";
                 "orch:write": "orch:write";
                 "orch:browse": "orch:browse";
+                "orch:mcp": "orch:mcp";
             }>>>;
             mode: z.ZodOptional<z.ZodEnum<{
                 default: "default";
@@ -472,6 +473,17 @@ export declare const AppConfigSchema: z.ZodObject<{
                 staleHeartbeatMs: z.ZodDefault<z.ZodNumber>;
                 keepAliveMs: z.ZodDefault<z.ZodNumber>;
                 recoveryBudgetMs: z.ZodDefault<z.ZodNumber>;
+                orchestrateResume: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strict>>;
+            mcp: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                allow: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+                    tools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                    classification: z.ZodOptional<z.ZodEnum<{
+                        safe: "safe";
+                        "permission-gated": "permission-gated";
+                    }>>;
+                }, z.core.$strict>>>;
             }, z.core.$strict>>;
             web: z.ZodOptional<z.ZodBoolean>;
             analyze: z.ZodOptional<z.ZodBoolean>;
@@ -487,6 +499,7 @@ export declare const AppConfigSchema: z.ZodObject<{
                 defaultTimezone: z.ZodDefault<z.ZodString>;
                 maxJobs: z.ZodDefault<z.ZodNumber>;
                 maxConsecutiveErrors: z.ZodDefault<z.ZodNumber>;
+                wakeGate: z.ZodOptional<z.ZodBoolean>;
             }, z.core.$strict>>;
             heartbeat: z.ZodOptional<z.ZodObject<{
                 enabled: z.ZodOptional<z.ZodBoolean>;
@@ -875,6 +888,7 @@ export declare const AppConfigSchema: z.ZodObject<{
                 minConfidence: z.ZodDefault<z.ZodNumber>;
                 promoteAtProofCount: z.ZodDefault<z.ZodNumber>;
                 maxDocsPerRun: z.ZodDefault<z.ZodNumber>;
+                maxProcedureDocsSurfaced: z.ZodDefault<z.ZodNumber>;
             }, z.core.$strict>>;
             forget: z.ZodDefault<z.ZodObject<{
                 maxDormantDays: z.ZodDefault<z.ZodNumber>;
@@ -1456,6 +1470,48 @@ export declare const AppConfigSchema: z.ZodObject<{
             }>>;
             pollingIntervalMs: z.ZodDefault<z.ZodNumber>;
         }, z.core.$strict>>;
+        msteams: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            authMode: z.ZodDefault<z.ZodEnum<{
+                secret: "secret";
+                certificate: "certificate";
+                managedIdentity: "managedIdentity";
+            }>>;
+            appId: z.ZodOptional<z.ZodString>;
+            appPassword: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                source: z.ZodEnum<{
+                    file: "file";
+                    exec: "exec";
+                    env: "env";
+                }>;
+                provider: z.ZodString;
+                id: z.ZodString;
+            }, z.core.$strict>]>>;
+            tenantId: z.ZodOptional<z.ZodString>;
+            certPath: z.ZodOptional<z.ZodString>;
+            managedIdentityClientId: z.ZodOptional<z.ZodString>;
+            allowFrom: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            allowMode: z.ZodDefault<z.ZodEnum<{
+                allowlist: "allowlist";
+                open: "open";
+            }>>;
+            mediaAuthAllowHosts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            cloud: z.ZodDefault<z.ZodEnum<{
+                public: "public";
+            }>>;
+            missedInboundThresholdMs: z.ZodDefault<z.ZodNumber>;
+            mediaProcessing: z.ZodOptional<z.ZodObject<{
+                transcribeAudio: z.ZodDefault<z.ZodBoolean>;
+                analyzeImages: z.ZodDefault<z.ZodBoolean>;
+                describeVideos: z.ZodDefault<z.ZodBoolean>;
+                extractDocuments: z.ZodDefault<z.ZodBoolean>;
+                understandLinks: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strict>>;
+            ackReaction: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                emoji: z.ZodDefault<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
         healthCheck: z.ZodDefault<z.ZodObject<{
             enabled: z.ZodDefault<z.ZodBoolean>;
             pollIntervalMs: z.ZodDefault<z.ZodNumber>;
@@ -1611,8 +1667,8 @@ export declare const AppConfigSchema: z.ZodObject<{
                 maxFiles: z.ZodDefault<z.ZodNumber>;
             }, z.core.$strict>>;
             redactSensitive: z.ZodDefault<z.ZodEnum<{
-                off: "off";
                 tools: "tools";
+                off: "off";
             }>>;
             redactPatterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
             redactMinLength: z.ZodDefault<z.ZodNumber>;
@@ -1641,6 +1697,7 @@ export declare const AppConfigSchema: z.ZodObject<{
             defaultTimezone: z.ZodDefault<z.ZodString>;
             maxJobs: z.ZodDefault<z.ZodNumber>;
             maxConsecutiveErrors: z.ZodDefault<z.ZodNumber>;
+            wakeGate: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strict>>;
         heartbeat: z.ZodDefault<z.ZodObject<{
             enabled: z.ZodDefault<z.ZodBoolean>;

package/node_modules/@comis/core/dist/config/schema.js

@@ -74,10 +74,11 @@ export const AppConfigSchema = z.strictObject({
     /** Observability persistence configuration */
     observability: ObservabilityConfigSchema.default(() => ObservabilityConfigSchema.parse({})),
     /**
-     * Orchestration authoring gates (Phase 174 / v2.27 P2). SHIPPED GATED-OFF:
+     * Orchestration authoring gates. SHIPPED GATED-OFF:
      * `orchestration.authoring.{intentAction,repairProducer,gbnfConstrain}` all
      * default false, so an absent section parses to the inert all-false gate and
-     * behavior is byte-identical to today (the load-bearing invariant).
+     * the feature is fully inert unless explicitly enabled (the load-bearing
+     * invariant).
      */
     orchestration: OrchestrationConfigSchema.default(() => OrchestrationConfigSchema.parse({})),
     /**

package/node_modules/@comis/core/dist/config/section-registry.d.ts

@@ -44,9 +44,9 @@ export interface ManagedSectionRedirect {
      * fields fit in < 20 lines of hint text. Verified against the tool's
      * TypeBox parameter schema as of this commit.
      *
-     * Bug B: production trace c7b91328 showed the agent burning
-     * ~30s × 4 LLM calls re-loading the agents_manage schema after an
-     * immutable-path rejection. Surfacing the fragment inline closes that
+     * Without the inline fragment, an agent hitting an immutable-path
+     * rejection has been observed burning ~30s × 4 LLM calls re-loading the
+     * agents_manage schema. Surfacing the fragment inline closes that
      * round-trip tax.
      */
     schemaFragment?: {
@@ -102,7 +102,7 @@ export interface SectionRegistryEntry {
  *   autoReplyEngine, sendPolicy, embedding, envelope, tooling, orchestration.
  * The 7 fieldMetadata-only entries (plugins → envelope) are inserted between
  * `diagnostics` and `tooling` so both filtered subsequences are stable.
- * `orchestration` (both views, gated-off Phase 174) is appended last after
+ * `orchestration` (both views, gated-off by default) is appended last after
  * `tooling`, so it extends both subsequences consistently with insertion order.
  */
 export declare const SECTION_REGISTRY: Readonly<Record<string, SectionRegistryEntry>>;

package/node_modules/@comis/core/dist/config/section-registry.js

@@ -62,11 +62,11 @@ import { ToolingConfigSchema } from "./schema-tooling.js";
  *   autoReplyEngine, sendPolicy, embedding, envelope, tooling, orchestration.
  * The 7 fieldMetadata-only entries (plugins → envelope) are inserted between
  * `diagnostics` and `tooling` so both filtered subsequences are stable.
- * `orchestration` (both views, gated-off Phase 174) is appended last after
+ * `orchestration` (both views, gated-off by default) is appended last after
  * `tooling`, so it extends both subsequences consistently with insertion order.
  */
 export const SECTION_REGISTRY = Object.freeze({
-    // The 11 common (both views) at the head — matches both legacy orders up to index 9, then diagnostics at index 10.
+    // The 11 common (both views) at the head — both filtered subsequences share indexes 0-9, then diagnostics at index 10.
     agents: {
         schema: PerAgentConfigSchema,
         schemaSerializable: true,
@@ -225,10 +225,10 @@ export const SECTION_REGISTRY = Object.freeze({
         fieldMetadataVisible: true,
     },
     envelope: { schema: EnvelopeConfigSchema, schemaSerializable: false, fieldMetadataVisible: true },
-    // Tooling is the last entry in BOTH legacy orderings — placed before
-    // orchestration so both filtered subsequences keep it adjacent to the tail.
+    // Tooling sits at the tail of BOTH filtered subsequences — placed before
+    // orchestration so each keeps it adjacent to the tail.
     tooling: { schema: ToolingConfigSchema, schemaSerializable: true, fieldMetadataVisible: true },
-    // Orchestration authoring gate (Phase 174 / v2.27 P2). Both views (like
+    // Orchestration authoring gate. Both views (like
     // tooling/approvals); plain boolean flags, so NO managedRedirect (it carries
     // no managed write surface). Appended last so it extends BOTH the
     // schemaSerializable and fieldMetadataVisible subsequences consistently.
@@ -244,8 +244,8 @@ export const SECTION_REGISTRY = Object.freeze({
  * then sorted longest-prefix-first.
  *
  * Order here is irrelevant; managed-sections.ts performs the longest-prefix
- * sort. We list them in the same order as the legacy managed-sections.ts
- * for git-blame friendliness.
+ * sort. The listing order is arbitrary and kept stable for git-blame
+ * friendliness.
  */
 const SUB_PATH_MANAGED_REDIRECTS_LITERAL = [
     {

package/node_modules/@comis/core/dist/context/context.d.ts

@@ -34,8 +34,8 @@ export type UserTrustLevel = z.infer<typeof UserTrustLevelSchema>;
  *
  * agentId is likewise optional (NOT known at channel ingress) — the executor
  * populates it at the per-turn entry. The in-session ctx_* tools read it
- * per-call from the LIVE context to scope LCD store reads by agent (R4 132-03;
- * the Phase-131 WR-02 cross-agent close) — never a wiring-time closure that
+ * per-call from the LIVE context to scope LCD store reads by
+ * agent — never a wiring-time closure that
  * could serve multiple agents the same scope.
  */
 export declare const RequestContextSchema: z.ZodObject<{

package/node_modules/@comis/core/dist/context/context.js

@@ -33,15 +33,15 @@ export const UserTrustLevelSchema = z.enum(["admin", "user", "guest"]);
  *
  * agentId is likewise optional (NOT known at channel ingress) — the executor
  * populates it at the per-turn entry. The in-session ctx_* tools read it
- * per-call from the LIVE context to scope LCD store reads by agent (R4 132-03;
- * the Phase-131 WR-02 cross-agent close) — never a wiring-time closure that
+ * per-call from the LIVE context to scope LCD store reads by
+ * agent — never a wiring-time closure that
  * could serve multiple agents the same scope.
  */
 export const RequestContextSchema = z.strictObject({
     tenantId: z.string().min(1).default("default"),
     userId: z.string().min(1).optional(),
     sessionKey: z.string().min(1).optional(),
-    /** Resolved agent id for the turn — populated at the executor entry (optional, not known at channel ingress, like sessionKey). Read per-call by the ctx_* tools to scope LCD reads by agent (R4 / WR-02). */
+    /** Resolved agent id for the turn — populated at the executor entry (optional, not known at channel ingress, like sessionKey). Read per-call by the ctx_* tools to scope LCD reads by agent. */
     agentId: z.string().min(1).optional(),
     traceId: z.guid(),
     startedAt: z.number().int().positive(),
@@ -54,7 +54,7 @@ export const RequestContextSchema = z.strictObject({
     deliveryOrigin: DeliveryOriginSchema.optional(),
     /** Resolved model string ("provider:modelId") set by parent executor for sub-agent inheritance via ALS. */
     resolvedModel: z.string().optional(),
-    /** Resolved reply language (DET-02 tag) set by parent executor for sub-agent inheritance via ALS. */
+    /** Resolved reply language tag set by parent executor for sub-agent inheritance via ALS. */
     resolvedLanguage: z.string().optional(),
 });
 /**

package/node_modules/@comis/core/dist/context-store/parts-codec.d.ts

@@ -1,5 +1,6 @@
 /**
- * Pure parts <-> pi-ai canonical Message round-trip (F2/F3).
+ * Pure parts <-> pi-ai canonical Message round-trip (lossless fidelity +
+ * reasoning exclusion).
  *
  * Lives in core — the only non-agent package that depends on pi-ai. No
  * embedded database, no wall-clock reads — pure + unit-testable. Provider-
@@ -11,7 +12,7 @@
  * the OpenAI Responses function-output blocks, etc.) here — pi-ai owns that
  * and is version-pinned.
  *
- * Fidelity model (F1/F2): every content block is emitted as one part whose
+ * Fidelity model: every content block is emitted as one part whose
  * `metadata.raw` is the verbatim canonical block; the message-level envelope
  * (every top-level field except `content`) rides verbatim on the FIRST part's
  * `metadata.messageEnvelope`. A top-level `ToolResultMessage` is its own
@@ -20,7 +21,7 @@
  * round-trip drops no field; the typed tool columns are the queryable
  * projection, not the source of truth.
  *
- * F3: a `thinking` block becomes a `reasoning` part marked
+ * Reasoning exclusion: a `thinking` block becomes a `reasoning` part marked
  * `topLevelReasoningOnly` and is NOT re-emitted as a visible content block on
  * reconstruction (excluded from visible content + summarizer input); its tokens
  * were already counted agent-side at write time (`estimateMessageTokens` counts
@@ -31,18 +32,18 @@
 import type { Message } from "@earendil-works/pi-ai";
 import type { LcdMessage, LcdMessagePart } from "../ports/context-store-types.js";
 /**
- * Decompose a canonical pi-ai `Message` into structured LCD parts (write path,
- * F1): one part per content block, plus a single `tool_result` part for a
+ * Decompose a canonical pi-ai `Message` into structured LCD parts (write
+ * path): one part per content block, plus a single `tool_result` part for a
  * top-level `ToolResultMessage`. Captures `metadata.raw` = the verbatim block
- * (or whole tool-result message), the F3 top-level reasoning marker, and the
+ * (or whole tool-result message), the top-level reasoning marker, and the
  * message-level envelope on the first part.
  */
 export declare function messageToParts(msg: Message): LcdMessagePart[];
 /**
  * Reconstruct a canonical pi-ai `Message` from a persisted `LcdMessage` (read
- * path, F2): rebuild blocks with STABLE ids (so tool_use<->tool_result pair),
+ * path): rebuild blocks with STABLE ids (so tool_use<->tool_result pair),
  * preferring `metadata.raw` for exactness, restore the message envelope from
  * the first part, and exclude `topLevelReasoningOnly` reasoning from the
- * reconstructed VISIBLE content (F3).
+ * reconstructed VISIBLE content.
  */
 export declare function partsToMessage(row: LcdMessage): Message;