@skastr0/prism-linux-x64 0.5.1 → 0.8.0

package/types/workflow-harness-detection.d.ts

@@ -35,11 +35,9 @@ export interface WorkflowHarnessDetectionSpec {
     readonly envVar: string;
     readonly probeArgs: ReadonlyArray<string>;
     /**
-     * Cheap-fast-tier model used by `resolveWorkflowTaskModel` when a task
-     * declares this harness but nothing (task, profile, or CLI --model) supplies
-     * a concrete model. Chosen from the empirical modelspace's throughput/triage
-     * profiles (not the premium tier) so a scaffolded workflow never crashes at
-     * run with "no concrete model for workflow worker X".
+     * Documented cheap-fast slug for this harness. Detection/probes may cite it.
+     * Unpinned workflow tasks must omit the harness model flag so the user's
+     * harness default stays in force — do not feed this into spawn.
      */
     readonly defaultModel: string;
     /**
@@ -81,9 +79,8 @@ export interface WorkflowHarnessDetectionOptions {
 export declare const WORKFLOW_HARNESS_DETECTION_SPECS: Readonly<Record<WorkflowHarnessId, WorkflowHarnessDetectionSpec>>;
 export declare const isWorkflowHarnessId: (id: string) => id is WorkflowHarnessId;
 /**
- * Cheap-fast-tier default model for a workflow harness, or `undefined` for an
- * id outside the registry. Single source of truth for `resolveWorkflowTaskModel`
- * (src/workflows.ts) — do not hand-maintain a second per-harness default list.
+ * Documented cheap-fast slug for a workflow harness, or `undefined` outside
+ * the registry. Not applied to unpinned tasks — omit the spawn flag instead.
  */
 export declare const workflowHarnessDefaultModel: (harness: string) => string | undefined;
 /** Provider paired with `workflowHarnessDefaultModel` for provider-multiplexing harnesses (hermes). */

package/types/workflow-hermes-worker.d.ts

@@ -0,0 +1,28 @@
+import type { AnyWorkflowWorkerTask, WorkflowPermissionMode } from "./workflows.js";
+import type { WorkflowTaskExecution, WorkflowTaskProgressReporter, WorkflowTaskRepairLoopOption } from "./workflow-runner.js";
+export type HermesWorkflowWorkerOptions = {
+    readonly cwd: string;
+    readonly bin?: string;
+    readonly model?: string;
+    readonly provider?: string;
+    readonly profile?: string;
+    readonly effort?: string;
+    readonly resolvedPermission: WorkflowPermissionMode;
+    readonly abortSignal?: AbortSignal;
+    readonly reportProgress?: WorkflowTaskProgressReporter;
+} & WorkflowTaskRepairLoopOption<"hermes">;
+export declare class HermesWorkflowWorkerError extends Error {
+    readonly name = "HermesWorkflowWorkerError";
+    readonly metadata?: Record<string, unknown>;
+    constructor(message: string, metadata?: Record<string, unknown>);
+}
+export declare const buildHermesArgs: (input: {
+    readonly profile?: string;
+    readonly model?: string;
+    readonly provider?: string;
+    readonly effort?: string;
+    readonly prompt: string;
+    readonly resumeSessionId?: string;
+    readonly permission?: WorkflowPermissionMode;
+}) => ReadonlyArray<string>;
+export declare const runHermesWorkflowTask: (task: AnyWorkflowWorkerTask, options: HermesWorkflowWorkerOptions) => Promise<WorkflowTaskExecution>;

package/types/workflow-identity.d.ts

@@ -1,4 +1,6 @@
 import { type AnyWorkflowTask, type WorkflowSessionPersistence, type WorkflowRuntimeOptions } from "./workflows.js";
+import { type JevQuestions, type JevEntry } from "./jev.js";
+import type { JevPublicConfig } from "./services/jev.js";
 /**
  * `cacheKey` and `promptHash` AND together in the cache primary key
  * (workflow-store.ts) — `cacheKey` never substitutes for `promptHash`, and
@@ -24,29 +26,56 @@ export interface WorkflowJudgeIdentity {
     readonly criterion: string;
     readonly cacheKey: string;
 }
-export interface WorkflowRunTaskSnapshot {
+interface WorkflowRunTaskSnapshotBase {
     readonly runId: string;
     readonly ordinal: number;
     readonly taskId: string;
     readonly phase?: string;
-    readonly prompt: string;
     readonly cacheKey: string;
     readonly promptHash: string;
+    readonly outputSchema?: unknown;
+    readonly createdAt: string;
+}
+export interface WorkflowWorkerRunTaskSnapshot extends WorkflowRunTaskSnapshotBase {
+    readonly kind: "workflow-task";
+    readonly prompt: string;
     readonly worker?: {
         readonly worker?: string;
         readonly model?: string;
         readonly profile?: string;
+        readonly effort?: string;
         readonly sessionPersistence?: WorkflowSessionPersistence;
     };
-    readonly outputSchema?: unknown;
     readonly finishCriteria: ReadonlyArray<string>;
-    readonly createdAt: string;
 }
-export declare const workflowTaskIdentity: (workflow: string, task: AnyWorkflowTask, runtimeOptions?: WorkflowRuntimeOptions) => WorkflowTaskIdentity;
+/**
+ * Persisted record of one native Jev decision: the exact request that was
+ * identity-hashed and executed, with the effective (non-secret) endpoint and
+ * model. Never contains the API key.
+ */
+export interface JevRunTaskSnapshot extends WorkflowRunTaskSnapshotBase {
+    readonly kind: "jev";
+    readonly request: {
+        readonly state: JevEntry;
+        readonly questions: JevQuestions;
+        readonly model: string;
+        readonly baseURL: string;
+    };
+}
+export type WorkflowRunTaskSnapshot = WorkflowWorkerRunTaskSnapshot | JevRunTaskSnapshot;
+/**
+ * Distributive snapshot-input union. Plain `Omit<Union, "createdAt">` would
+ * collapse variant-specific properties (`prompt`, `request`), so each
+ * variant's input form is spelled out.
+ */
+export type WorkflowRunTaskSnapshotInput = Omit<WorkflowWorkerRunTaskSnapshot, "createdAt"> | Omit<JevRunTaskSnapshot, "createdAt">;
+export declare const workflowTaskIdentity: (workflow: string, task: AnyWorkflowTask, runtimeOptions?: WorkflowRuntimeOptions, jev?: JevPublicConfig) => WorkflowTaskIdentity;
 export declare const workflowRunTaskSnapshotForTask: (input: {
     readonly runId: string;
     readonly ordinal: number;
     readonly workflow: string;
     readonly task: AnyWorkflowTask;
     readonly runtimeOptions?: WorkflowRuntimeOptions;
-}) => Omit<WorkflowRunTaskSnapshot, "createdAt">;
+    readonly jev?: JevPublicConfig;
+}) => WorkflowRunTaskSnapshotInput;
+export {};

package/types/workflow-kimi-effort.d.ts

@@ -0,0 +1,17 @@
+export declare const kimiCodeHome: (home?: string) => string;
+export type KimiModelEffortSupport = {
+    readonly declared: false;
+} | {
+    readonly declared: true;
+    readonly efforts: readonly string[];
+} | {
+    readonly error: string;
+};
+/** Read one model's optional support_efforts entry from Kimi's config TOML. */
+export declare const parseKimiModelEffortSupport: (source: string, model: string, configPath?: string) => KimiModelEffortSupport;
+/** Validate Kimi's optional model-specific ladder after checking the fixed union. */
+export declare const validateKimiWorkflowEffort: (input: {
+    readonly model?: string;
+    readonly effort?: string;
+    readonly kimiHome?: string;
+}) => string | undefined;

package/types/workflow-kimi-worker.d.ts

@@ -0,0 +1,27 @@
+import type { AnyWorkflowWorkerTask, WorkflowPermissionMode } from "./workflows.js";
+import type { WorkflowTaskExecution, WorkflowTaskProgressReporter, WorkflowTaskRepairLoopOption } from "./workflow-runner.js";
+export type KimiWorkflowWorkerOptions = {
+    readonly cwd: string;
+    readonly bin?: string;
+    readonly model?: string;
+    readonly effort?: string;
+    readonly kimiHome?: string;
+    readonly resolvedPermission: WorkflowPermissionMode;
+    readonly abortSignal?: AbortSignal;
+    readonly reportProgress?: WorkflowTaskProgressReporter;
+} & WorkflowTaskRepairLoopOption<"kimi-code">;
+export declare class KimiWorkflowWorkerError extends Error {
+    readonly name = "KimiWorkflowWorkerError";
+    readonly metadata?: Record<string, unknown>;
+    constructor(message: string, metadata?: Record<string, unknown>);
+}
+export declare const isKimiAuthOutput: (output: string) => boolean;
+export declare const kimiSessionIdFromStream: (stdout: string) => string | undefined;
+export declare const buildKimiArgs: (input: {
+    readonly model?: string;
+    readonly prompt: string;
+    readonly skillsDir?: string;
+    readonly sessionId?: string;
+    readonly permission?: WorkflowPermissionMode;
+}) => ReadonlyArray<string>;
+export declare const runKimiWorkflowTask: (task: AnyWorkflowWorkerTask, options: KimiWorkflowWorkerOptions) => Promise<WorkflowTaskExecution>;

package/types/workflow-omp-worker.d.ts

@@ -0,0 +1,49 @@
+import type { AnyWorkflowWorkerTask, WorkflowPermissionMode, WorkflowSessionPersistence } from "./workflows.js";
+import type { WorkflowTaskExecution, WorkflowTaskProgressReporter, WorkflowTaskRepairLoopOption } from "./workflow-runner.js";
+export type OmpWorkflowWorkerOptions = {
+    readonly cwd: string;
+    readonly bin?: string;
+    readonly model?: string;
+    readonly provider?: string;
+    readonly profile?: string;
+    readonly effort?: string;
+    readonly sessionPersistence?: WorkflowSessionPersistence;
+    readonly resolvedPermission: WorkflowPermissionMode;
+    readonly restrictedTools?: readonly string[];
+    readonly abortSignal?: AbortSignal;
+    readonly reportProgress?: WorkflowTaskProgressReporter;
+} & WorkflowTaskRepairLoopOption<"omp">;
+export declare class OmpWorkflowWorkerError extends Error {
+    readonly name = "OmpWorkflowWorkerError";
+    readonly metadata?: Record<string, unknown>;
+    constructor(message: string, metadata?: Record<string, unknown>);
+}
+/** Console Go selectors 400 in workflow `--print` (no `x-opencode-session`). */
+export declare const OMP_CONSOLE_GO_PREFIX = "opencode-go/";
+export declare const ompConsoleGoPinError: (model: string) => string;
+export declare const assertOmpWorkflowModel: (model: string | undefined) => void;
+type OmpWorkflowSessionArgs = {
+    readonly sessionPersistence?: "persistent";
+    readonly sessionId?: string;
+} | {
+    readonly sessionPersistence: "ephemeral";
+    readonly sessionId?: never;
+};
+export declare const buildOmpArgs: (input: {
+    readonly cwd: string;
+    readonly model?: string;
+    readonly provider?: string;
+    readonly profile?: string;
+    readonly effort?: string;
+    readonly prompt: string;
+    readonly permission?: WorkflowPermissionMode;
+    readonly restrictedTools?: readonly string[];
+} & OmpWorkflowSessionArgs) => ReadonlyArray<string>;
+export interface OmpJsonStreamResult {
+    readonly sessionId?: string;
+    readonly text: string;
+    readonly error?: string;
+}
+export declare const parseOmpJsonStream: (stdout: string) => OmpJsonStreamResult;
+export declare const runOmpWorkflowTask: (task: AnyWorkflowWorkerTask, options: OmpWorkflowWorkerOptions) => Promise<WorkflowTaskExecution>;
+export {};

package/types/workflow-opencode-worker.d.ts

@@ -0,0 +1,26 @@
+import type { AnyWorkflowWorkerTask, WorkflowPermissionMode } from "./workflows.js";
+import type { WorkflowTaskExecution, WorkflowTaskProgressReporter, WorkflowTaskRepairLoopOption } from "./workflow-runner.js";
+export type OpenCodeWorkflowWorkerOptions = {
+    readonly cwd: string;
+    readonly bin?: string;
+    readonly model?: string;
+    readonly resolvedPermission: WorkflowPermissionMode;
+    readonly abortSignal?: AbortSignal;
+    readonly reportProgress?: WorkflowTaskProgressReporter;
+} & WorkflowTaskRepairLoopOption<"opencode">;
+export declare class OpenCodeWorkflowWorkerError extends Error {
+    readonly name = "OpenCodeWorkflowWorkerError";
+    readonly metadata?: Record<string, unknown>;
+    constructor(message: string, metadata?: Record<string, unknown>);
+}
+/**
+ * OpenCode v2 `run` has no `--dir` (the process cwd is the project) and uses
+ * `--auto` instead of `--dangerously-skip-permissions`.
+ */
+export declare const buildOpenCodeArgs: (input: {
+    readonly model?: string;
+    readonly prompt: string;
+    readonly sessionId?: string;
+    readonly permission?: WorkflowPermissionMode;
+}) => ReadonlyArray<string>;
+export declare const runOpenCodeWorkflowTask: (task: AnyWorkflowWorkerTask, options: OpenCodeWorkflowWorkerOptions) => Promise<WorkflowTaskExecution>;

package/types/workflow-output-schema.d.ts

@@ -0,0 +1,6 @@
+import type { Schema } from "effect";
+import { WorkflowOutputSchemaError, type JsonSchema as WorkflowJsonSchema } from "./ast-to-json-schema.js";
+export { WorkflowOutputSchemaError };
+export type { WorkflowJsonSchema };
+export declare const workflowJsonSchemaFromEffectSchema: (schema: Schema.Top) => WorkflowJsonSchema;
+export declare const tryWorkflowJsonSchemaFromEffectSchema: (schema: Schema.Top) => WorkflowJsonSchema | undefined;

package/types/workflow-permissions.d.ts

@@ -0,0 +1,10 @@
+import type { WorkflowPermissionMode } from "./workflows.js";
+export declare const WORKFLOW_PERMISSION_MODES: readonly ["legacy", "permissive", "restricted", "interactive", "sandbox-read-only", "sandbox-workspace-write", "full-access"];
+export declare const isWorkflowPermissionMode: (value: string) => value is WorkflowPermissionMode;
+export declare const assertNeverWorkflowPermissionMode: (worker: string, mode: never) => never;
+export declare class WorkflowPermissionError extends Error {
+    readonly worker: string;
+    readonly mode: string;
+    readonly name = "WorkflowPermissionError";
+    constructor(worker: string, mode: string, message: string);
+}

package/types/workflow-process-guard.d.ts

@@ -0,0 +1,28 @@
+export interface WorkflowProcessGuardRequest {
+    readonly cwd: string;
+    readonly command: string;
+    readonly args: ReadonlyArray<string>;
+}
+export declare class WorkflowProcessGuardError extends Error {
+    readonly name = "WorkflowProcessGuardError";
+}
+export declare const encodeWorkflowProcessGuardRequest: (request: WorkflowProcessGuardRequest) => ReadonlyArray<string>;
+export declare const decodeWorkflowProcessGuardRequest: (encodedCwd: string, encodedCommand: string, encodedArgs: ReadonlyArray<string>) => WorkflowProcessGuardRequest;
+export declare const workflowProcessGroupExists: (pid: number) => boolean;
+export declare const waitForWorkflowProcessGroupAbsence: (pid: number, timeoutMs: number) => Promise<boolean>;
+export interface WorkflowProcessGroupTerminationResult {
+    readonly escalated: boolean;
+    readonly alreadyAbsent: boolean;
+}
+export interface WorkflowProcessGroupTerminationOptions {
+    readonly termGraceMs?: number;
+    readonly killConfirmationMs?: number;
+    readonly onEscalated?: () => void;
+}
+export declare const terminateWorkflowProcessGroup: (pid: number, options?: WorkflowProcessGroupTerminationOptions) => Promise<WorkflowProcessGroupTerminationResult>;
+/**
+ * Own a detached workload process group for exactly as long as the caller keeps
+ * this guard's stdin open. Every shutdown cause shares the same bounded group
+ * termination and direct-child reap operation.
+ */
+export declare const runWorkflowProcessGuard: (request: WorkflowProcessGuardRequest) => Promise<number>;

package/types/workflow-runner.d.ts

@@ -1,4 +1,5 @@
-import { type AnyWorkflowDefinition, type AnyWorkflowTask, type WorkflowRuntimeOptions } from "./workflows.js";
+import { type AnyWorkflowDefinition, type AnyWorkflowTask, type AnyWorkflowWorkerTask, type WorkflowRuntimeOptions } from "./workflows.js";
+import type { JevPublicConfig } from "./services/jev.js";
 import type { WorkflowStore } from "./workflow-store.js";
 import { type WorkflowRepairLoopContinuationWorkerId, type WorkflowStableSession } from "./workflow-session.js";
 export interface WorkflowTaskExecution {
@@ -55,6 +56,12 @@ export type WorkflowTaskRepairLoopOption<Worker extends string> = Worker extends
     readonly repair?: never;
 };
 export type WorkflowTaskExecutor = (task: AnyWorkflowTask, context?: WorkflowTaskExecutionContext) => Promise<unknown | WorkflowTaskExecution>;
+/**
+ * The worker-shaped half of {@link WorkflowTaskExecutor}: worker adapters and
+ * the mock-output path only ever receive workflow worker tasks. Jev tasks are
+ * dispatched separately by kind (see workflow-executors.ts).
+ */
+export type WorkflowWorkerTaskExecutor = (task: AnyWorkflowWorkerTask, context?: WorkflowTaskExecutionContext) => Promise<unknown | WorkflowTaskExecution>;
 /**
  * Internal scheduler pacing, not a budget: excess live tasks queue and run as
  * slots free, so this never fails a task. Sized to the machine because each
@@ -62,11 +69,18 @@ export type WorkflowTaskExecutor = (task: AnyWorkflowTask, context?: WorkflowTas
  * about a workflow's intent belongs in this number.
  */
 export declare const WORKFLOW_TASK_CONCURRENCY: number;
+/**
+ * Jev tasks are one HTTP call (not a harness process), so they run on a
+ * separate, wider run-scoped limiter than worker tasks. Same semantics: queue,
+ * never fail.
+ */
+export declare const WORKFLOW_JEV_CONCURRENCY = 32;
 export declare const runWorkflow: (workflow: AnyWorkflowDefinition, options: {
     readonly executeTask: WorkflowTaskExecutor;
     readonly store?: WorkflowStore;
     readonly mockOutput?: boolean;
     readonly runId?: string;
     readonly runtimeOptions?: WorkflowRuntimeOptions;
+    readonly jev?: JevPublicConfig;
     readonly abortSignal?: AbortSignal;
 }) => Promise<WorkflowRunResult>;

package/types/workflow-scheduler/cron.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Effect's `Cron` module, narrowed to Prism's scheduling dialect.
+ *
+ * Prism ships no cron parser. `effect`'s `Cron` already implements the
+ * five-field dialect Prism documents — names, ranges, steps, lists, Vixie
+ * DOM/DOW OR semantics, named timezones, and DST resolution — and it is
+ * already a Prism-owned dependency pinned to one exact release by
+ * `scripts/effect-version-guard.ts`. Re-deriving a parser here would be a
+ * second implementation of the same contract, which AGENTS.md rule 3 forbids.
+ *
+ * This module is the adapter that *pins the dialect Prism accepts*, so the
+ * accepted language lives in one place instead of being whatever the
+ * dependency happens to accept today. Two deliberate narrowings, both
+ * fail-closed:
+ *
+ *   - **Exactly five fields.** `Cron.parse` also accepts a six-field,
+ *     seconds-first form. A six-field expression is rejected so an expression
+ *     copied from a seconds-capable scheduler cannot silently mean something
+ *     else than it reads.
+ *   - **Named timezones only.** `Cron.parse` accepts fixed offsets such as
+ *     `+03:00`. A fixed offset is not DST-aware, so a schedule declared with
+ *     one drifts by an hour at a transition. A named IANA zone — including the
+ *     DST-free `Etc/GMT+3` — is required.
+ *
+ * DST policy is inherited from `effect`'s `Cron` and pinned by `cron.test.ts`:
+ * a wall-clock time inside a spring-forward gap resolves to the first valid
+ * instant after the gap, and a time inside a fall-back fold resolves to the
+ * **first** of the two occurrences. That is a documented policy, not an
+ * accident of the dependency, so the tests assert it rather than assume it.
+ *
+ * Only `next` is exposed. Prism never asks "what was the previous occurrence?"
+ * because the durable cursor is the schedule row's `next_due_at` — see
+ * `docs/workflow-scheduling.md`. `Cron.prev` is also subtly exclusive at exact
+ * minute boundaries, which makes it the wrong primitive for "the occurrence
+ * that is due now".
+ */
+import { Cron } from "effect";
+/** The field count Prism accepts. Six-field (seconds-first) expressions are rejected. */
+export declare const WORKFLOW_CRON_FIELD_COUNT = 5;
+export interface ParsedWorkflowCron {
+    readonly expression: string;
+    readonly timezone: string;
+    /** The parsed `effect` `Cron`, ready for `Cron.next`. */
+    readonly cron: Cron.Cron;
+}
+/**
+ * Validate a cron expression + timezone pair, returning the parsed schedule.
+ *
+ * Throws `WorkflowScheduleError` — never a bare string or a dependency's error
+ * type — so every rejection carries the field, a headline, and the exact fix.
+ */
+export declare const parseWorkflowCron: (expression: string, timezone: string) => ParsedWorkflowCron;
+/**
+ * The first occurrence strictly after `afterMs`.
+ *
+ * `Cron.next` is exclusive of its argument, which is what the tick algorithm
+ * needs: advancing the cursor from a consumed occurrence must never re-yield
+ * that same occurrence.
+ */
+export declare const nextWorkflowCronOccurrence: (schedule: ParsedWorkflowCron, afterMs: number) => number;

package/types/workflow-scheduler/errors.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Scheduler error vocabulary.
+ *
+ * These are `Schema.TaggedError`s rather than plain `Error`s for two reasons:
+ * every one of them is both a typed Effect failure *and* a durable record (a
+ * scheduler event, an execution's `cause_json`), and `message` is an explicit
+ * schema field so the rendered headline survives a round trip through SQLite.
+ * `Schema.TaggedError`'s optional third-argument message function is not used
+ * because it does not take effect in this Effect release; carrying `message`
+ * as a field keeps the rendered text identical before and after persistence.
+ *
+ * `hint` is required, never optional: AGENTS.md rule 6 forbids warnings, so a
+ * failure that cannot name its own remediation does not belong here.
+ */
+import { Schema } from "effect";
+declare const WorkflowScheduleError_base: Schema.Class<WorkflowScheduleError, Schema.TaggedStruct<"WorkflowScheduleError", {
+    readonly message: Schema.String;
+    readonly field: Schema.String;
+    readonly hint: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** A declared schedule that Prism cannot accept. `field` is the offending key. */
+export declare class WorkflowScheduleError extends WorkflowScheduleError_base {
+}
+declare const WorkflowScheduleInstallError_base: Schema.Class<WorkflowScheduleInstallError, Schema.TaggedStruct<"WorkflowScheduleInstallError", {
+    readonly message: Schema.String;
+    readonly hint: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** A schedule installation or lifecycle operation Prism refuses to perform. */
+export declare class WorkflowScheduleInstallError extends WorkflowScheduleInstallError_base {
+}
+declare const SchedulerStoreError_base: Schema.Class<SchedulerStoreError, Schema.TaggedStruct<"SchedulerStoreError", {
+    readonly message: Schema.String;
+    readonly hint: Schema.String;
+    readonly path: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The scheduler store could not be opened, migrated, or read as expected. */
+export declare class SchedulerStoreError extends SchedulerStoreError_base {
+}
+declare const SchedulerAlreadyRunningError_base: Schema.Class<SchedulerAlreadyRunningError, Schema.TaggedStruct<"SchedulerAlreadyRunningError", {
+    readonly message: Schema.String;
+    readonly hint: Schema.String;
+    readonly holderInstanceId: Schema.NullOr<Schema.String>;
+    readonly holderPid: Schema.NullOr<Schema.Number>;
+}>, import("effect/Cause").YieldableError>;
+/** Another scheduler instance holds the machine-wide instance lock. */
+export declare class SchedulerAlreadyRunningError extends SchedulerAlreadyRunningError_base {
+}
+declare const SchedulerLaunchError_base: Schema.Class<SchedulerLaunchError, Schema.TaggedStruct<"SchedulerLaunchError", {
+    readonly message: Schema.String;
+    readonly hint: Schema.String;
+    readonly executionId: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** A worker process could not be launched, or its launch could not be authorized. */
+export declare class SchedulerLaunchError extends SchedulerLaunchError_base {
+}
+declare const SchedulerFatalError_base: Schema.Class<SchedulerFatalError, Schema.TaggedStruct<"SchedulerFatalError", {
+    readonly message: Schema.String;
+    readonly hint: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The scheduler loop itself hit an unrecoverable defect. The owner's contract
+ * is explicit that a scheduler defect must surface and end the process so the
+ * service manager restarts it — never be swallowed into an endlessly
+ * "healthy"-looking loop.
+ */
+export declare class SchedulerFatalError extends SchedulerFatalError_base {
+}
+export type SchedulerError = WorkflowScheduleError | WorkflowScheduleInstallError | SchedulerStoreError | SchedulerAlreadyRunningError | SchedulerLaunchError | SchedulerFatalError;
+/** One-line headline plus a `hint:` line — the repo's human error shape. */
+export declare const renderSchedulerError: (error: SchedulerError) => string;
+export {};

package/types/workflow-scheduler/schedule.d.ts

@@ -0,0 +1,61 @@
+/**
+ * The inert `schedule` declaration on a workflow definition.
+ *
+ * A workflow may declare how it wants to be scheduled; declaring it does
+ * nothing. `defineWorkflow` records the policy on the definition object and
+ * no more — importing, typechecking, validating, or running the file has no
+ * scheduling side effect whatsoever. Registration happens only through
+ * `prism workflow schedule install`, which reads the declaration back out of
+ * the loaded definition. This split is what makes `install` the single
+ * activation gate, and it is why a schedule edit requires a reinstall while a
+ * task/prompt edit does not.
+ *
+ * **Only implemented policies are representable.** `overlap` and `missedRuns`
+ * each admit exactly one value, so `overlap: "queue"` is a TypeScript error at
+ * authoring time and a hard, self-explaining `WorkflowScheduleError` at the
+ * cross-version boundary. AGENTS.md rule 6 forbids warnings, and rule 8 says a
+ * type that needs a runtime membership check is lying — so the unions stay
+ * closed rather than admitting a policy Prism does not implement.
+ *
+ * The two policies, stated precisely, because both names are easy to misread:
+ *
+ *   - `overlap: "skip"` — at most one unresolved execution per schedule. A due
+ *     occurrence that arrives while the previous execution is still running,
+ *     still reserving, or still *uncertain* is consumed as a skip and
+ *     recorded; it is never queued and never run in parallel. A stranded
+ *     execution cannot be cleared by a timeout, only by evidence.
+ *   - `missedRuns: "skip"` — overdue occurrences are coalesced into at most one
+ *     opportunity. A machine asleep for three hours produces one run on wake, not
+ *     eighteen, and a scheduler restart behaves the same way rather than silently
+ *     swallowing an occurrence. Nothing accumulates: the cursor advances whether
+ *     or not the run succeeds, so a crash-loop fires at most once per occurrence.
+ */
+/** Policies Prism implements for a due occurrence that overlaps a live execution. */
+export declare const WORKFLOW_SCHEDULE_OVERLAP_POLICIES: readonly ["skip"];
+export type WorkflowScheduleOverlap = (typeof WORKFLOW_SCHEDULE_OVERLAP_POLICIES)[number];
+/** Policies Prism implements for occurrences that passed while nothing was watching. */
+export declare const WORKFLOW_SCHEDULE_MISSED_RUN_POLICIES: readonly ["skip"];
+export type WorkflowScheduleMissedRuns = (typeof WORKFLOW_SCHEDULE_MISSED_RUN_POLICIES)[number];
+export interface WorkflowSchedule {
+    /** Five-field cron: `minute hour day-of-month month day-of-week`. */
+    readonly cron: string;
+    /** A named IANA timezone. Fixed UTC offsets are rejected; see `cron.ts`. */
+    readonly timezone: string;
+    readonly overlap: WorkflowScheduleOverlap;
+    readonly missedRuns: WorkflowScheduleMissedRuns;
+}
+/** The complete key set. An unrecognized key is an error, not an ignored field. */
+export declare const WORKFLOW_SCHEDULE_KEYS: ReadonlyArray<keyof WorkflowSchedule>;
+/**
+ * Validate an already-loaded `schedule` value and return it typed.
+ *
+ * Used twice on purpose: `defineWorkflow` calls it so an authoring mistake
+ * fails at import with the file in front of the author, and
+ * `prism workflow schedule install` calls it again because an installed
+ * schedule is data that crossed a boundary (a hand-written object, or a
+ * definition produced by a different Prism version) and must not be trusted
+ * just because some other layer once checked it.
+ */
+export declare const parseWorkflowSchedule: (value: unknown) => WorkflowSchedule;
+/** Non-throwing form for the `isWorkflowDefinition` type guard. */
+export declare const isWorkflowSchedule: (value: unknown) => value is WorkflowSchedule;