comisai 1.0.45 → 1.0.46

package/node_modules/@comis/core/dist/api-contracts/observability-billing.d.ts

@@ -2,7 +2,7 @@
  * The five `obs.billing.*` contracts (per-provider / per-agent / per-session /
  * total / 24h usage) + the billing-only `BillingSnapshot` response schema.
  * Extracted from `observability.ts` to keep that module under the file-size cap
- * (the incident-report.ts sibling-split precedent from Phase 153).
+ * (the same sibling-split pattern as incident-report.ts).
  *
  * Barrel-only: external consumers import these from `"@comis/core"`. The
  * `observability.ts` barrel re-exports every contract here (and the
@@ -45,7 +45,7 @@ export declare const ObsBillingByProviderContract: import("./types.js").ApiContr
  * tools?: ToolCost[] }`. The handler spreads `merged` (a BillingSnapshot) then
  * adds an optional `budgetUsed` field — modeled as a loose record because
  * `perExecution`/`perHour`/`perDay` carry a nested `{ used, limit? }` shape — and
- * the CR-01 optional `tools[]` per-tool even-split (HG-01 aggregateToolCostByAgent;
+ * the optional `tools[]` per-tool even-split (`aggregateToolCostByAgent`;
  * present-only when non-empty), modeled as a loose-record array (the per-tool
  * `{ tool, cost, tokens, calls }` rows — content-free names + numbers).
  */

package/node_modules/@comis/core/dist/api-contracts/observability-billing.js

@@ -3,7 +3,7 @@
  * The five `obs.billing.*` contracts (per-provider / per-agent / per-session /
  * total / 24h usage) + the billing-only `BillingSnapshot` response schema.
  * Extracted from `observability.ts` to keep that module under the file-size cap
- * (the incident-report.ts sibling-split precedent from Phase 153).
+ * (the same sibling-split pattern as incident-report.ts).
  *
  * Barrel-only: external consumers import these from `"@comis/core"`. The
  * `observability.ts` barrel re-exports every contract here (and the
@@ -89,7 +89,7 @@ export const ObsBillingByProviderContract = defineContract({
  * tools?: ToolCost[] }`. The handler spreads `merged` (a BillingSnapshot) then
  * adds an optional `budgetUsed` field — modeled as a loose record because
  * `perExecution`/`perHour`/`perDay` carry a nested `{ used, limit? }` shape — and
- * the CR-01 optional `tools[]` per-tool even-split (HG-01 aggregateToolCostByAgent;
+ * the optional `tools[]` per-tool even-split (`aggregateToolCostByAgent`;
  * present-only when non-empty), modeled as a loose-record array (the per-tool
  * `{ tool, cost, tokens, calls }` rows — content-free names + numbers).
  */

package/node_modules/@comis/core/dist/api-contracts/observability.d.ts

@@ -4,8 +4,8 @@
  * Groups and method names:
  *   Diagnostics (1): obs.diagnostics
  *   Billing (5):     obs.billing.{byProvider,byAgent,bySession,total,usage24h}
- *   Audit (1):       obs.audit.query  (read surface onto obs_audit_events — AUDIT-05,
- *                    Phase 176; contract + wire schema in `audit-query.ts`)
+ *   Audit (1):       obs.audit.query  (read surface onto obs_audit_events;
+ *                    contract + wire schema in `audit-query.ts`)
  *   Channels (3):    obs.channels.{all,stale,get}
  *   Delivery (2):    obs.delivery.{recent,stats}
  *   Context (2):     obs.context.{pipeline,dag}  (gateway-scope gate only)
@@ -13,10 +13,10 @@
  *   Reset (2):       obs.reset, obs.reset.table
  *   SystemPrompt (2):obs.systemPromptReport.{latest,list}
  *   Trace (3):       obs.trace.{export,search,tail}
- *   Explain (1):     obs.explain  (IncidentReport assembler — Phase 153;
+ *   Explain (1):     obs.explain  (IncidentReport assembler;
  *                    contract + wire schema in sibling `incident-report.ts`)
- *   Fleet (1):       obs.fleet.health  (cross-session FleetHealthReport — v2.15
- *                    Phase 161; contract + wire schema in `fleet-health-report.ts`)
+ *   Fleet (1):       obs.fleet.health  (cross-session FleetHealthReport;
+ *                    contract + wire schema in `fleet-health-report.ts`)
  *
  * Dispatch: the non-Trace methods are web-SPA only (packages/web/src/views/),
  * handled by packages/daemon/src/api/obs-handlers.ts; the Trace group is also
@@ -31,8 +31,8 @@
  * @module
  */
 import { z } from "zod";
-export { ObsExplainContract, IncidentReportSchema, IncidentContextBudgetSchema, IncidentPromptTimeoutSchema } from "./incident-report.js";
-export type { IncidentReport, IncidentFailure, IncidentSignals, IncidentContextBudget, IncidentContextBudgetHistoryEntry, IncidentPromptTimeout } from "./incident-report.js";
+export { ObsExplainContract, IncidentReportSchema, IncidentContextBudgetSchema, IncidentCronWakeGateSchema, IncidentPromptTimeoutSchema } from "./incident-report.js";
+export type { IncidentReport, IncidentFailure, IncidentSignals, IncidentContextBudget, IncidentContextBudgetHistoryEntry, IncidentCronWakeGate, IncidentPromptTimeout } from "./incident-report.js";
 export { ObsFleetHealthContract, FleetHealthReportSchema } from "./fleet-health-report.js";
 export type { FleetHealthReport } from "./fleet-health-report.js";
 export { ObsAuditQueryContract } from "./audit-query.js";
@@ -233,8 +233,8 @@ export declare const ObsCacheStatsWindowContract: import("./types.js").ApiContra
 }, z.core.$strip>, z.ZodObject<{
     window: z.ZodRecord<z.ZodString, z.ZodUnknown>;
 }, z.core.$strip>>;
-/** `obs.cacheBreaks.byReason` — cache-break rate by reason + the $-lost SUM
- *  (WEBUI-02, 179-04). Admin-only. The rows are `{reason, count, estCostUsd}[]`
+/** `obs.cacheBreaks.byReason` — cache-break rate by reason + the $-lost SUM.
+ *  Admin-only. The rows are `{reason, count, estCostUsd}[]`
  *  GROUP BY'd server-side over the existing `category:'cache_break'` diagnostics
  *  index — content-free (a closed reason label + two numbers). The Cache Health
  *  view consumes it. Rides the loose ObsRecordArray (bundle-size budget). */
@@ -245,7 +245,7 @@ export declare const ObsCacheBreaksByReasonContract: import("./types.js").ApiCon
     rows: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>>;
 /** `obs.spend.snapshot` — the LIVE per-agent/tenant/global spend the kill-switch
- *  sees (WEBUI-02, 179-04; locked A1 — the live accumulator, NOT the lagging SQL).
+ *  sees (served from the live accumulator, NOT the lagging SQL).
  *  Admin-only. The snapshot carries the per-scope spend + the configured ceilings →
  *  headroom + a three-state pricing-coverage count. Content-free (dollar counts +
  *  scope enums + pricing-state counts). The Spend & Governance view consumes it.
@@ -414,7 +414,7 @@ export declare const ObsTraceSearchContract: import("./types.js").ApiContract<z.
 }, z.core.$strip>>;
 /**
  * Poll for live trace events on a chat. `chatId` required (min 1).
- * `limit` max 100. True WebSocket streaming deferred to v2.
+ * `limit` max 100. Polling only — there is no WebSocket streaming.
  */
 export declare const ObsTraceTailContract: import("./types.js").ApiContract<z.ZodObject<{
     chatId: z.ZodString;
@@ -629,6 +629,40 @@ export declare const OBSERVABILITY_CONTRACTS: readonly [import("./types.js").Api
         denials: z.ZodArray<z.ZodString>;
         budgetTokensUsed: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>>;
+    orchestrate: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        runId: z.ZodString;
+        leaseId: z.ZodOptional<z.ZodString>;
+        outcome: z.ZodEnum<{
+            success: "success";
+            failure: "failure";
+        }>;
+        durationMs: z.ZodNumber;
+        exitCode: z.ZodNumber;
+        failureClass: z.ZodOptional<z.ZodEnum<{
+            timeout: "timeout";
+            stdout_cap: "stdout_cap";
+            nonzero_exit: "nonzero_exit";
+            spawn_fail: "spawn_fail";
+            lease_absent: "lease_absent";
+        }>>;
+        toolCalls: z.ZodArray<z.ZodObject<{
+            tool: z.ZodString;
+            capability: z.ZodString;
+            decision: z.ZodEnum<{
+                allow: "allow";
+                deny: "deny";
+            }>;
+            count: z.ZodNumber;
+        }, z.core.$strip>>;
+        resultRefs: z.ZodObject<{
+            count: z.ZodNumber;
+            bytes: z.ZodNumber;
+        }, z.core.$strip>;
+        savings: z.ZodOptional<z.ZodObject<{
+            estSavedTokens: z.ZodNumber;
+            savedRatio: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
     contextBudget: z.ZodOptional<z.ZodObject<{
         windowTokens: z.ZodNumber;
         rawContextWindowTokens: z.ZodNumber;
@@ -651,6 +685,13 @@ export declare const OBSERVABILITY_CONTRACTS: readonly [import("./types.js").Api
             exhausted: "exhausted";
         }>;
     }, z.core.$strip>>;
+    cronWakeGate: z.ZodOptional<z.ZodObject<{
+        jobId: z.ZodString;
+        wake: z.ZodBoolean;
+        durationMs: z.ZodNumber;
+        toolCalls: z.ZodNumber;
+        estTurnsSaved: z.ZodNumber;
+    }, z.core.$strip>>;
     contextBudgetHistory: z.ZodOptional<z.ZodArray<z.ZodObject<{
         windowTokens: z.ZodNumber;
         assembledInputTokens: z.ZodNumber;
@@ -777,6 +818,22 @@ export declare const OBSERVABILITY_CONTRACTS: readonly [import("./types.js").Api
         cap: z.ZodNumber;
         unit: z.ZodString;
     }, z.core.$strip>>;
+    activityFinalize: z.ZodOptional<z.ZodObject<{
+        strategy: z.ZodString;
+        outcome: z.ZodString;
+        errorKind: z.ZodOptional<z.ZodString>;
+        reason: z.ZodOptional<z.ZodString>;
+        reclassified: z.ZodBoolean;
+    }, z.core.$strip>>;
+    recoveries: z.ZodOptional<z.ZodObject<{
+        total: z.ZodNumber;
+        succeeded: z.ZodNumber;
+        byReason: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    }, z.core.$strip>>;
+    deliverySkipped: z.ZodOptional<z.ZodObject<{
+        events: z.ZodNumber;
+        chunksNotSent: z.ZodNumber;
+    }, z.core.$strip>>;
     turnCount: z.ZodOptional<z.ZodNumber>;
     summary: z.ZodString;
     likelyRootCause: z.ZodNullable<z.ZodObject<{
@@ -899,6 +956,27 @@ export declare const OBSERVABILITY_CONTRACTS: readonly [import("./types.js").Api
         costUsd: z.ZodNumber;
         worstRootRunId: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
+    cronWakeGate: z.ZodOptional<z.ZodObject<{
+        fires: z.ZodObject<{
+            total: z.ZodNumber;
+            skipped: z.ZodNumber;
+            skipRate: z.ZodNumber;
+            failedOpen: z.ZodNumber;
+            failOpenRate: z.ZodNumber;
+        }, z.core.$strip>;
+        turnsSaved: z.ZodNumber;
+        toolCalls: z.ZodNumber;
+        perAgent: z.ZodArray<z.ZodObject<{
+            agentId: z.ZodString;
+            fires: z.ZodNumber;
+            skipped: z.ZodNumber;
+            skipRate: z.ZodNumber;
+            failedOpen: z.ZodNumber;
+            failOpenRate: z.ZodNumber;
+            turnsSaved: z.ZodNumber;
+            toolCalls: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>>, import("./types.js").ApiContract<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
     cacheHitRate: z.ZodNumber;
     cacheEffectiveness: z.ZodNumber;

package/node_modules/@comis/core/dist/api-contracts/observability.js

@@ -5,8 +5,8 @@
  * Groups and method names:
  *   Diagnostics (1): obs.diagnostics
  *   Billing (5):     obs.billing.{byProvider,byAgent,bySession,total,usage24h}
- *   Audit (1):       obs.audit.query  (read surface onto obs_audit_events — AUDIT-05,
- *                    Phase 176; contract + wire schema in `audit-query.ts`)
+ *   Audit (1):       obs.audit.query  (read surface onto obs_audit_events;
+ *                    contract + wire schema in `audit-query.ts`)
  *   Channels (3):    obs.channels.{all,stale,get}
  *   Delivery (2):    obs.delivery.{recent,stats}
  *   Context (2):     obs.context.{pipeline,dag}  (gateway-scope gate only)
@@ -14,10 +14,10 @@
  *   Reset (2):       obs.reset, obs.reset.table
  *   SystemPrompt (2):obs.systemPromptReport.{latest,list}
  *   Trace (3):       obs.trace.{export,search,tail}
- *   Explain (1):     obs.explain  (IncidentReport assembler — Phase 153;
+ *   Explain (1):     obs.explain  (IncidentReport assembler;
  *                    contract + wire schema in sibling `incident-report.ts`)
- *   Fleet (1):       obs.fleet.health  (cross-session FleetHealthReport — v2.15
- *                    Phase 161; contract + wire schema in `fleet-health-report.ts`)
+ *   Fleet (1):       obs.fleet.health  (cross-session FleetHealthReport;
+ *                    contract + wire schema in `fleet-health-report.ts`)
  *
  * Dispatch: the non-Trace methods are web-SPA only (packages/web/src/views/),
  * handled by packages/daemon/src/api/obs-handlers.ts; the Trace group is also
@@ -38,16 +38,16 @@ import { defineContract } from "./types.js";
 // for the OBSERVABILITY_CONTRACTS array below; re-export so the `@comis/core`
 // public surface + registered RPC set are unchanged.
 import { ObsExplainContract } from "./incident-report.js";
-export { ObsExplainContract, IncidentReportSchema, IncidentContextBudgetSchema, IncidentPromptTimeoutSchema } from "./incident-report.js";
-// The `obs.fleet.health` contract + wire schema (v2.15 R2, Phase 161) live in the
+export { ObsExplainContract, IncidentReportSchema, IncidentContextBudgetSchema, IncidentCronWakeGateSchema, IncidentPromptTimeoutSchema } from "./incident-report.js";
+// The `obs.fleet.health` contract + wire schema live in the
 // sibling `fleet-health-report.ts` (file-size split, mirroring incident-report.ts
 // which holds BOTH IncidentReportSchema + ObsExplainContract). Import the contract
 // for the OBSERVABILITY_CONTRACTS array below; re-export the contract + schema so
 // the `@comis/core` public surface + the registered RPC set carry them.
 import { ObsFleetHealthContract } from "./fleet-health-report.js";
 export { ObsFleetHealthContract, FleetHealthReportSchema } from "./fleet-health-report.js";
-// The `obs.audit.query` contract + wire schema (AUDIT-05, Phase 176 Plan 05) live
-// in the sibling `audit-query.ts` (the read surface onto the now-durable
+// The `obs.audit.query` contract + wire schema live
+// in the sibling `audit-query.ts` (the read surface onto the durable
 // obs_audit_events table). Import for the OBSERVABILITY_CONTRACTS array below;
 // re-export the contract + schema so the `@comis/core` public surface + the
 // registered RPC set carry them (the ObsFleetHealthContract precedent).
@@ -128,10 +128,10 @@ export const ObsDiagnosticsContract = defineContract({
         events: ObsRecordArray,
         counts: ObsRecord,
     }),
-    // OBS-SELF-DEAD (30uc-20260624 UC-14): rpc, NOT admin — same as obs.explain. obs_query's
+    // rpc, NOT admin — same as obs.explain. obs_query's
     // self-observability path reads diagnostics for the agent's own sessions; read-only +
-    // scrubbed digests, single-tenant daemon. ["admin"] put it in the deny-by-origin set and
-    // killed the agent's self-diagnose. MD-02 re-scope class.
+    // scrubbed digests, single-tenant daemon. ["admin"] would put it in the deny-by-origin
+    // set and kill the agent's self-diagnose.
     scopes: ["rpc"],
 });
 // ---------------------------------------------------------------------------
@@ -379,8 +379,8 @@ export const ObsCacheStatsWindowContract = defineContract({
     response: z.object({ window: ObsRecord }),
     scopes: ["admin"],
 });
-/** `obs.cacheBreaks.byReason` — cache-break rate by reason + the $-lost SUM
- *  (WEBUI-02, 179-04). Admin-only. The rows are `{reason, count, estCostUsd}[]`
+/** `obs.cacheBreaks.byReason` — cache-break rate by reason + the $-lost SUM.
+ *  Admin-only. The rows are `{reason, count, estCostUsd}[]`
  *  GROUP BY'd server-side over the existing `category:'cache_break'` diagnostics
  *  index — content-free (a closed reason label + two numbers). The Cache Health
  *  view consumes it. Rides the loose ObsRecordArray (bundle-size budget). */
@@ -394,7 +394,7 @@ export const ObsCacheBreaksByReasonContract = defineContract({
     scopes: ["admin"],
 });
 /** `obs.spend.snapshot` — the LIVE per-agent/tenant/global spend the kill-switch
- *  sees (WEBUI-02, 179-04; locked A1 — the live accumulator, NOT the lagging SQL).
+ *  sees (served from the live accumulator, NOT the lagging SQL).
  *  Admin-only. The snapshot carries the per-scope spend + the configured ceilings →
  *  headroom + a three-state pricing-coverage count. Content-free (dollar counts +
  *  scope enums + pricing-state counts). The Spend & Governance view consumes it.
@@ -605,7 +605,7 @@ export const ObsTraceSearchContract = defineContract({
         since: z.string().optional(),
         where: z.string().optional(),
         limit: z.number().int().positive().max(1000).optional(),
-        // D9: admin opt-in to include synthetic/test sessions (excluded by default).
+        // Admin opt-in to include synthetic/test sessions (excluded by default).
         includeSynthetic: z.boolean().optional(),
     }),
     response: z.object({
@@ -615,7 +615,7 @@ export const ObsTraceSearchContract = defineContract({
 });
 /**
  * Poll for live trace events on a chat. `chatId` required (min 1).
- * `limit` max 100. True WebSocket streaming deferred to v2.
+ * `limit` max 100. Polling only — there is no WebSocket streaming.
  */
 export const ObsTraceTailContract = defineContract({
     method: "obs.trace.tail",

package/node_modules/@comis/core/dist/api-contracts/orchestrator/autonomy-handlers.d.ts

@@ -1,5 +1,5 @@
 /**
- * Autonomy-handlers contract slice (213-03 — REVOKE-01/03).
+ * Autonomy-handlers contract slice.
  *
  * The two operator-facing live-control RPC methods of the bounded-autonomy
  * control plane:
@@ -13,11 +13,11 @@
  * is DERIVED from `scopes:["admin"]` contracts (rpc-dispatch.ts), so each method
  * lands in `ADMIN_METHODS` and the dispatch chokepoint's `assertNotAgentOrigin`
  * denies any agent-origin (`_agentId`-bearing) call automatically — the
- * deny-by-origin guarantee (REVOKE-01 "external to + non-bypassable by the
- * agent"), with NO manual `_agentId` check anywhere (a manual check would
+ * deny-by-origin guarantee (revocation is external to and non-bypassable by
+ * the agent), with NO manual `_agentId` check anywhere (a manual check would
  * drift). Mirrors `subagent-handlers.ts` (the admin-RPC contract template); the
- * daemon handlers driving the LeaseManager revoke fan-outs + the runner's
- * `killByRootRun` land in Plan 06.
+ * daemon handlers (daemon autonomy-handlers.ts) drive the LeaseManager revoke
+ * fan-outs + the runner's `killByRootRun`.
  *
  * Spread order in `AUTONOMY_HANDLERS_CONTRACTS` matches the orchestrator
  * contracts array byte for byte to keep `contracts.generated.*` artifacts
@@ -29,7 +29,7 @@
 import { z } from "zod";
 /**
  * `lease.revoke` — Revoke a capability lease (cooperative stop). Admin-scoped
- * → deny-by-origin. Handler path: autonomy-handlers.ts (Plan 06).
+ * → deny-by-origin. Handler path: autonomy-handlers.ts (daemon).
  *
  * Request: `{ leaseId?, rootRunId? }` — one-of. `leaseId` revokes a single
  *   lease; `rootRunId` revokes every lease of that spawn tree (the handler
@@ -45,7 +45,7 @@ export declare const LeaseRevokeContract: import("../types.js").ApiContract<z.Zo
 }, z.core.$strip>>;
 /**
  * `run.kill` — Kill a whole spawn tree (hard stop). Admin-scoped →
- * deny-by-origin. Handler path: autonomy-handlers.ts (Plan 06). Drives the
+ * deny-by-origin. Handler path: autonomy-handlers.ts (daemon). Drives the
  * runner's `killByRootRun` (abort every SDK session of the tree) AND
  * `leaseManager.revokeByRootRun` (revoke its leases).
  *
@@ -58,16 +58,16 @@ export declare const RunKillContract: import("../types.js").ApiContract<z.ZodObj
     killed: z.ZodNumber;
 }, z.core.$strip>>;
 /**
- * `autonomy.evict` — DEMOTE an in-flight run to `default` (Phase 217-04,
- * EVICT-01). Admin-scoped → deny-by-origin (an agent cannot self-un-evict).
- * Handler path: autonomy-handlers.ts (daemon, Phase 217-04).
+ * `autonomy.evict` — DEMOTE an in-flight run to `default`.
+ * Admin-scoped → deny-by-origin (an agent cannot self-un-evict).
+ * Handler path: autonomy-handlers.ts (daemon).
  *
  * SEMANTICALLY DISTINCT from `lease.revoke` (cooperative stop) and `run.kill`
  * (hard stop): evict does NOT abort — the run CONTINUES under the `default`
  * profile (which still escalates outward, never auto-sends). The handler marks
  * the `rootRunId` in a daemon-wide evicted-set; the bounded-autonomy chokepoint
- * consults it at the NEXT gate decision (EVICT-03 — mid-run, NOT at mint/next-
- * spawn), so the demotion bites a runaway in flight.
+ * consults it at the NEXT gate decision (mid-run, NOT at mint/next-spawn),
+ * so the demotion bites a runaway in flight.
  *
  * Request: `{ rootRunId }` — the root run to demote.
  * Response: `{ evicted }` — true if the run is now demoted (whether THIS call

package/node_modules/@comis/core/dist/api-contracts/orchestrator/autonomy-handlers.js

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 /**
- * Autonomy-handlers contract slice (213-03 — REVOKE-01/03).
+ * Autonomy-handlers contract slice.
  *
  * The two operator-facing live-control RPC methods of the bounded-autonomy
  * control plane:
@@ -14,11 +14,11 @@
  * is DERIVED from `scopes:["admin"]` contracts (rpc-dispatch.ts), so each method
  * lands in `ADMIN_METHODS` and the dispatch chokepoint's `assertNotAgentOrigin`
  * denies any agent-origin (`_agentId`-bearing) call automatically — the
- * deny-by-origin guarantee (REVOKE-01 "external to + non-bypassable by the
- * agent"), with NO manual `_agentId` check anywhere (a manual check would
+ * deny-by-origin guarantee (revocation is external to and non-bypassable by
+ * the agent), with NO manual `_agentId` check anywhere (a manual check would
  * drift). Mirrors `subagent-handlers.ts` (the admin-RPC contract template); the
- * daemon handlers driving the LeaseManager revoke fan-outs + the runner's
- * `killByRootRun` land in Plan 06.
+ * daemon handlers (daemon autonomy-handlers.ts) drive the LeaseManager revoke
+ * fan-outs + the runner's `killByRootRun`.
  *
  * Spread order in `AUTONOMY_HANDLERS_CONTRACTS` matches the orchestrator
  * contracts array byte for byte to keep `contracts.generated.*` artifacts
@@ -37,7 +37,7 @@ import { defineContract } from "../types.js";
 // ---------------------------------------------------------------------------
 /**
  * `lease.revoke` — Revoke a capability lease (cooperative stop). Admin-scoped
- * → deny-by-origin. Handler path: autonomy-handlers.ts (Plan 06).
+ * → deny-by-origin. Handler path: autonomy-handlers.ts (daemon).
  *
  * Request: `{ leaseId?, rootRunId? }` — one-of. `leaseId` revokes a single
  *   lease; `rootRunId` revokes every lease of that spawn tree (the handler
@@ -61,7 +61,7 @@ export const LeaseRevokeContract = defineContract({
 // ---------------------------------------------------------------------------
 /**
  * `run.kill` — Kill a whole spawn tree (hard stop). Admin-scoped →
- * deny-by-origin. Handler path: autonomy-handlers.ts (Plan 06). Drives the
+ * deny-by-origin. Handler path: autonomy-handlers.ts (daemon). Drives the
  * runner's `killByRootRun` (abort every SDK session of the tree) AND
  * `leaseManager.revokeByRootRun` (revoke its leases).
  *
@@ -82,16 +82,16 @@ export const RunKillContract = defineContract({
 // autonomy.evict
 // ---------------------------------------------------------------------------
 /**
- * `autonomy.evict` — DEMOTE an in-flight run to `default` (Phase 217-04,
- * EVICT-01). Admin-scoped → deny-by-origin (an agent cannot self-un-evict).
- * Handler path: autonomy-handlers.ts (daemon, Phase 217-04).
+ * `autonomy.evict` — DEMOTE an in-flight run to `default`.
+ * Admin-scoped → deny-by-origin (an agent cannot self-un-evict).
+ * Handler path: autonomy-handlers.ts (daemon).
  *
  * SEMANTICALLY DISTINCT from `lease.revoke` (cooperative stop) and `run.kill`
  * (hard stop): evict does NOT abort — the run CONTINUES under the `default`
  * profile (which still escalates outward, never auto-sends). The handler marks
  * the `rootRunId` in a daemon-wide evicted-set; the bounded-autonomy chokepoint
- * consults it at the NEXT gate decision (EVICT-03 — mid-run, NOT at mint/next-
- * spawn), so the demotion bites a runaway in flight.
+ * consults it at the NEXT gate decision (mid-run, NOT at mint/next-spawn),
+ * so the demotion bites a runaway in flight.
  *
  * Request: `{ rootRunId }` — the root run to demote.
  * Response: `{ evicted }` — true if the run is now demoted (whether THIS call

package/node_modules/@comis/core/dist/api-contracts/orchestrator/cron-handlers.d.ts

@@ -14,8 +14,8 @@ import { z } from "zod";
  *
  * The contract describes the WEB on-wire shape (nested `schedule.{kind,expr,
  * tz,everyMs,at}` + `message`); the handler body accepts BOTH the web shape
- * (nested) AND the legacy chat-tool shape (flat `schedule_kind` /
- * `schedule_every_ms` / etc.) to preserve existing handler-test invocations.
+ * (nested) AND the chat-tool shape (flat `schedule_kind` /
+ * `schedule_every_ms` / etc.) — the chat-tool path sends the flat fields.
  *
  * Bespoke pre-Zod validation: duplicate job-name guard reads name on
  * rawParams.name BEFORE the schedule normalization (preserves the
@@ -24,7 +24,7 @@ import { z } from "zod";
  * Request: `{ name, agentId?, schedule, message }` (web shape) — the
  * handler also accepts `{ name, schedule_kind, schedule_every_ms?,
  * schedule_expr?, timezone?, schedule_at?, payload_kind?, payload_text }`
- * (legacy flat shape). Loose-record on `schedule` (variant inner shape per
+ * (flat chat-tool shape). Loose-record on `schedule` (variant inner shape per
  * schedule.kind).
  *
  * Response: `{ jobId, name, schedule, model? }`. `schedule` is the normalized
@@ -52,6 +52,9 @@ export declare const CronAddContract: import("../types.js").ApiContract<z.ZodObj
     forward_to_main: z.ZodOptional<z.ZodBoolean>;
     session_strategy: z.ZodOptional<z.ZodString>;
     max_history_turns: z.ZodOptional<z.ZodNumber>;
+    wake_gate_script: z.ZodOptional<z.ZodString>;
+    wake_gate_language: z.ZodOptional<z.ZodString>;
+    wakeGate: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>, z.ZodObject<{
     jobId: z.ZodString;
     name: z.ZodString;
@@ -99,6 +102,9 @@ export declare const CronUpdateContract: import("../types.js").ApiContract<z.Zod
     schedule: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     message: z.ZodOptional<z.ZodString>;
     deliveryTarget: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    wake_gate_script: z.ZodOptional<z.ZodString>;
+    wake_gate_language: z.ZodOptional<z.ZodString>;
+    wakeGate: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>, z.ZodObject<{
     jobName: z.ZodString;
     updated: z.ZodBoolean;
@@ -217,6 +223,9 @@ export declare const CRON_HANDLERS_CONTRACTS: readonly [import("../types.js").Ap
     forward_to_main: z.ZodOptional<z.ZodBoolean>;
     session_strategy: z.ZodOptional<z.ZodString>;
     max_history_turns: z.ZodOptional<z.ZodNumber>;
+    wake_gate_script: z.ZodOptional<z.ZodString>;
+    wake_gate_language: z.ZodOptional<z.ZodString>;
+    wakeGate: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>, z.ZodObject<{
     jobId: z.ZodString;
     name: z.ZodString;
@@ -235,6 +244,9 @@ export declare const CRON_HANDLERS_CONTRACTS: readonly [import("../types.js").Ap
     schedule: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     message: z.ZodOptional<z.ZodString>;
     deliveryTarget: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    wake_gate_script: z.ZodOptional<z.ZodString>;
+    wake_gate_language: z.ZodOptional<z.ZodString>;
+    wakeGate: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>, z.ZodObject<{
     jobName: z.ZodString;
     updated: z.ZodBoolean;

package/node_modules/@comis/core/dist/api-contracts/orchestrator/cron-handlers.js

@@ -22,8 +22,8 @@ import { defineContract } from "../types.js";
  *
  * The contract describes the WEB on-wire shape (nested `schedule.{kind,expr,
  * tz,everyMs,at}` + `message`); the handler body accepts BOTH the web shape
- * (nested) AND the legacy chat-tool shape (flat `schedule_kind` /
- * `schedule_every_ms` / etc.) to preserve existing handler-test invocations.
+ * (nested) AND the chat-tool shape (flat `schedule_kind` /
+ * `schedule_every_ms` / etc.) — the chat-tool path sends the flat fields.
  *
  * Bespoke pre-Zod validation: duplicate job-name guard reads name on
  * rawParams.name BEFORE the schedule normalization (preserves the
@@ -32,7 +32,7 @@ import { defineContract } from "../types.js";
  * Request: `{ name, agentId?, schedule, message }` (web shape) — the
  * handler also accepts `{ name, schedule_kind, schedule_every_ms?,
  * schedule_expr?, timezone?, schedule_at?, payload_kind?, payload_text }`
- * (legacy flat shape). Loose-record on `schedule` (variant inner shape per
+ * (flat chat-tool shape). Loose-record on `schedule` (variant inner shape per
  * schedule.kind).
  *
  * Response: `{ jobId, name, schedule, model? }`. `schedule` is the normalized
@@ -50,7 +50,7 @@ export const CronAddContract = defineContract({
         sessionTarget: z.string().optional(),
         deliveryTarget: z.record(z.string(), z.unknown()).optional(),
         enabled: z.boolean().optional(),
-        // Legacy flat shape (chat-tool path — exercised by 14+ existing tests).
+        // Flat chat-tool shape (the chat-tool path sends these top-level fields).
         schedule_kind: z.string().optional(),
         payload_kind: z.string().optional(),
         payload_text: z.string().optional(),
@@ -67,6 +67,12 @@ export const CronAddContract = defineContract({
         forward_to_main: z.boolean().optional(),
         session_strategy: z.string().optional(),
         max_history_turns: z.number().optional(),
+        // Optional pre-run wake-gate authoring: the flat chat-tool fields plus the
+        // nested web shape. Kept loose here (the closed js|ts language enum and its
+        // defaults are enforced downstream at the store).
+        wake_gate_script: z.string().optional(),
+        wake_gate_language: z.string().optional(),
+        wakeGate: z.record(z.string(), z.unknown()).optional(),
     }),
     response: z.object({
         jobId: z.string(),
@@ -92,9 +98,9 @@ export const CronAddContract = defineContract({
  */
 export const CronListContract = defineContract({
     method: "cron.list",
-    // TARGET-01: optional explicit `agentId` selects one agent's jobs; `agentId: "*"`
-    // returns EVERY agent's jobs (each tagged by `agentId`) — the admin inventory view
-    // I lacked when a non-default agent's crons were invisible. Absent → connection
+    // Optional explicit `agentId` selects one agent's jobs; `agentId: "*"` returns
+    // EVERY agent's jobs (each tagged by `agentId`) — the admin inventory view;
+    // without it a non-default agent's crons are invisible. Absent → connection
     // `_agentId` ?? default (unchanged per-connection scoping).
     request: z.object({ agentId: z.string().optional() }),
     response: z.object({
@@ -132,6 +138,12 @@ export const CronUpdateContract = defineContract({
         schedule: z.record(z.string(), z.unknown()).optional(),
         message: z.string().optional(),
         deliveryTarget: z.nullable(z.record(z.string(), z.unknown())).optional(),
+        // Optional pre-run wake-gate authoring: the flat chat-tool fields plus the
+        // nested web shape. Kept loose here (the closed js|ts language enum and its
+        // defaults are enforced downstream at the store).
+        wake_gate_script: z.string().optional(),
+        wake_gate_language: z.string().optional(),
+        wakeGate: z.record(z.string(), z.unknown()).optional(),
     }),
     response: z.object({
         jobName: z.string(),
@@ -178,11 +190,11 @@ export const CronRemoveContract = defineContract({
  */
 export const CronStatusContract = defineContract({
     method: "cron.status",
-    request: z.object({ agentId: z.string().optional() }), // TARGET-01
+    request: z.object({ agentId: z.string().optional() }), // explicit per-agent targeting
     response: z.object({
         running: z.boolean(),
         jobCount: z.number(),
-        resolvedAgentId: z.string().optional(), // TARGET-01: the agent this status is for
+        resolvedAgentId: z.string().optional(), // the agent this status is for
     }),
     scopes: ["rpc"],
 });
@@ -205,7 +217,7 @@ export const CronRunsContract = defineContract({
     request: z.object({
         jobName: z.string(),
         limit: z.number().optional(),
-        agentId: z.string().optional(), // TARGET-01: which agent's run-history
+        agentId: z.string().optional(), // which agent's run-history to read
     }),
     response: z.object({
         runs: z.array(z.record(z.string(), z.unknown())),
@@ -231,16 +243,16 @@ export const CronRunContract = defineContract({
     request: z.object({
         jobName: z.string().optional(),
         mode: z.string().optional(),
-        // TARGET-01: explicit per-agent targeting. When present it selects that agent's
+        // Explicit per-agent targeting. When present it selects that agent's
         // per-agent scheduler; absent, the handler falls back to the connection `_agentId`
-        // then the default — but the response ALWAYS states the resolved agent (I5).
+        // then the default — but the response ALWAYS states the resolved agent.
         agentId: z.string().optional(),
     }),
     response: z.object({
         triggered: z.boolean(),
         mode: z.string(),
         jobName: z.string().optional(),
-        // TARGET-01: the agent the trigger actually acted on (never a silent default).
+        // The agent the trigger actually acted on (never a silent default).
         resolvedAgentId: z.string().optional(),
     }),
     scopes: ["rpc"],

package/node_modules/@comis/core/dist/api-contracts/orchestrator/graph-handlers.d.ts

@@ -25,8 +25,8 @@ import { z } from "zod";
  *
  * Request: `{ nodes, label?, onFailure?, timeoutMs?, budget?, edges? }`.
  *   - `nodes` is `z.array(z.record(z.string(), z.unknown()))` because the
- *     handler calls `transformNodes` (snake_case → camelCase + legacy debate
- *     migration) BEFORE parseExecutionGraph. Inner shape varies per
+ *     handler calls `transformNodes` (snake_case → camelCase + agent-node
+ *     shape normalization) BEFORE parseExecutionGraph. Inner shape varies per
  *     `typeId`/`typeConfig` driver registry.
  *   - `onFailure` / `timeoutMs` / `budget` flow into the rawGraph build.
  *

package/node_modules/@comis/core/dist/api-contracts/orchestrator/graph-handlers.js

@@ -33,8 +33,8 @@ import { defineContract } from "../types.js";
  *
  * Request: `{ nodes, label?, onFailure?, timeoutMs?, budget?, edges? }`.
  *   - `nodes` is `z.array(z.record(z.string(), z.unknown()))` because the
- *     handler calls `transformNodes` (snake_case → camelCase + legacy debate
- *     migration) BEFORE parseExecutionGraph. Inner shape varies per
+ *     handler calls `transformNodes` (snake_case → camelCase + agent-node
+ *     shape normalization) BEFORE parseExecutionGraph. Inner shape varies per
  *     `typeId`/`typeConfig` driver registry.
  *   - `onFailure` / `timeoutMs` / `budget` flow into the rawGraph build.
  *

package/node_modules/@comis/core/dist/api-contracts/orchestrator/heartbeat-handlers.d.ts

@@ -2,9 +2,10 @@
  * Heartbeat-handlers contract slice.
  *
  * Mirrors `packages/daemon/src/api/heartbeat-handlers.ts` (4 methods —
- * heartbeat.*). Spread order in `HEARTBEAT_HANDLERS_CONTRACTS` matches
- * the legacy `ORCHESTRATOR_CONTRACTS` array byte for byte to keep
- * `contracts.generated.*` artifacts byte-identical.
+ * heartbeat.*). Spread order in `HEARTBEAT_HANDLERS_CONTRACTS` is
+ * determinism-critical: it fixes this slice's position within
+ * `ORCHESTRATOR_CONTRACTS`, keeping `contracts.generated.*` artifacts
+ * byte-identical across builds.
  *
  * @module
  */