comisai 1.0.44 → 1.0.46

package/node_modules/@comis/scheduler/dist/cron/cron-scheduler.js

@@ -67,7 +67,7 @@ export function createCronScheduler(deps) {
                 job.consecutiveErrors = 0;
                 job.lastRunAtMs = endTime;
                 job.nextRunAtMs = computeNextRunAtMs(job.schedule, endTime);
-                // OBS-8 (reflect-obs-20260627): a system_event payload is FIRE-AND-FORGET — executeJob
+                // A system_event payload is FIRE-AND-FORGET — executeJob
                 // dispatches the event and returns in ms while the real work (e.g. the ~20s __REFLECT__
                 // run) proceeds async. Logging "Job completed durationMs:15" reads as "finished in 15ms"
                 // and a completion-grep false-matches the dispatch. So distinguish the dispatch: the work's
@@ -179,6 +179,12 @@ export function createCronScheduler(deps) {
         getJobs() {
             return [...jobs];
         },
+        async persist() {
+            // Flush the current in-memory list (mirrors tick()'s post-run save). A
+            // caller that mutated a job through a getJobs() reference (e.g. cron.update)
+            // makes that edit durable here instead of waiting for the next due fire.
+            await store.save(jobs);
+        },
         async runMissedJobs() {
             await tick();
         },

package/node_modules/@comis/scheduler/dist/cron/cron-store.js

@@ -2,13 +2,11 @@
 // @allow-throw: boundary for file-IO + lock-acquisition errors in CronStore; consumed via daemon cron-handlers + setup-schedulers.
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import { z } from "zod";
 import { CronJobSchema } from "./cron-types.js";
 // Scheduler internals consume the canonical FileLockPort.withLock() API
 // from @comis/core. The FileLockPort returns Result<T, LockError> where
 // LockError = { kind: "locked" | "error", message: string }.
 import { createFileLock } from "@comis/core";
-const CronJobArraySchema = z.array(CronJobSchema);
 /** Lock options for CronStore mutations: short stale/update since operations are fast. */
 const LOCK_OPTIONS = { staleMs: 30_000, updateMs: 5_000 };
 /**
@@ -24,36 +22,70 @@ export function createCronStore(filePath, logger) {
     const fileLock = createFileLock();
     /** Internal load: reads and parses the store file. */
     async function loadFromFile() {
+        let raw;
         try {
-            const raw = await fs.readFile(filePath, "utf-8");
-            const parsed = JSON.parse(raw);
-            return CronJobArraySchema.parse(parsed);
+            raw = await fs.readFile(filePath, "utf-8");
         }
         catch (err) {
             // File doesn't exist -- return empty without warning
             if (isNodeError(err) && err.code === "ENOENT") {
                 return [];
             }
-            // JSON parse corruption -- log warning
-            if (err instanceof SyntaxError) {
-                logger?.warn({
-                    err: err.message,
-                    hint: "Cron store file contains invalid JSON; returning empty job list. Check .bak file for recovery.",
-                    errorKind: "validation",
-                }, "Cron store corruption detected");
-                return [];
-            }
-            // Zod validation failure -- log warning
-            if (err instanceof z.ZodError) {
-                logger?.warn({
-                    err: err.message,
-                    hint: "Cron store data failed schema validation; returning empty job list. Check .bak file for recovery.",
-                    errorKind: "validation",
-                }, "Cron store schema validation failed");
-                return [];
-            }
             throw err;
         }
+        // JSON parse corruption -- the whole file is unreadable, so nothing loads.
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch (err) {
+            logger?.warn({
+                err: err.message,
+                hint: "Cron store file contains invalid JSON; returning empty job list. Check .bak file for recovery.",
+                errorKind: "validation",
+            }, "Cron store corruption detected");
+            return [];
+        }
+        // Per-JOB validation, NOT an atomic array parse. A `z.array(CronJobSchema)`
+        // parse throws on the FIRST invalid element, which dropped EVERY job — one
+        // malformed job silently disabled all scheduling (incl. the system lifecycle
+        // crons) on the next reload. Instead quarantine only the invalid jobs and keep
+        // the valid ones; name each dropped job (id/name, never the body) so an
+        // operator can recover it from the .bak file. Prod trigger seen: a partial
+        // deliveryTarget persisted by a bare-cast cron.update (now validated on write).
+        const rows = Array.isArray(parsed) ? parsed : [];
+        const jobs = [];
+        const dropped = [];
+        let firstErr;
+        if (!Array.isArray(parsed)) {
+            // Root is not an array — treat the whole file as unloadable, but still via
+            // the same "kept/dropped" WARN shape below so the signal is uniform.
+            dropped.push({ index: -1 });
+            firstErr = "cron store root is not a JSON array";
+        }
+        else {
+            rows.forEach((row, index) => {
+                const result = CronJobSchema.safeParse(row);
+                if (result.success) {
+                    jobs.push(result.data);
+                }
+                else {
+                    dropped.push({ index, name: row?.name });
+                    firstErr ??= result.error.message;
+                }
+            });
+        }
+        if (dropped.length > 0) {
+            logger?.warn({
+                dropped: dropped.length,
+                kept: jobs.length,
+                droppedJobs: dropped, // ids/counts only — never the job body/script/secret
+                err: firstErr,
+                hint: `Cron store data failed schema validation; ${dropped.length} job(s) dropped, ${jobs.length} kept (a single bad job no longer empties the whole store). Check .bak file for recovery.`,
+                errorKind: "validation",
+            }, "Cron store schema validation failed");
+        }
+        return jobs;
     }
     /** Internal save: writes jobs atomically (write tmp, rename). */
     async function saveToFile(jobs) {

package/node_modules/@comis/scheduler/dist/cron/cron-types.d.ts

@@ -9,7 +9,7 @@ import { z } from "zod";
  *   Exists so "remind me in 2 minutes" resolves deterministically as now+N —
  *   small models reliably botch the absolute "at" + IANA-tz conversion (a
  *   keyless qwen3.6:35b scheduled "in 2 minutes" ~7h off by pairing the injected
- *   UTC hour with the user's display timezone; CRON-IN-01, live 2026-06-20).
+ *   UTC hour with the user's display timezone).
  */
 export declare const CronScheduleSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"cron">;
@@ -133,6 +133,14 @@ export declare const CronJobSchema: z.ZodObject<{
         allow: z.ZodDefault<z.ZodArray<z.ZodString>>;
         deny: z.ZodDefault<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>;
+    wakeGate: z.ZodOptional<z.ZodObject<{
+        script: z.ZodString;
+        language: z.ZodDefault<z.ZodEnum<{
+            js: "js";
+            ts: "ts";
+        }>>;
+        timeoutSeconds: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
     deliveryTarget: z.ZodOptional<z.ZodObject<{
         channelId: z.ZodString;
         userId: z.ZodString;

package/node_modules/@comis/scheduler/dist/cron/cron-types.js

@@ -10,7 +10,7 @@ import { z } from "zod";
  *   Exists so "remind me in 2 minutes" resolves deterministically as now+N —
  *   small models reliably botch the absolute "at" + IANA-tz conversion (a
  *   keyless qwen3.6:35b scheduled "in 2 minutes" ~7h off by pairing the injected
- *   UTC hour with the user's display timezone; CRON-IN-01, live 2026-06-20).
+ *   UTC hour with the user's display timezone).
  */
 export const CronScheduleSchema = z.discriminatedUnion("kind", [
     z.strictObject({
@@ -126,6 +126,12 @@ export const CronJobSchema = z.strictObject({
         allow: z.array(z.string()).default([]),
         deny: z.array(z.string()).default([]),
     }).optional(),
+    /** Optional pre-run wake-gate: a jailed script that decides whether to invoke the model. */
+    wakeGate: z.strictObject({
+        script: z.string().min(1),
+        language: z.enum(["js", "ts"]).default("js"),
+        timeoutSeconds: z.number().int().positive().max(300).default(30),
+    }).optional(),
     /** Delivery target for routing results to originating channel */
     deliveryTarget: CronDeliveryTargetSchema.optional(),
     /** Whether this job is currently enabled */

package/node_modules/@comis/scheduler/dist/cron/index.d.ts

@@ -1,6 +1,9 @@
 export type { CronJob, CronSchedule } from "./cron-types.js";
+export { CronDeliveryTargetSchema } from "./cron-types.js";
 export { computeNextRunAtMs } from "./cron-expression.js";
 export { createCronStore } from "./cron-store.js";
 export type { CronStore } from "./cron-store.js";
 export { createCronScheduler } from "./cron-scheduler.js";
 export type { CronScheduler } from "./cron-scheduler.js";
+export { parseWakeGateVerdict } from "./wake-gate-verdict.js";
+export type { WakeGateVerdict } from "./wake-gate-verdict.js";

package/node_modules/@comis/scheduler/dist/cron/index.js

@@ -1,8 +1,14 @@
 // SPDX-License-Identifier: Apache-2.0
 // @comis/scheduler/cron — cron scheduling
+// The delivery-target schema — exported so the RPC write path can validate a
+// caller-supplied deliveryTarget against the SAME shape the store enforces on
+// load (prevents a partial target poison-pilling the whole job array).
+export { CronDeliveryTargetSchema } from "./cron-types.js";
 // Cron expression evaluation
 export { computeNextRunAtMs } from "./cron-expression.js";
 // Cron store (atomic JSON persistence)
 export { createCronStore } from "./cron-store.js";
 // Cron scheduler (timer loop, job lifecycle, error backoff)
 export { createCronScheduler } from "./cron-scheduler.js";
+// Pre-run wake-gate: pure, fail-open verdict parser
+export { parseWakeGateVerdict } from "./wake-gate-verdict.js";

package/node_modules/@comis/scheduler/dist/cron/wake-gate-verdict.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Pure, fail-open verdict parser for a pre-run gate script.
+ *
+ * A gate is an untrusted script that runs before a scheduled payload and
+ * decides whether to invoke the model at all. This maps the gate's raw run
+ * outcome to a decision.
+ *
+ * The invariant is **fail-open**: a gate that emits no verdict, crashes, times
+ * out, or overflows wakes the model — only an explicit boolean `wake` on the
+ * last non-empty line, or a known silent sentinel on that line, decides
+ * otherwise. Fail-open is resolved LAST so it covers every non-verdict case,
+ * which guarantees a broken monitor is never silently dropped.
+ *
+ * @module
+ */
+/** The gate run outcome the parser resolves. Pure input; no I/O. */
+export interface WakeGateRunOutcome {
+    readonly stdout: string;
+    /** `0` or `null` = clean exit; any other number = failure. */
+    readonly exitCode: number | null;
+    readonly timedOut: boolean;
+    readonly overflowed: boolean;
+}
+/** The resolved gate decision. */
+export interface WakeGateVerdict {
+    readonly wake: boolean;
+    /** Pre-gathered finding to inject when waking. */
+    readonly context?: string;
+    /** Routine-status text to deliver without a model turn. */
+    readonly deliver?: string;
+}
+/**
+ * Resolve a gate run outcome to a wake decision.
+ *
+ * Total function: it always yields a verdict, failing open on every
+ * non-verdict or failure case. Resolution order:
+ * 1. A failed run (timeout, overflow, or non-zero exit) wakes regardless of
+ *    stdout content.
+ * 2. No non-empty output wakes (an empty gate is never resolved to silent).
+ * 3. An explicit JSON verdict with a boolean `wake` on the last non-empty
+ *    line is honored (optional string `context` / `deliver`).
+ * 4. A known silent sentinel on that line (`HEARTBEAT_OK` / `NO_REPLY`, or a
+ *    `[SILENT]`-prefixed line, case-insensitive) skips; a trailing
+ *    `[SILENT] <text>` carries `<text>` as `deliver`.
+ * 5. Any other stdout wakes, carrying a bounded stdout tail as context.
+ */
+export declare function parseWakeGateVerdict(outcome: WakeGateRunOutcome): WakeGateVerdict;

package/node_modules/@comis/scheduler/dist/cron/wake-gate-verdict.js

@@ -0,0 +1,102 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Pure, fail-open verdict parser for a pre-run gate script.
+ *
+ * A gate is an untrusted script that runs before a scheduled payload and
+ * decides whether to invoke the model at all. This maps the gate's raw run
+ * outcome to a decision.
+ *
+ * The invariant is **fail-open**: a gate that emits no verdict, crashes, times
+ * out, or overflows wakes the model — only an explicit boolean `wake` on the
+ * last non-empty line, or a known silent sentinel on that line, decides
+ * otherwise. Fail-open is resolved LAST so it covers every non-verdict case,
+ * which guarantees a broken monitor is never silently dropped.
+ *
+ * @module
+ */
+import { HEARTBEAT_OK_TOKEN, NO_REPLY_TOKEN, SILENT_PREFIX } from "@comis/shared";
+/**
+ * Upper bound on the stdout tail carried as `context`. Keeps an injected
+ * finding content-light rather than forwarding an unbounded script dump.
+ */
+const CONTEXT_TAIL_MAX_CHARS = 4000;
+/** Return the last `CONTEXT_TAIL_MAX_CHARS` chars of `s` (or all of it). */
+function boundedTail(s) {
+    return s.length <= CONTEXT_TAIL_MAX_CHARS ? s : s.slice(-CONTEXT_TAIL_MAX_CHARS);
+}
+/** Wake the model, attaching a bounded stdout tail as context when present. */
+function failOpen(stdout) {
+    const tail = boundedTail(stdout);
+    return tail ? { wake: true, context: tail } : { wake: true };
+}
+/** Return the last line whose trimmed form is non-empty, or `undefined`. */
+function lastNonEmptyLine(stdout) {
+    return stdout.split(/\r?\n/).findLast((line) => line.trim().length > 0);
+}
+/** Parse an explicit JSON verdict from a line, or `undefined` if it is not one. */
+function parseJsonVerdict(line) {
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch {
+        return undefined;
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return undefined;
+    }
+    const record = parsed;
+    if (typeof record.wake !== "boolean")
+        return undefined;
+    // Bound the explicit-JSON context/deliver to the SAME content-light cap the
+    // fail-open tail applies. Without this an explicit {"wake":true,"context":...}
+    // bypasses the bound entirely, so up to the runner's 4 MiB stdout cap could
+    // enter the prompt — defeating the stated "content-light rather than an
+    // unbounded script dump" intent.
+    return {
+        wake: record.wake,
+        ...(typeof record.context === "string" ? { context: boundedTail(record.context) } : {}),
+        ...(typeof record.deliver === "string" ? { deliver: boundedTail(record.deliver) } : {}),
+    };
+}
+/**
+ * Resolve a gate run outcome to a wake decision.
+ *
+ * Total function: it always yields a verdict, failing open on every
+ * non-verdict or failure case. Resolution order:
+ * 1. A failed run (timeout, overflow, or non-zero exit) wakes regardless of
+ *    stdout content.
+ * 2. No non-empty output wakes (an empty gate is never resolved to silent).
+ * 3. An explicit JSON verdict with a boolean `wake` on the last non-empty
+ *    line is honored (optional string `context` / `deliver`).
+ * 4. A known silent sentinel on that line (`HEARTBEAT_OK` / `NO_REPLY`, or a
+ *    `[SILENT]`-prefixed line, case-insensitive) skips; a trailing
+ *    `[SILENT] <text>` carries `<text>` as `deliver`.
+ * 5. Any other stdout wakes, carrying a bounded stdout tail as context.
+ */
+export function parseWakeGateVerdict(outcome) {
+    // 1. A failed run wakes regardless of stdout content.
+    if (outcome.timedOut || outcome.overflowed || (outcome.exitCode !== 0 && outcome.exitCode !== null)) {
+        return failOpen(outcome.stdout);
+    }
+    // 2. No non-empty output → fail open (never resolve an empty gate to silent).
+    const lastLine = lastNonEmptyLine(outcome.stdout);
+    if (lastLine === undefined)
+        return { wake: true };
+    const trimmed = lastLine.trim();
+    // 3. An explicit JSON verdict on the last non-empty line wins.
+    const jsonVerdict = parseJsonVerdict(trimmed);
+    if (jsonVerdict !== undefined)
+        return jsonVerdict;
+    // 4. Known silent sentinels on the (non-empty) last line.
+    const upper = trimmed.toUpperCase();
+    if (upper === HEARTBEAT_OK_TOKEN || upper === NO_REPLY_TOKEN) {
+        return { wake: false };
+    }
+    if (upper.startsWith(SILENT_PREFIX)) {
+        const deliver = trimmed.slice(SILENT_PREFIX.length).trim();
+        return deliver ? { wake: false, deliver } : { wake: false };
+    }
+    // 5. Any other stdout → fail open with the bounded tail as context.
+    return failOpen(outcome.stdout);
+}

package/node_modules/@comis/scheduler/dist/execution/execution-tracker.d.ts

@@ -25,6 +25,12 @@ export interface ExecutionLogEntry {
     costUsd?: number;
     /** Number of tool calls executed. */
     toolCalls?: number;
+    /** Estimated model turns avoided by a wake-gate skip (1 per skipped fire, 0 on wake). Content-free — a count only. */
+    estTurnsSaved?: number;
+    /** The wake-gate fire's `root-wakegate-<jobId>-<ts>-<nonce>` root, when the gate ran.
+     *  Lets `cron.runs "<jobName>"` hand an operator the root to reconstruct the gate's
+     *  cap-calls via `comis explain <rootRunId>` (the cap-audit stream keys on it). */
+    rootRunId?: string;
     /** Number of LLM API calls made. */
     llmCalls?: number;
     /** Names of tools that failed during execution. */

package/node_modules/@comis/scheduler/dist/execution/execution-tracker.js

@@ -20,6 +20,8 @@ const ExecutionLogEntrySchema = z.object({
     totalTokens: z.number().optional(),
     costUsd: z.number().optional(),
     toolCalls: z.number().optional(),
+    estTurnsSaved: z.number().optional(),
+    rootRunId: z.string().optional(),
     llmCalls: z.number().optional(),
     failedTools: z.array(z.string()).optional(),
 });

package/node_modules/@comis/scheduler/dist/index.d.ts

@@ -1,10 +1,13 @@
 export type { SchedulerLogger } from "./shared-types.js";
 export type { CronJob, CronSchedule } from "./cron/index.js";
+export { CronDeliveryTargetSchema } from "./cron/index.js";
 export { computeNextRunAtMs } from "./cron/index.js";
 export { createCronStore } from "./cron/index.js";
 export type { CronStore } from "./cron/index.js";
 export { createCronScheduler } from "./cron/index.js";
 export type { CronScheduler } from "./cron/index.js";
+export { parseWakeGateVerdict } from "./cron/index.js";
+export type { WakeGateVerdict } from "./cron/index.js";
 export { createExecutionTracker } from "./execution/index.js";
 export type { ExecutionTracker, ExecutionLogEntry } from "./execution/index.js";
 export { createHeartbeatRunner } from "./heartbeat/index.js";

package/node_modules/@comis/scheduler/dist/index.js

@@ -1,17 +1,20 @@
 // SPDX-License-Identifier: Apache-2.0
 // @comis/scheduler - proactive automation: cron scheduling, heartbeat, execution safety
 // Public API -- all exports have verified external consumers.
+export { CronDeliveryTargetSchema } from "./cron/index.js";
 // Cron engine
 export { computeNextRunAtMs } from "./cron/index.js";
 export { createCronStore } from "./cron/index.js";
 export { createCronScheduler } from "./cron/index.js";
+// Pre-run wake-gate: pure, fail-open verdict parser
+export { parseWakeGateVerdict } from "./cron/index.js";
 // Execution safety
 export { createExecutionTracker } from "./execution/index.js";
 // createFileLock lives in @comis/core. Consumers (CLI, agent OAuth call
 // sites, daemon composition root, scheduler internals) import directly from
 // @comis/core; scheduler no longer mediates the FileLockPort factory.
 // Heartbeat monitoring
-// HEARTBEAT_OK_TOKEN was previously re-exported here; canonical home is @comis/shared.
+// HEARTBEAT_OK_TOKEN is not re-exported here; its canonical home is @comis/shared.
 export { createHeartbeatRunner } from "./heartbeat/index.js";
 // Per-agent heartbeat config resolution
 export { resolveEffectiveHeartbeatConfig } from "./heartbeat/index.js";

package/node_modules/@comis/scheduler/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@comis/scheduler",
   "private": true,
-  "version": "1.0.44",
+  "version": "1.0.46",
   "author": "Moshe Anconina",
   "license": "Apache-2.0",
   "description": "Task scheduling and cron management for Comis",

package/node_modules/@comis/shared/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@comis/shared",
   "private": true,
-  "version": "1.0.44",
+  "version": "1.0.46",
   "author": "Moshe Anconina",
   "license": "Apache-2.0",
   "description": "Shared types and utilities for the Comis platform",

package/node_modules/@comis/skills/dist/platform-tools/registry.d.ts

@@ -77,12 +77,12 @@ export interface PlatformToolBuildContext {
     readonly onSuspiciousContent?: WrapExternalContentOptions["onSuspiciousContent"];
     /** `image_generate` tool's conditional predicate signal (truthy when provider wired). */
     readonly imageGenProvider?: unknown;
-    /** `video_generate` tool's conditional predicate signal (truthy when provider wired; daemon sets it in Phase 188 Plan 04). */
+    /** `video_generate` tool's conditional predicate signal (truthy when provider wired; the daemon sets it at boot). */
     readonly videoGenProvider?: unknown;
-    /** `video_status` tool's conditional predicate signal (Phase 189 / JOB-04;
+    /** `video_status` tool's conditional predicate signal:
      *  truthy when the async stack — store + poller — is wired, gated on the SAME
      *  condition `videoGenProvider` uses so video_status activates exactly when
-     *  video_generate does). */
+     *  video_generate does. */
     readonly videoStatusEnabled?: unknown;
     /** `background_tasks` tool's conditional predicate signal (truthy when manager wired). */
     readonly backgroundTaskManager?: unknown;
@@ -90,9 +90,9 @@ export interface PlatformToolBuildContext {
     readonly toolCapabilityPort?: unknown;
     /** Per-agent context-engine version signal (`"pipeline"` | `"dag"`). Set by
      *  setup-tools but currently unconsumed — its only reader, the `unified_context`
-     *  conditional, was removed in Phase 126 (DAG demolition). Retained as a
-     *  harmless optional so the daemon's BuildContext literal stays valid; a
-     *  governed LCD expansion surface re-reads it in Phase 131. */
+     *  conditional, has been removed. Retained as a harmless optional so the
+     *  daemon's BuildContext literal stays valid; a future governed LCD expansion
+     *  surface may re-read it. */
     readonly contextEngineVersion?: string;
     /** `browser` tool's conditional predicate. */
     readonly builtinToolsBrowserEnabled?: boolean;

package/node_modules/@comis/skills/dist/platform-tools/registry.js

@@ -45,10 +45,10 @@ import { createBrowserTool } from "./tools/browser-tool.js";
 import { createListResourcesTool, createReadResourceTool } from "./tools/mcp-resources-tool.js";
 import { createListPromptsTool, createGetPromptTool } from "./tools/mcp-prompts-tool.js";
 // Side-effect import: registers `suppressActivity:true` metadata for the
-// non-§17.6 platform tools. Importing the tool factory modules above
-// already triggers each §17.6 tool's co-located `registerActivityLabelSpec`
-// call; this completes the other side of the coverage contract so every
-// emitted name is classified before any registry walk.
+// platform tools that have no activity-label spec. Importing the tool factory
+// modules above already triggers each activity-label-spec tool's co-located
+// `registerActivityLabelSpec` call; this completes the other side of the
+// coverage contract so every emitted name is classified before any registry walk.
 import "./tools/suppressed-tools-metadata.js";
 // Capability-gate helpers + manager type for the resources/prompts descriptor
 // conditionals. Imported from the mcp-client barrel (the public surface of
@@ -219,7 +219,7 @@ export function createPlatformToolRegistry() {
             name: "video_generate",
             category: "media",
             conditional: (ctx) => ctx.videoGenProvider !== undefined,
-            // IN-03 (191): thread the boot-selected videoGenProvider so the tool
+            // Thread the boot-selected videoGenProvider so the tool
             // description is built at registration from the ACTIVE backend's
             // capability matrix (the conditional above guarantees it is present).
             build: (ctx) => createVideoGenerateTool(ctx.rpcCall, ctx.videoGenProvider),

package/node_modules/@comis/skills/dist/platform-tools/tools/agents-manage-tool.d.ts

@@ -96,7 +96,7 @@ export declare function buildCreateContract(agentId: string, workspaceDir: strin
  * @param logger - Required structured logger. Used to emit a per-create
  *   INFO log pinning the next-step contract emission.
  *   Mirrors the gateway-tool required-logger position; no overload-with-
- *   default-logger compat shim (per `feedback_no_backward_compat.md`).
+ *   default-logger compat shim (the project does not ship backward-compat shims).
  * @param approvalGate - Optional approval gate for create/delete actions
  * @returns AgentTool implementing the agent management interface
  */

package/node_modules/@comis/skills/dist/platform-tools/tools/agents-manage-tool.js

@@ -13,7 +13,7 @@ import { Type } from "typebox";
 import { registerActivityLabelSpec } from "@comis/core";
 import { readStringParam } from "../tool-helpers.js";
 import { createAdminManageTool } from "../admin-manage-factory.js";
-// Activity label spec (§17.6). Descriptor name == emitted name.
+// Activity label spec. Descriptor name == emitted name.
 // Per-action overrides use the tool's REAL action enum.
 registerActivityLabelSpec("agents_manage", {
     semanticPhase: "tool",
@@ -251,7 +251,7 @@ function coerceConfig(p) {
  * @param logger - Required structured logger. Used to emit a per-create
  *   INFO log pinning the next-step contract emission.
  *   Mirrors the gateway-tool required-logger position; no overload-with-
- *   default-logger compat shim (per `feedback_no_backward_compat.md`).
+ *   default-logger compat shim (the project does not ship backward-compat shims).
  * @param approvalGate - Optional approval gate for create/delete actions
  * @returns AgentTool implementing the agent management interface
  */

package/node_modules/@comis/skills/dist/platform-tools/tools/browser-tool-schema.d.ts

@@ -1,8 +1,8 @@
 /**
  * TypeBox schema for the browser platform tool parameters.
  *
- * Ported from Comis's browser-tool.schema.ts. Uses a flattened object
- * schema (not nested unions) for Claude/OpenAI function calling compatibility.
+ * Uses a flattened object schema (not nested unions) for Claude/OpenAI
+ * function calling compatibility.
  *
  * @module
  */

package/node_modules/@comis/skills/dist/platform-tools/tools/browser-tool-schema.js

@@ -2,8 +2,8 @@
 /**
  * TypeBox schema for the browser platform tool parameters.
  *
- * Ported from Comis's browser-tool.schema.ts. Uses a flattened object
- * schema (not nested unions) for Claude/OpenAI function calling compatibility.
+ * Uses a flattened object schema (not nested unions) for Claude/OpenAI
+ * function calling compatibility.
  *
  * @module
  */

package/node_modules/@comis/skills/dist/platform-tools/tools/browser-tool.d.ts

@@ -7,7 +7,7 @@
  * browser-service; this tool is a thin RPC delegation layer.
  *
  * Security: Navigate and open actions validate URLs through the SSRF guard
- * before delegating to rpcCall (improvement over Comis).
+ * before delegating to rpcCall.
  *
  * @module
  */

package/node_modules/@comis/skills/dist/platform-tools/tools/browser-tool.js

@@ -8,14 +8,14 @@
  * browser-service; this tool is a thin RPC delegation layer.
  *
  * Security: Navigate and open actions validate URLs through the SSRF guard
- * before delegating to rpcCall (improvement over Comis).
+ * before delegating to rpcCall.
  *
  * @module
  */
 import { validateUrl, registerActivityLabelSpec } from "@comis/core";
 import { jsonResult, throwToolError, imageResult, dualImageResult, readStringParam } from "../tool-helpers.js";
 import { BrowserToolSchema } from "./browser-tool-schema.js";
-// Activity label spec (§17.6). Descriptor name == emitted name. A
+// Activity label spec. Descriptor name == emitted name. A
 // tool-level label covers the gate; the browser action enum lives in
 // browser-tool-schema.ts and is not surfaced per-action here.
 registerActivityLabelSpec("browser", {

package/node_modules/@comis/skills/dist/platform-tools/tools/channels-manage-tool.js

@@ -13,7 +13,7 @@ import { Type } from "typebox";
 import { tryGetContext, registerActivityLabelSpec } from "@comis/core";
 import { readStringParam, readBooleanParam, throwToolError, } from "../tool-helpers.js";
 import { createAdminManageTool } from "../admin-manage-factory.js";
-// Activity label spec (§17.6). Descriptor name == emitted name.
+// Activity label spec. Descriptor name == emitted name.
 // Per-action overrides use the tool's REAL action enum.
 registerActivityLabelSpec("channels_manage", {
     semanticPhase: "tool",

package/node_modules/@comis/skills/dist/platform-tools/tools/cron-tool.d.ts

@@ -29,6 +29,8 @@ declare const CronToolParams: Type.TObject<{
     session_strategy: Type.TOptional<Type.TUnion<[Type.TLiteral<"fresh">, Type.TLiteral<"rolling">, Type.TLiteral<"accumulate">]>>;
     max_history_turns: Type.TOptional<Type.TInteger>;
     model: Type.TOptional<Type.TString>;
+    wake_gate_script: Type.TOptional<Type.TString>;
+    wake_gate_language: Type.TOptional<Type.TUnion<[Type.TLiteral<"js">, Type.TLiteral<"ts">]>>;
     job_name: Type.TOptional<Type.TString>;
     enabled: Type.TOptional<Type.TBoolean>;
     limit: Type.TOptional<Type.TInteger>;