@cjhyy/code-shell-core 0.5.0-rc.1 → 0.6.0-rc.1

package/dist/arena/planner.js

@@ -67,7 +67,6 @@ export async function planArena(topic, llmConfig, flags, signal) {
         signal?.throwIfAborted();
         const client = await createLLMClient({
             ...llmConfig,
-            enableStreaming: false,
             maxTokens: 1024,
         });
         const response = await client.createMessage({

package/dist/arena/providers/docs.d.ts

@@ -4,3 +4,4 @@
  */
 import type { ArenaContextProvider } from "../types.js";
 export declare const docsProvider: ArenaContextProvider;
+export declare function truncate(content: string): string;

package/dist/arena/providers/docs.js

@@ -99,10 +99,13 @@ function safeReadDoc(filePath) {
         return null;
     }
 }
-function truncate(content) {
+export function truncate(content) {
     if (content.length <= MAX_DOC_CHARS)
         return content;
     const t = content.slice(0, MAX_DOC_CHARS);
     const lastNl = t.lastIndexOf("\n");
-    return t.slice(0, lastNl) + `\n... (truncated, ${content.length} chars total)`;
+    // No newline in the window → lastNl is -1 and slice(0,-1) would drop just
+    // the last char; cut at MAX_DOC_CHARS instead.
+    const body = lastNl > 0 ? t.slice(0, lastNl) : t;
+    return body + `\n... (truncated, ${content.length} chars total)`;
 }

package/dist/arena/providers/repo.d.ts

@@ -4,3 +4,4 @@
  */
 import type { ArenaContextProvider } from "../types.js";
 export declare const repoProvider: ArenaContextProvider;
+export declare function truncate(content: string): string;

package/dist/arena/providers/repo.js

@@ -192,12 +192,15 @@ function safeReadFile(filePath) {
         return null;
     }
 }
-function truncate(content) {
+export function truncate(content) {
     if (content.length <= MAX_FILE_CHARS)
         return content;
     const t = content.slice(0, MAX_FILE_CHARS);
     const lastNl = t.lastIndexOf("\n");
-    return t.slice(0, lastNl) + `\n... (truncated, ${content.length} chars total)`;
+    // No newline in the window (e.g. a minified file) → lastNl is -1 and
+    // slice(0,-1) would drop just the last char; cut at MAX_FILE_CHARS instead.
+    const body = lastNl > 0 ? t.slice(0, lastNl) : t;
+    return body + `\n... (truncated, ${content.length} chars total)`;
 }
 async function safeGrep(pattern) {
     try {

package/dist/arena/strategies/utils.d.ts

@@ -1,9 +1,6 @@
 /** Shared utilities for arena strategy implementations. */
 import type { ArenaBaseContext, FindingReview, ParticipantReport, ArenaConsensus, ArenaRoadmapPhaseDetail, ClaimRecord, ClaimChallenge, ClaimAdjudication, ClaimStatusSummary, DebateTurn, RoundResearchDigest } from "../types.js";
-/** Extract JSON from text that might have markdown fences or surrounding text */
-export declare function extractJSON(text: string): string;
-/** Extract a JSON array from text */
-export declare function extractJSONArray(text: string): string;
+export { extractJSON, extractJSONArray } from "../../utils/json.js";
 /** Format base context into a readable text block for LLM prompts */
 export declare function formatBaseContext(ctx: ArenaBaseContext): string;
 /** Format participant reports for cross-review or consensus prompts */

package/dist/arena/strategies/utils.js

@@ -22,57 +22,13 @@ function sanitizeForPrompt(text) {
         .replace(/^(?:IGNORE|DISREGARD|FORGET|OVERRIDE|SYSTEM|INSTRUCTION)[:\s].*/gim, "")
         .slice(0, 3000);
 }
-/** Extract JSON from text that might have markdown fences or surrounding text */
-export function extractJSON(text) {
-    // Try fenced code blocks — use GREEDY match to handle nested backticks
-    const fenced = text.match(/```(?:json)?\s*\n([\s\S]*)\n\s*```/);
-    if (fenced)
-        return fenced[1].trim();
-    // Try to find the outermost { ... } pair with balanced braces
-    const start = text.indexOf("{");
-    if (start !== -1) {
-        let depth = 0;
-        let inString = false;
-        let escape = false;
-        for (let i = start; i < text.length; i++) {
-            const ch = text[i];
-            if (escape) {
-                escape = false;
-                continue;
-            }
-            if (ch === "\\") {
-                escape = true;
-                continue;
-            }
-            if (ch === '"') {
-                inString = !inString;
-                continue;
-            }
-            if (inString)
-                continue;
-            if (ch === "{")
-                depth++;
-            else if (ch === "}") {
-                depth--;
-                if (depth === 0)
-                    return text.slice(start, i + 1);
-            }
-        }
-        // Unbalanced — return from start to end as best effort
-        return text.slice(start);
-    }
-    return text;
-}
-/** Extract a JSON array from text */
-export function extractJSONArray(text) {
-    const fenced = text.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
-    if (fenced)
-        return fenced[1].trim();
-    const arrayMatch = text.match(/\[[\s\S]*\]/);
-    if (arrayMatch)
-        return arrayMatch[0];
-    return text;
-}
+// extractJSON / extractJSONArray are generic JSON extractors with no Arena
+// dependency. They moved to utils/json.ts so non-Arena consumers (e.g.
+// services/memory-orchestrator) can use them without importing this Arena
+// module — that import made Arena a dependency of a core service. Re-exported
+// here for back-compat with Arena's own callers and the existing test.
+export { extractJSON, extractJSONArray } from "../../utils/json.js";
+import { extractJSON, extractJSONArray } from "../../utils/json.js";
 /** Format base context into a readable text block for LLM prompts */
 export function formatBaseContext(ctx) {
     const sections = [];

package/dist/arena/transitions.d.ts

@@ -5,9 +5,14 @@
  * consistent state transitions across phases.
  *
  * State machine:
- *   proposed → under_review
- *   under_review → verified | contested | rejected
+ *   proposed → under_review | unresolved
+ *   under_review → verified | contested | rejected | unresolved
  *   contested → under_review | unresolved | verified | rejected
+ *
+ * `unresolved` is reachable from proposed/under_review (not just contested):
+ * adjudication sweeps any claims left in those states when the round/budget
+ * is exhausted (adjudication.ts) — without these edges markUnresolved() would
+ * silently no-op and the claims would be dropped from the consensus summary.
  */
 import type { ClaimRecord, ClaimStatus, ClaimChallenge } from "./types.js";
 /**

package/dist/arena/transitions.js

@@ -5,14 +5,19 @@
  * consistent state transitions across phases.
  *
  * State machine:
- *   proposed → under_review
- *   under_review → verified | contested | rejected
+ *   proposed → under_review | unresolved
+ *   under_review → verified | contested | rejected | unresolved
  *   contested → under_review | unresolved | verified | rejected
+ *
+ * `unresolved` is reachable from proposed/under_review (not just contested):
+ * adjudication sweeps any claims left in those states when the round/budget
+ * is exhausted (adjudication.ts) — without these edges markUnresolved() would
+ * silently no-op and the claims would be dropped from the consensus summary.
  */
 /** Valid transitions from each status */
 const VALID_TRANSITIONS = {
-    proposed: ["under_review"],
-    under_review: ["verified", "contested", "rejected"],
+    proposed: ["under_review", "unresolved"],
+    under_review: ["verified", "contested", "rejected", "unresolved"],
     contested: ["under_review", "unresolved", "verified", "rejected"],
     verified: [],
     rejected: [],

package/dist/arena/types.d.ts

@@ -3,7 +3,7 @@
  *
  * V2 architecture: shared facts → independent research → findings → cross-review → consensus.
  */
-import type { LLMConfig } from "../types.js";
+import type { ClientDefaults, LLMConfig } from "../types.js";
 /** Arena operating mode — determines prompts, output format, and default rounds */
 export type ArenaMode = "review" | "discussion" | "planning";
 /** Analysis lens — the perspective from which participants analyze */
@@ -87,8 +87,14 @@ export declare const ARENA_MODE_DEFAULTS: Record<ArenaMode, {
 export interface ArenaParticipant {
     /** Display name, e.g. "Claude Sonnet", "GPT-4o" */
     name: string;
-    /** LLM config for this participant */
+    /** LLM config for this participant (pure model identity) */
     llm: LLMConfig;
+    /**
+     * Cross-model client knobs (temperature/timeout/etc.). Arena hardcodes
+     * temperature here so debate participants speak with consistent sampling
+     * regardless of the user's session preference.
+     */
+    clientDefaults?: ClientDefaults;
 }
 export interface ArenaBaseContext {
     /** Evidence-driven plan that drives the session */

package/dist/automation/cron-expr.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Minimal 5-field cron expression parser + timezone-aware next-trigger
+ * calculator. No third-party dependency (core keeps its dep set tight).
+ *
+ * Fields:  minute(0-59) hour(0-23) dayOfMonth(1-31) month(1-12) dayOfWeek(0-6, 0=Sun)
+ * Syntax per field:  star | star-slash-n | a | a-b | a-b-slash-n | comma-lists of those.
+ *
+ * Timezone handling uses Intl.DateTimeFormat with a timeZone option to derive
+ * the wall-clock parts of a candidate UTC instant in the target zone — correct
+ * across DST without a tz library. nextCronTime steps minute-by-minute from the
+ * reference and returns the first future instant whose wall-clock parts (in tz)
+ * match every field. Bounded to ~2 years so an unsatisfiable expression can't
+ * loop forever.
+ */
+export interface ParsedCron {
+    minutes: Set<number>;
+    hours: Set<number>;
+    daysOfMonth: Set<number>;
+    months: Set<number>;
+    daysOfWeek: Set<number>;
+    /**
+     * Whether the dayOfMonth / dayOfWeek FIELD was restricted (anything other
+     * than a bare "*"). Vixie-cron semantics: when BOTH day fields are
+     * restricted, a tick matches if EITHER matches (OR); when only one is
+     * restricted, the "*" one is ignored and the restricted one governs. We
+     * can't recover this from the value Set alone ("*" and an explicit full
+     * range both expand to the full set), so we capture it at parse time.
+     */
+    domRestricted: boolean;
+    dowRestricted: boolean;
+}
+/** Cheap check: is this string a 5-field cron expression (vs an interval like "5m")? */
+export declare function isCronExpression(s: string): boolean;
+/** Parse a 5-field cron expression into per-field value sets. Throws on invalid input. */
+export declare function parseCronExpression(expr: string): ParsedCron;
+/**
+ * Return the next UTC instant (ms) strictly after `fromMs` whose wall-clock
+ * time in `timeZone` matches `cron`. Returns null if none within ~2 years
+ * (e.g. an impossible expression like Feb 30).
+ */
+export declare function nextCronTime(cron: ParsedCron, timeZone: string, fromMs: number): number | null;

package/dist/automation/cron-expr.js

@@ -0,0 +1,169 @@
+/**
+ * Minimal 5-field cron expression parser + timezone-aware next-trigger
+ * calculator. No third-party dependency (core keeps its dep set tight).
+ *
+ * Fields:  minute(0-59) hour(0-23) dayOfMonth(1-31) month(1-12) dayOfWeek(0-6, 0=Sun)
+ * Syntax per field:  star | star-slash-n | a | a-b | a-b-slash-n | comma-lists of those.
+ *
+ * Timezone handling uses Intl.DateTimeFormat with a timeZone option to derive
+ * the wall-clock parts of a candidate UTC instant in the target zone — correct
+ * across DST without a tz library. nextCronTime steps minute-by-minute from the
+ * reference and returns the first future instant whose wall-clock parts (in tz)
+ * match every field. Bounded to ~2 years so an unsatisfiable expression can't
+ * loop forever.
+ */
+const SPECS = [
+    { min: 0, max: 59 }, // minute
+    { min: 0, max: 23 }, // hour
+    { min: 1, max: 31 }, // day of month
+    { min: 1, max: 12 }, // month
+    { min: 0, max: 6 }, // day of week
+];
+/** Cheap check: is this string a 5-field cron expression (vs an interval like "5m")? */
+export function isCronExpression(s) {
+    if (typeof s !== "string")
+        return false;
+    const parts = s.trim().split(/\s+/);
+    if (parts.length !== 5)
+        return false;
+    // Every field must contain only cron field characters.
+    return parts.every((p) => /^[\d*/,-]+$/.test(p));
+}
+function parseField(field, spec) {
+    const out = new Set();
+    for (const part of field.split(",")) {
+        // Split optional step: "a-b/n" or "*/n" or "a/n"
+        const [rangePart, stepPart] = part.split("/");
+        const step = stepPart === undefined ? 1 : parseInt(stepPart, 10);
+        if (!Number.isInteger(step) || step <= 0) {
+            throw new Error(`Invalid cron step in "${field}"`);
+        }
+        let lo;
+        let hi;
+        if (rangePart === "*") {
+            lo = spec.min;
+            hi = spec.max;
+        }
+        else if (rangePart.includes("-")) {
+            const [a, b] = rangePart.split("-");
+            lo = parseInt(a, 10);
+            hi = parseInt(b, 10);
+        }
+        else {
+            lo = parseInt(rangePart, 10);
+            hi = lo;
+        }
+        if (!Number.isInteger(lo) || !Number.isInteger(hi)) {
+            throw new Error(`Invalid cron field "${field}"`);
+        }
+        if (lo < spec.min || hi > spec.max || lo > hi) {
+            throw new Error(`cron field "${field}" out of range [${spec.min}-${spec.max}]`);
+        }
+        for (let v = lo; v <= hi; v += step)
+            out.add(v);
+    }
+    return out;
+}
+/** Parse a 5-field cron expression into per-field value sets. Throws on invalid input. */
+export function parseCronExpression(expr) {
+    const parts = expr.trim().split(/\s+/);
+    if (parts.length !== 5) {
+        throw new Error(`cron expression must have 5 fields, got ${parts.length}: "${expr}"`);
+    }
+    return {
+        minutes: parseField(parts[0], SPECS[0]),
+        hours: parseField(parts[1], SPECS[1]),
+        daysOfMonth: parseField(parts[2], SPECS[2]),
+        months: parseField(parts[3], SPECS[3]),
+        daysOfWeek: parseField(parts[4], SPECS[4]),
+        // A bare "*" is unrestricted; anything else (a number, range, list, or even
+        // "*/n") restricts the field for the OR rule below.
+        domRestricted: parts[2].trim() !== "*",
+        dowRestricted: parts[4].trim() !== "*",
+    };
+}
+// Cache one formatter per timezone — constructing Intl.DateTimeFormat is costly.
+const formatterCache = new Map();
+function getFormatter(timeZone) {
+    let fmt = formatterCache.get(timeZone);
+    if (!fmt) {
+        fmt = new Intl.DateTimeFormat("en-US", {
+            timeZone,
+            hour12: false,
+            year: "numeric",
+            month: "2-digit",
+            day: "2-digit",
+            hour: "2-digit",
+            minute: "2-digit",
+            weekday: "short",
+        });
+        formatterCache.set(timeZone, fmt);
+    }
+    return fmt;
+}
+const WEEKDAY_INDEX = {
+    Sun: 0,
+    Mon: 1,
+    Tue: 2,
+    Wed: 3,
+    Thu: 4,
+    Fri: 5,
+    Sat: 6,
+};
+/** Derive the wall-clock parts of a UTC instant `ms` as seen in `timeZone`. */
+function wallClockInZone(ms, timeZone) {
+    const parts = getFormatter(timeZone).formatToParts(new Date(ms));
+    const get = (type) => parts.find((p) => p.type === type)?.value ?? "";
+    // hour can come back as "24" at midnight in some environments; normalize.
+    let hour = parseInt(get("hour"), 10);
+    if (hour === 24)
+        hour = 0;
+    return {
+        minute: parseInt(get("minute"), 10),
+        hour,
+        dayOfMonth: parseInt(get("day"), 10),
+        month: parseInt(get("month"), 10),
+        dayOfWeek: WEEKDAY_INDEX[get("weekday")] ?? 0,
+    };
+}
+function matches(cron, wc) {
+    if (!cron.minutes.has(wc.minute))
+        return false;
+    if (!cron.hours.has(wc.hour))
+        return false;
+    if (!cron.months.has(wc.month))
+        return false;
+    // Day-of-month vs day-of-week per Vixie/POSIX cron:
+    //   - both restricted → match if EITHER matches (OR)
+    //   - only one restricted → that one governs (the "*" one is ignored)
+    //   - neither restricted → matches every day
+    const domHit = cron.daysOfMonth.has(wc.dayOfMonth);
+    const dowHit = cron.daysOfWeek.has(wc.dayOfWeek);
+    if (cron.domRestricted && cron.dowRestricted)
+        return domHit || dowHit;
+    if (cron.domRestricted)
+        return domHit;
+    if (cron.dowRestricted)
+        return dowHit;
+    return true;
+}
+const MINUTE_MS = 60_000;
+// ~2 years of minutes — bounds the search for an unsatisfiable expression.
+const MAX_STEPS = 2 * 366 * 24 * 60;
+/**
+ * Return the next UTC instant (ms) strictly after `fromMs` whose wall-clock
+ * time in `timeZone` matches `cron`. Returns null if none within ~2 years
+ * (e.g. an impossible expression like Feb 30).
+ */
+export function nextCronTime(cron, timeZone, fromMs) {
+    // Start at the next whole minute strictly after fromMs (cron has minute
+    // granularity; we never return the reference instant itself).
+    let candidate = Math.floor(fromMs / MINUTE_MS) * MINUTE_MS + MINUTE_MS;
+    for (let i = 0; i < MAX_STEPS; i++) {
+        const wc = wallClockInZone(candidate, timeZone);
+        if (matches(cron, wc))
+            return candidate;
+        candidate += MINUTE_MS;
+    }
+    return null;
+}

package/dist/automation/index.d.ts

@@ -0,0 +1,41 @@
+/**
+ * automation/ — zero-environment-dependency scheduling module.
+ *
+ * Hosts (Electron main, future CLI server) load this module and inject their
+ * own store + runner. The module imports nothing from Electron/Ink and makes
+ * no GUI/TTY assumptions, so the same code runs in any host
+ * (docs/automation-plan-2026-05-31.md, D1).
+ */
+import { CronScheduler } from "./scheduler.js";
+import { type CronRunner, type RunSubmitter } from "./runner.js";
+import type { CronStore } from "./store.js";
+export interface StartAutomationDeps {
+    /** Persistence backend (injected; module never picks a path itself). */
+    store: CronStore;
+    /**
+     * Execution backend. Provide exactly one:
+     *   - `runner`: a one-shot run callback (Phase 1 direct-Engine path).
+     *   - `runManager`: a RunManager submitter (Phase 2 — runs land in RunStore
+     *     with full history/checkpoint/resume).
+     */
+    runner?: CronRunner;
+    runManager?: RunSubmitter;
+}
+export interface AutomationHandle {
+    scheduler: CronScheduler;
+    /** Halt all timers and release the scheduler. Idempotent. */
+    stop(): void;
+}
+/**
+ * Wire a scheduler to a host-provided store + execution backend and restore
+ * persisted jobs. Returns a handle the host keeps for its lifetime. Prefers
+ * `runManager` when both are supplied (it gives run history).
+ */
+export declare function startAutomation(deps: StartAutomationDeps): AutomationHandle;
+export { CronScheduler, cronScheduler, type CronJob } from "./scheduler.js";
+export { CronStore, defaultCronStorePath } from "./store.js";
+export { bindCronToEngine, bindCronToRunManager, type CronRunner, type CronRunRequest, type CronRunResult, type RunSubmitter, } from "./runner.js";
+export { isCronExpression, parseCronExpression, nextCronTime, type ParsedCron, } from "./cron-expr.js";
+export type { CronPermissionLevel, CreateJobOptions, UpdateJobPatch } from "./scheduler.js";
+export { resolveWritePolicy, wrapUntrustedInput, type WritePolicy, } from "./write-policy.js";
+export { runWriteJobInWorktree, type WriteJobGitOps, type RunWriteJobInput, type RunWriteJobResult, } from "./write-run.js";

package/dist/automation/index.js

@@ -0,0 +1,39 @@
+/**
+ * automation/ — zero-environment-dependency scheduling module.
+ *
+ * Hosts (Electron main, future CLI server) load this module and inject their
+ * own store + runner. The module imports nothing from Electron/Ink and makes
+ * no GUI/TTY assumptions, so the same code runs in any host
+ * (docs/automation-plan-2026-05-31.md, D1).
+ */
+import { CronScheduler } from "./scheduler.js";
+import { bindCronToEngine, bindCronToRunManager, } from "./runner.js";
+/**
+ * Wire a scheduler to a host-provided store + execution backend and restore
+ * persisted jobs. Returns a handle the host keeps for its lifetime. Prefers
+ * `runManager` when both are supplied (it gives run history).
+ */
+export function startAutomation(deps) {
+    const scheduler = new CronScheduler(deps.store);
+    if (deps.runManager) {
+        bindCronToRunManager(scheduler, deps.runManager);
+    }
+    else if (deps.runner) {
+        bindCronToEngine(scheduler, deps.runner);
+    }
+    else {
+        throw new Error("startAutomation requires either a runner or a runManager");
+    }
+    scheduler.loadJobs();
+    return {
+        scheduler,
+        stop: () => scheduler.stopAll(),
+    };
+}
+// Re-export the building blocks so hosts import everything from one place.
+export { CronScheduler, cronScheduler } from "./scheduler.js";
+export { CronStore, defaultCronStorePath } from "./store.js";
+export { bindCronToEngine, bindCronToRunManager, } from "./runner.js";
+export { isCronExpression, parseCronExpression, nextCronTime, } from "./cron-expr.js";
+export { resolveWritePolicy, wrapUntrustedInput, } from "./write-policy.js";
+export { runWriteJobInWorktree, } from "./write-run.js";

package/dist/automation/runner.d.ts

@@ -0,0 +1,84 @@
+/**
+ * cron-runtime — wire the CronScheduler's executor to a real run backend.
+ *
+ * B1 fix: `CronScheduler.setExecutor` was never called in production, so cron
+ * jobs were created and ticked but did nothing on fire. `bindCronToEngine`
+ * installs an executor that, for each fired job, hands a one-shot headless run
+ * request to the caller-supplied `runner`.
+ *
+ * Security contract: cron runs unattended, so each job's permission tier
+ * (`job.permissionLevel`) is resolved through `resolveWritePolicy`, which maps
+ * the tier to a permissionMode + approval backend (see write-policy.ts). The
+ * mode stays "default" so the classifier doesn't add its own acceptEdits
+ * auto-allow rules ahead of the backend — the backend is the single source of
+ * truth for what a tier permits. An undefined/unknown tier falls back to the
+ * read-only backend.
+ */
+import type { CronJob } from "./scheduler.js";
+import type { CronScheduler } from "./scheduler.js";
+import type { PermissionMode } from "../types.js";
+import type { ApprovalBackend } from "../tool-system/permission.js";
+import type { SandboxMode } from "../tool-system/sandbox/index.js";
+/** What the executor hands to the run backend for one fired job. */
+export interface CronRunRequest {
+    job: CronJob;
+    /** The prompt to run — `job.prompt`, surfaced for convenience. */
+    prompt: string;
+    /** Permission mode the run must use (see security contract above). */
+    permissionMode: PermissionMode;
+    /** Approval backend the run must install (resolved from the job's tier). */
+    approvalBackend: ApprovalBackend;
+    /** Sandbox mode the run should confine writes/shell to (resolved from the
+     *  job's tier). The host runner must forward this to `Engine({ sandbox })`
+     *  so even a `full` tier can't escape the workspace — defense in depth on
+     *  top of the approval backend. */
+    sandboxMode: SandboxMode;
+    /** Abort signal for the run — tripped by `CronScheduler.abort(jobId)` when
+     *  the run must be cancelled mid-flight (e.g. the user deletes its session
+     *  while it's still executing). Forward to `Engine.run({ signal })`. */
+    signal?: AbortSignal;
+}
+export interface CronRunResult {
+    text: string;
+    reason: string;
+    /**
+     * When present, this fire hit a PERMANENT failure that will recur every tick
+     * (e.g. a `resumeSessionId` whose session was deleted). The scheduler should
+     * auto-disable the job with `stop.reason` rather than silently retrying
+     * forever. Absent = transient/normal outcome; keep scheduling.
+     */
+    stop?: {
+        reason: string;
+    };
+}
+/** The pluggable run backend. Production wires this to a headless Engine run;
+ *  tests pass a stub. Phase 5 will swap this for a RunManager.submit() path. */
+export type CronRunner = (req: CronRunRequest) => Promise<CronRunResult>;
+/**
+ * Install the cron executor. After this call, a fired job invokes `runner`
+ * with a run request whose permission tier comes from the job. A thrown error
+ * is logged (`logCronFailure`) and re-thrown so the scheduler's catch records
+ * stats and keeps ticking — one transient bad run never stops future ticks. A
+ * PERMANENT failure the runner flags via `result.stop` (e.g. a resume target
+ * whose session was deleted) auto-disables the job with that reason, so it
+ * stops silently retrying forever.
+ */
+export declare function bindCronToEngine(scheduler: CronScheduler, runner: CronRunner): void;
+/** Minimal structural view of RunManager.submit the executor needs. */
+export interface RunSubmitter {
+    submit(input: {
+        objective: string;
+        cwd?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<{
+        runId: string;
+    }>;
+}
+/**
+ * Wire the scheduler to submit each fired job into a RunManager. Records the
+ * resulting runId back onto the job (`lastRunId`) so the UI can link a job to
+ * its latest run in the RunStore. Read-only is enforced at the RunManager level
+ * by the host injecting `approvalBackend: HeadlessApprovalBackend("approve-read-only")`
+ * into createRunManager (Phase 2) until sandbox+write tiers land (Phase 4/5).
+ */
+export declare function bindCronToRunManager(scheduler: CronScheduler, runManager: RunSubmitter): void;