comisai 1.0.44 → 1.0.46

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

@@ -211,10 +211,10 @@ export type SepConfig = z.infer<typeof SepConfigSchema>;
 /**
  * GoalAnchor configuration: tail-injects the current execution objective +
  * uncompleted steps into the system prompt. Gated on scaffoldLevel==="max"
- * (small + nano models only) in the prompt assembly layer (Plan 02).
+ * (small + nano models only) in the prompt assembly layer.
  *
  * Default enabled=false ensures frontier/mid receive no injection until
- * explicitly configured (behavior-neutral for all existing agents).
+ * explicitly configured.
  * Output is bounded by maxChars (default 500) to cap tail injection size.
  */
 export declare const GoalAnchorConfigSchema: z.ZodObject<{
@@ -223,14 +223,14 @@ export declare const GoalAnchorConfigSchema: z.ZodObject<{
 }, z.core.$strict>;
 export type GoalAnchorConfig = z.infer<typeof GoalAnchorConfigSchema>;
 /**
- * Pre-delivery verification critic configuration (R4, Phase 154).
+ * Pre-delivery verification critic configuration.
  *
  * The critic scores a completion-claiming response against the GoalAnchor
  * checklist and returns verified / not-verified / skipped. Gated on
  * scaffoldLevel==="max" (small + nano models only) when enabled.
  *
  * Default enabled=false ensures the critic does not fire until explicitly
- * configured by the operator. Behavior-neutral for all existing agents.
+ * configured by the operator.
  */
 export declare const VerificationConfigSchema: z.ZodObject<{
     enabled: z.ZodDefault<z.ZodBoolean>;
@@ -238,7 +238,7 @@ export declare const VerificationConfigSchema: z.ZodObject<{
 }, z.core.$strict>;
 export type VerificationConfig = z.infer<typeof VerificationConfigSchema>;
 /**
- * Honesty guardrail configuration (R4/S2, Phase 154).
+ * Honesty guardrail configuration.
  *
  * Bounds critic retry redirects and enforces an honest unmet-list when
  * the redirect budget is exhausted. Prevents the executor from looping

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

@@ -56,9 +56,9 @@ export const RagConfigSchema = z.strictObject({
     /** Minimum BASE relevance score (pre-boost) for memory injection.
      *  Boosts cannot resurrect a memory whose base score is below this threshold.
      *  Gates on ScoreBreakdown.base (the un-boosted cosine/RRF score), applied AFTER
-     *  scoreWithBreakdown() and BEFORE the trust-filter (T-153-poison mitigation).
-     *  Default=0 means no floor — all memories pass, preserving exact prior behavior.
-     *  S6: a weaker ModelProfile cannot lower this below the operator-set value. */
+     *  scoreWithBreakdown() and BEFORE the trust-filter (memory-poisoning mitigation).
+     *  Default=0 means no floor — all memories pass.
+     *  Frozen: a weaker ModelProfile cannot lower this below the operator-set value. */
     baseFloor: z.number().min(0).max(1).default(0).describe("Minimum BASE relevance score (pre-boost) for memory injection. " +
         "Boosts cannot resurrect a memory whose base score is below this threshold. " +
         "Frozen: a weaker ModelProfile cannot lower this below the operator-set value (S6)."),
@@ -96,13 +96,13 @@ export const RagConfigSchema = z.strictObject({
         /** Usefulness boost weight (the SINGLE canonical usefulness knob —
          *  the recall-utility feedback loop reads `rag.scoring.usefulnessAlpha`, NOT a knob on
          *  `rag.feedback`). Bounded small (same magnitude as trust/proof) so a proven-useful
-         *  memory is boosted but CANNOT overturn trust-first ordering — Pitfall 5. Neutral
+         *  memory is boosted but CANNOT overturn trust-first ordering. Neutral
          *  (factor 1.0) whenever the per-memory usefulness signal is absent. */
         usefulnessAlpha: z.number().min(0).max(1).default(0.1),
         /** FadeMem decay boost weight (the SINGLE canonical decay knob —
          *  the recall-side gate `rag.forget` carries only the on/off toggle, NOT a magnitude).
          *  Bounded small (same magnitude as trust/proof/usefulness) so a stale memory's decay
-         *  RANKS but CANNOT overturn trust-first ordering — Pitfall 2. The factor only ever
+         *  RANKS but CANNOT overturn trust-first ordering. The factor only ever
          *  demotes (∈ [0.5,1], wrapped by this alpha), and is neutral (factor 1.0) at
          *  event-age 0 (the neutral-in-time byte-identity point), regardless of the
          *  `rag.forget` toggle (which defaults ON), OR when forget is explicitly disabled. */
@@ -116,14 +116,13 @@ export const RagConfigSchema = z.strictObject({
         usefulnessAlpha: 0.1,
         forgetAlpha: 0.1,
     })),
-    /** Per-lane RRF weights for the FTS + vector fusion lanes. These REPLACE the
-     *  weights hybridSearch.ts hardcoded (computeRRF 1.0/1.5) — they now live at the agent's
+    /** Per-lane RRF weights for the FTS + vector fusion lanes, applied at the agent's
      *  fuse() seam so an operator can tune the fts-vs-vector balance. The DEFAULTS {fts:1.0,
      *  vector:1.5} are the PARITY GUARD: with defaults the recall ranking is byte-for-byte
-     *  identical to the prior hardcoded behaviour (the characterization test enforces it). Bounded `min(0)`
-     *  so a negative weight (which could invert RRF ordering) is rejected at parse;
-     *  the upper bound is left open like entityLane.weight (a large finite weight only
-     *  re-orders). NB: a `temporal` sub-lane is added under `lanes` — additive. */
+     *  identical to the hybrid-search computeRRF weights (the characterization test enforces
+     *  it). Bounded `min(0)` so a negative weight (which could invert RRF ordering) is
+     *  rejected at parse; the upper bound is left open like entityLane.weight (a large
+     *  finite weight only re-orders). The `temporal` sub-lane under `lanes` is additive. */
     lanes: z
         .strictObject({
         /** FTS (BM25) lane weight. Default 1.0 — the parity value (hybrid-search.ts:310). */
@@ -188,9 +187,9 @@ export const RagConfigSchema = z.strictObject({
         .strictObject({
         /** Opt-out posture: default-ON. */
         enabled: z.boolean().default(true),
-        /** How many top search hits seed the self-join (design §4.4 seedCount). */
+        /** How many top search hits seed the self-join. */
         seedCount: z.number().int().positive().default(5),
-        /** Max shared-entity neighbour rows the lane returns (design §4.4 perEntityCap default 200). */
+        /** Max shared-entity neighbour rows the lane returns (default 200). */
         perEntityCap: z.number().int().positive().default(200),
         /** RRF weight for the entity lane (parity with the other lanes). */
         weight: z.number().min(0).default(1.0),
@@ -228,7 +227,7 @@ export const RagConfigSchema = z.strictObject({
      *  `0.5 + 0.5·exp(−λ·Δt^β)`. $0 at recall — a pure closed-form decay over event age (no API
      *  budget). OFF ⇒ forgetFactor forced to EXACTLY 1.0 in score.ts. The neutral-importance
      *  byte-identity holds even when ON: at event-age 0 the factor is exactly 1.0, so a
-     *  legacy/neutral fresh row never silently shifts. The magnitude is the single canonical
+     *  neutral fresh row never silently shifts. The magnitude is the single canonical
      *  `rag.scoring.forgetAlpha` (NOT duplicated here — one knob, no drift). A `.strictObject` so
      *  a stray field (e.g. a smuggled `forgetAlpha`) is REJECTED at parse, structurally enforcing
      *  the single-knob invariant. */
@@ -245,7 +244,7 @@ export const RagConfigSchema = z.strictObject({
         .default(() => ({ enabled: false, maxPinnedInjection: 5 })),
     /** LLM-free query understanding. Opt-out posture: all
      *  default-ON. $0 at recall — each toggle is an additive DETERMINISTIC, LLM-FREE capability
-     *  over the existing recall path (NO LLM call on the recall hot path — binding constraint #1).
+     *  over the existing recall path (NO LLM call on the recall hot path — a binding constraint).
      *  `intentReweight` multiplies the existing lane weights by a pure intent classifier;
      *  `synonyms` expands the FTS query terms via a bounded static map; `temporalParse` parses NL
      *  time expressions into an occurred_at range filter. */
@@ -366,10 +365,10 @@ export const SepConfigSchema = z.strictObject({
 /**
  * GoalAnchor configuration: tail-injects the current execution objective +
  * uncompleted steps into the system prompt. Gated on scaffoldLevel==="max"
- * (small + nano models only) in the prompt assembly layer (Plan 02).
+ * (small + nano models only) in the prompt assembly layer.
  *
  * Default enabled=false ensures frontier/mid receive no injection until
- * explicitly configured (behavior-neutral for all existing agents).
+ * explicitly configured.
  * Output is bounded by maxChars (default 500) to cap tail injection size.
  */
 export const GoalAnchorConfigSchema = z.strictObject({
@@ -383,14 +382,14 @@ export const GoalAnchorConfigSchema = z.strictObject({
     maxChars: z.number().int().min(100).max(2000).default(500),
 });
 /**
- * Pre-delivery verification critic configuration (R4, Phase 154).
+ * Pre-delivery verification critic configuration.
  *
  * The critic scores a completion-claiming response against the GoalAnchor
  * checklist and returns verified / not-verified / skipped. Gated on
  * scaffoldLevel==="max" (small + nano models only) when enabled.
  *
  * Default enabled=false ensures the critic does not fire until explicitly
- * configured by the operator. Behavior-neutral for all existing agents.
+ * configured by the operator.
  */
 export const VerificationConfigSchema = z.strictObject({
     /** Enable pre-delivery verification critic. Default: false (opt-in; meaningful only for scaffoldLevel=max). */
@@ -403,7 +402,7 @@ export const VerificationConfigSchema = z.strictObject({
     minResponseChars: z.number().int().min(50).max(2000).default(200),
 });
 /**
- * Honesty guardrail configuration (R4/S2, Phase 154).
+ * Honesty guardrail configuration.
  *
  * Bounds critic retry redirects and enforces an honest unmet-list when
  * the redirect budget is exhausted. Prevents the executor from looping

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

@@ -248,7 +248,7 @@ export type AgentConfig = z.infer<typeof AgentConfigSchema>;
 export type RoutingBinding = z.infer<typeof RoutingBindingSchema>;
 export type RoutingConfig = z.infer<typeof RoutingConfigSchema>;
 /**
- * Per-agent activity-presentation config (Agent Transparency, §16.3).
+ * Per-agent activity-presentation config (Agent Transparency).
  *
  * Controls how much work-in-progress UI the agent renders. Distinct from the
  * top-level `verbosity` (response-style `VerbosityConfigSchema`) — they share
@@ -301,6 +301,7 @@ export declare const PerAgentCronConfigSchema: 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>;
 /** Per-agent heartbeat delivery target (which channel to send heartbeat notifications to). */
 export declare const HeartbeatTargetSchema: z.ZodObject<{
@@ -347,6 +348,7 @@ export declare const PerAgentSchedulerConfigSchema: 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>;
@@ -786,6 +788,7 @@ export declare const PerAgentConfigSchema: 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";
@@ -831,6 +834,17 @@ export declare const PerAgentConfigSchema: 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>;
@@ -846,6 +860,7 @@ export declare const PerAgentConfigSchema: 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>;
@@ -1234,6 +1249,7 @@ export declare const PerAgentConfigSchema: 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>;
@@ -1657,6 +1673,7 @@ export declare const AgentsMapSchema: z.ZodRecord<z.ZodString, 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";
@@ -1702,6 +1719,17 @@ export declare const AgentsMapSchema: z.ZodRecord<z.ZodString, 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>;
@@ -1717,6 +1745,7 @@ export declare const AgentsMapSchema: z.ZodRecord<z.ZodString, 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>;
@@ -2105,6 +2134,7 @@ export declare const AgentsMapSchema: z.ZodRecord<z.ZodString, 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>;

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

@@ -47,7 +47,7 @@ export const AgentConfigSchema = z.strictObject({
      * effectiveContextCap{Small,Nano} apply on ANY provider/model. Primary use:
      * forcing a small-window nano/small treatment on a large-window model
      * (e.g. gpt-5-nano = 400K) to stress the context-fit path provider-agnostically.
-     * Unset → today's heuristic (byte-identical, no regression). Takes precedence
+     * Unset → the provider-family heuristic applies unchanged. Takes precedence
      * over the provider-level providers.entries.<id>.capabilities.capabilityClass.
      * Enum mirrors provider-capabilities.ts (frontier/mid/small/nano).
      */
@@ -56,14 +56,13 @@ export const AgentConfigSchema = z.strictObject({
     maxSteps: z.number().int().positive().default(150),
     /** SDK thinking level override (off/minimal/low/medium/high/xhigh). Optional -- only overrides when set. */
     thinkingLevel: z.enum(["off", "minimal", "low", "medium", "high", "xhigh"]).optional(),
-    /** Phase 166 Fix 3: thinking-effort governor config.
+    /** Thinking-effort governor config.
      *  Controls whether the governor may down-shift thinkingLevel on tight windows. */
     thinking: z.strictObject({
         /** When true (default), the thinking-effort governor may lower thinkingLevel
          *  (high→medium→low) when remaining room < thinkingReserve + MIN_VISIBLE_OUTPUT.
          *  For frontier/mid models the governor is always a no-op (large windows).
-         *  Frontier/mid: irrelevant — governor never fires on large windows regardless.
-         *  Design ref: design/small-model-context-fidelity.md §4 Fix 3 item 4. */
+         *  Design ref: design/small-model-context-fidelity.md. */
         downshiftOnTightWindow: z.boolean().default(true),
     }).default({ downshiftOnTightWindow: true }),
     /** SDK max tokens override. Optional -- only overrides when set. */
@@ -93,12 +92,12 @@ export const AgentConfigSchema = z.strictObject({
      *  When false, use static retention from cacheRetention field.
      *  Default: true -- adaptive retention saves ~$4/MTok on cold-start Opus calls. */
     adaptiveCacheRetention: z.boolean().default(true),
-    /** Cache breakpoint strategy. Default 'auto' → 'multi-zone' for ALL providers (W11):
+    /** Cache breakpoint strategy. Default 'auto' → 'multi-zone' for ALL providers:
      *  multi-zone places breakpoints across system, tools, and messages so a long tool-using
      *  turn keeps each Anthropic 20-block lookback window covered. 'single' places ONE
      *  breakpoint and can cause lookback-window cache misses + O(N^2) cache_creation
-     *  re-writes on long tool turns (the 2026-06-18 regression: the default was 'single',
-     *  billing the whole tool suffix as a fresh write every iteration). */
+     *  re-writes on long tool turns (billing the whole tool suffix as a fresh write
+     *  every iteration). */
     cacheBreakpointStrategy: z.enum(["auto", "multi-zone", "single"]).default("auto"),
     /** Advanced cache optimization options for interactive sessions. */
     advancedCacheOptimization: z.object({
@@ -151,13 +150,13 @@ export const AgentConfigSchema = z.strictObject({
     promptTimeout: PromptTimeoutConfigSchema.default(() => PromptTimeoutConfigSchema.parse({})),
     /** Per-operation model override configuration (model tiering). */
     operationModels: OperationModelsSchema,
-    /** Reply language for deterministic degraded replies (DET-02). BCP-47 ("he")
+    /** Reply language for deterministic degraded replies. BCP-47 ("he")
      *  or an English display name ("Hebrew"). Omit to auto-detect from the
      *  USER.md preferred language, then the inbound message script (he/ar/ru only). */
     language: z.string().optional(),
 });
 /**
- * Per-agent activity-presentation config (Agent Transparency, §16.3).
+ * Per-agent activity-presentation config (Agent Transparency).
  *
  * Controls how much work-in-progress UI the agent renders. Distinct from the
  * top-level `verbosity` (response-style `VerbosityConfigSchema`) — they share
@@ -169,22 +168,22 @@ export const ActivityConfigSchema = z.strictObject({
     /** How much work-in-progress UI to render. */
     verbosity: z.enum(["silent", "quiet", "normal", "verbose"]).default("normal"),
     /** What to do with activity messages once the turn succeeds.
-     *  (onFailure is hardcoded to "keep"; not exposed — §7.3.) */
+     *  (onFailure is hardcoded to "keep"; not exposed.) */
     onSuccess: z.enum(["delete", "keep", "collapse"]).default("delete"),
     /** Visual theme for activity rendering. */
     theme: z.enum(["default", "terminal-minimal", "playful", "ascii"]).default("default"),
-    /** Agent-scoped emergency kill switch (§22.2). When true, no activity
+    /** Agent-scoped emergency kill switch. When true, no activity
      *  messages are produced for this agent on any channel; lifecycle reactions
      *  and final-message delivery are unaffected. Enforcement is handled elsewhere. */
     emergencyDisabled: z.boolean().default(false),
-    /** Renderer-scoped enable map (§22.2), keyed by TurnActivityContext.rendererKey.
+    /** Renderer-scoped enable map, keyed by TurnActivityContext.rendererKey.
      *  A missing entry follows `defaultChannelEnabled` (default true → enabled).
      *  An explicit `enabled` always wins: `true` renders, `false` opts that
      *  renderer out even under default-on (kill-switch safety). */
     channels: z
         .record(z.string(), z.strictObject({ enabled: z.boolean().default(false) }))
         .default({}),
-    /** Operator opt-out from DEFAULT-ON (§22.2): when true (the default), any
+    /** Operator opt-out from DEFAULT-ON: when true (the default), any
      *  renderer for this agent that has no explicit `channels[rendererKey]` entry
      *  renders, and the operator opts a specific renderer OUT via
      *  `channels[rendererKey].enabled: false`. Set it to `false` to restore the
@@ -194,7 +193,7 @@ export const ActivityConfigSchema = z.strictObject({
     defaultChannelEnabled: z.boolean().default(true),
 });
 /**
- * Per-agent delivery config (Agent Transparency, §16.3).
+ * Per-agent delivery config (Agent Transparency).
  *
  * `visibleReplies` decides what becomes a room-visible assistant reply. It is
  * intentionally separate from `activity` (presentation): "automatic" delivers
@@ -224,6 +223,15 @@ export const PerAgentCronConfigSchema = z.strictObject({
     maxJobs: z.number().int().nonnegative().default(100),
     /** Maximum consecutive errors before auto-suspending a cron job (0 = never suspend). Per-agent override. */
     maxConsecutiveErrors: z.number().int().nonnegative().default(5),
+    /**
+     * Per-agent override for the scheduler-initiated wake-gate toggle. Tri-state
+     * via `.optional()` (mirrors the global `scheduler.cron.wakeGate`): `true` →
+     * on; `false` → off (a gated job runs as it would with no gate); absent →
+     * follow the agent's `autonomy.script` surface. Because a per-agent cron
+     * override replaces the whole global cron block, this must exist here too, or
+     * setting any per-agent cron field would silently drop the operator's toggle.
+     */
+    wakeGate: z.boolean().optional(),
 });
 /** Per-agent heartbeat delivery target (which channel to send heartbeat notifications to). */
 export const HeartbeatTargetSchema = z.strictObject({
@@ -291,7 +299,7 @@ export const PerAgentSchedulerConfigSchema = z.strictObject({
 export const PerAgentConfigSchema = AgentConfigSchema.extend({
     /** Per-agent skills configuration (toolPolicy, builtinTools, discoveryPaths) */
     skills: SkillsConfigSchema.optional(),
-    /** Per-agent autonomy posture (v8 §3.8 named profiles). NOT .optional(): §6.4 — a missing block resolves to the `standard` default (zero-config + MIG-01). Resolve via `resolveAutonomy(...)`. */
+    /** Per-agent autonomy posture (named profiles). NOT .optional(): a missing block resolves to the `standard` default (zero-config). Resolve via `resolveAutonomy(...)`. */
     autonomy: AutonomyConfigSchema.default(() => AutonomyConfigSchema.parse({})),
     /** Per-agent scheduler configuration (cron settings) */
     scheduler: PerAgentSchedulerConfigSchema.optional(),
@@ -326,18 +334,18 @@ export const PerAgentConfigSchema = AgentConfigSchema.extend({
     sep: SepConfigSchema.optional(),
     /** GoalAnchor: tail-injects objective + uncompleted steps into system prompt (small/nano models only; enabled=false by default) */
     goalAnchor: GoalAnchorConfigSchema.optional(),
-    /** Pre-delivery verification critic (R4, Phase 154): scores completion claims against GoalAnchor checklist. Opt-in; enabled=false by default. */
+    /** Pre-delivery verification critic: scores completion claims against GoalAnchor checklist. Opt-in; enabled=false by default. */
     verification: VerificationConfigSchema.optional(),
-    /** Honesty guardrails (R4/S2, Phase 154): bounds critic retry redirects and enforces honest unmet-list on exhaustion. */
+    /** Honesty guardrails: bounds critic retry redirects and enforces honest unmet-list on exhaustion. */
     honesty: HonestyConfigSchema.optional(),
     /** Proactive notification configuration (rate limits, primary channel, dedup) */
     notification: NotificationConfigSchema.optional(),
     /** Channel-aware response-style verbosity hints (KEPT unchanged — distinct
      *  from `activity.verbosity`, which is the work-in-progress UI level). */
     verbosity: VerbosityConfigSchema.optional(),
-    /** Per-agent activity-presentation config (Agent Transparency, §16.3). */
+    /** Per-agent activity-presentation config (Agent Transparency). */
     activity: ActivityConfigSchema.default(() => ActivityConfigSchema.parse({})),
-    /** Per-agent delivery config: final-assistant-reply visibility (§16.3). */
+    /** Per-agent delivery config: final-assistant-reply visibility. */
     delivery: DeliveryConfigSchema.default(() => DeliveryConfigSchema.parse({})),
     /** Deferred tools configuration (deferral mode + force-load/force-defer lists) */
     deferredTools: DeferredToolsConfigSchema.optional(),
@@ -347,33 +355,20 @@ export const PerAgentConfigSchema = AgentConfigSchema.extend({
      *  default-ON. A COST feature — force-disabled at its registration site when the
      *  master kill switch `memory.enabled` is false. */
     memoryReview: MemoryReviewConfigSchema.default(() => MemoryReviewConfigSchema.parse({})),
-    // (The `socialModeling` key was DELETED in Phase 226 SIMPLIFY-03 — the entire
-    //  social-modeling subsystem (the __SOCIAL_MODELING__ cron + the RelationshipStore port +
-    //  adapter + the `relationship` table + the relationship-block prompt injection) is gone.
-    //  z.strictObject now rejects a config carrying it, the D-01a operator-update path. No alias, I1.)
     /** memory_ask grounded-Q&A tool config — the ONE allowed query-time LLM surface.
      *  Opt-out posture: default-ON; a COST feature gated by the kill switch at its registration site. */
     dialectic: DialecticConfigSchema.default(() => DialecticConfigSchema.parse({})),
-    // (The `memoryUsefulnessJudge` key was DELETED in Phase 226 SIMPLIFY-03 — the dormant
-    //  usefulness-judge cron is gone. z.strictObject now rejects a config carrying it, the
-    //  D-01a operator-update path. The FORGET-02 recordUsage reward write stays in setup-learning.ts.)
-    /** Outcome-signal (Verified Learning WS1) configuration. Opt-OUT posture:
+    /** Outcome-signal (Verified Learning) configuration. Opt-OUT posture:
      *  default-ON, so `.parse({})` produces an active block; the master cost switch
      *  (`memory.enabled`) force-disables it at the registration site. */
     learningOutcome: LearningOutcomeConfigSchema.default(() => LearningOutcomeConfigSchema.parse({})),
-    /** The collapsed per-agent LEARNING layer (Phase 226 / SIMPLIFY-01/05). ONE
-     *  `learning.enabled` master gate (folds the former learningSkills.enabled +
-     *  learningTuning.enabled + learningForgetting.enabled) under the top-level
+    /** The per-agent LEARNING layer. ONE
+     *  `learning.enabled` master gate under the top-level
      *  `memory.enabled` kill-switch + the reflect/forget cost-bound knobs. Opt-OUT posture:
      *  default-ON, so `.parse({})` yields an active block; force-disabled when
-     *  `memory.enabled: false`. The RANK-01 reward / FORGET-02 accrual / SURFACE-04 promote
-     *  writes STAY wired behind this one flag. (Replaces learningSkills/learningTuning/
-     *  learningForgetting — those keys are now rejected at parse, the D-01a operator-update path.) */
+     *  `memory.enabled: false`. The reward / accrual / promote
+     *  writes are ALL wired behind this one flag. */
     learning: LearningConfigSchema.default(() => LearningConfigSchema.parse({})),
-    // (The `memoryTripleExtraction` key was DELETED in Phase 226 SIMPLIFY-03 — the dormant no-op
-    //  extraction cron is gone (its `extract` returned []). z.strictObject now rejects a config
-    //  carrying it, the D-01a operator-update path. The TripleStorePort graphSpread recall lane
-    //  survives — only the extraction JOB went, not the read lane.)
     /** SCAFFOLD-DORMANT memory-lifecycle sweep cron. Opt-OUT posture: default-ON for consistency
      *  (a KEYLESS cron) — but it still evicts/demotes NOTHING until the deferred live eviction
      *  policy lands, so default-on is a forward-consistent no-op today. */

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

@@ -64,8 +64,8 @@ export const HostRuleSchema = z.strictObject({
     pathPrefix: z.string().min(1).optional(),
     pathPolicy: z.array(z.string()).optional(),
     inject: z.array(InjectionRuleSchema),
-    // staticHeaders and finalizer were missing, causing z.strictObject to
-    // reject valid operator YAML that includes these fields.
+    // staticHeaders and finalizer must be declared here: z.strictObject would
+    // otherwise reject valid operator YAML that includes these fields.
     staticHeaders: z.array(StaticHeaderSchema).optional(),
     finalizer: RequestFinalizerSchema.optional(),
 });

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

@@ -491,6 +491,57 @@ export declare const IrcChannelEntrySchema: z.ZodObject<{
         id: z.ZodString;
     }, z.core.$strict>]>>;
 }, z.core.$strict>;
+/**
+ * Microsoft Teams via the Bot Framework Connector.
+ *
+ * A dedicated entry rather than an extension of the base channel schema: Teams
+ * authenticates with an app registration (app ID + credential + tenant) instead
+ * of a single bot token. Inbound activities arrive as authenticated POSTs on the
+ * gateway's HTTP/TLS surface, so enabling this channel also requires the gateway
+ * to be enabled.
+ */
+export declare const MsTeamsChannelEntrySchema: 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>;
 /** Configuration for channel health monitoring and automatic restart. */
 export declare const ChannelHealthCheckSchema: z.ZodObject<{
     enabled: z.ZodDefault<z.ZodBoolean>;
@@ -1073,6 +1124,48 @@ export declare const ChannelConfigSchema: 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>;
@@ -1093,4 +1186,5 @@ export type IMessageChannelEntry = z.infer<typeof IMessageChannelEntrySchema>;
 export type LineChannelEntry = z.infer<typeof LineChannelEntrySchema>;
 export type EmailChannelEntry = z.infer<typeof EmailChannelEntrySchema>;
 export type IrcChannelEntry = z.infer<typeof IrcChannelEntrySchema>;
+export type MsTeamsChannelEntry = z.infer<typeof MsTeamsChannelEntrySchema>;
 export type ChannelConfig = z.infer<typeof ChannelConfigSchema>;

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

@@ -153,6 +153,54 @@ export const IrcChannelEntrySchema = ChannelEntrySchema.extend({
     /** NickServ password for nick identification (string or SecretRef) */
     nickservPassword: SecretRefOrStringSchema.optional(),
 });
+/**
+ * Microsoft Teams via the Bot Framework Connector.
+ *
+ * A dedicated entry rather than an extension of the base channel schema: Teams
+ * authenticates with an app registration (app ID + credential + tenant) instead
+ * of a single bot token. Inbound activities arrive as authenticated POSTs on the
+ * gateway's HTTP/TLS surface, so enabling this channel also requires the gateway
+ * to be enabled.
+ */
+export const MsTeamsChannelEntrySchema = z.strictObject({
+    /** Whether this channel is active */
+    enabled: z.boolean().default(false),
+    /** Credential mode for the bot app registration */
+    authMode: z.enum(["secret", "certificate", "managedIdentity"]).default("secret"),
+    /** Bot application (client) ID */
+    appId: z.string().optional(),
+    /** App password / client secret (string or SecretRef) */
+    appPassword: SecretRefOrStringSchema.optional(),
+    /** Directory (tenant) ID; single-tenant registration, required when enabled */
+    tenantId: z.string().optional(),
+    /** Client certificate path (certificate credential mode) */
+    certPath: z.string().optional(),
+    /** Managed-identity client ID (managed-identity credential mode) */
+    managedIdentityClientId: z.string().optional(),
+    /** Allowed sender IDs — aadObjectId or conversation.id (empty honors allowMode) */
+    allowFrom: z.array(z.string()).default([]),
+    /** Allowlist mode: "allowlist" (default, blocks all unless listed) or "open" */
+    allowMode: z.enum(["allowlist", "open"]).default("allowlist"),
+    /** Extra hosts permitted for inbound media fetches */
+    mediaAuthAllowHosts: z.array(z.string()).optional(),
+    /** Target cloud environment */
+    cloud: z.enum(["public"]).default("public"),
+    /**
+     * Silence window (ms) after which the daemon raises a missed-inbound alert
+     * for this webhook channel. Webhook adapters are exempt from the health
+     * monitor's stale-reap, so a dead ingress reports healthy indefinitely; a
+     * dedicated liveness timer compares the inbound-only last-received timestamp
+     * to this threshold and, on breach, emits a `channel:inbound_silent` event +
+     * a WARN that surface as a `comis fleet` health signal. The check interval is
+     * derived from this value, so it is floored at 1 minute — a smaller window
+     * would drive a CPU-pegging busy-loop poll. Default: 6 hours.
+     */
+    missedInboundThresholdMs: z.number().int().min(60_000).default(21_600_000),
+    /** Per-channel media processing overrides (defaults: all enabled) */
+    mediaProcessing: MediaProcessingSchema.optional(),
+    /** Ack reaction sent when the agent starts processing a message */
+    ackReaction: AckReactionConfigSchema.optional(),
+});
 // ---------------------------------------------------------------------------
 // Health check config
 // ---------------------------------------------------------------------------
@@ -192,6 +240,7 @@ export const ChannelConfigSchema = z.strictObject({
     line: LineChannelEntrySchema.default(() => LineChannelEntrySchema.parse({})),
     irc: IrcChannelEntrySchema.default(() => IrcChannelEntrySchema.parse({})),
     email: EmailChannelEntrySchema.default(() => EmailChannelEntrySchema.parse({})),
+    msteams: MsTeamsChannelEntrySchema.default(() => MsTeamsChannelEntrySchema.parse({})),
     /** Health monitoring configuration */
     healthCheck: ChannelHealthCheckSchema.default(() => ChannelHealthCheckSchema.parse({})),
 });