@skastr0/prism-linux-x64 0.5.1 → 0.7.1

package/types/services/jev.d.ts

@@ -0,0 +1,131 @@
+/**
+ * JevClient — the Effect service behind first-class Jev (TypeSafe System One)
+ * decisions in Prism workflows and Prism tools (GLYPH-JEV-03).
+ *
+ * One implementation serves both surfaces: the workflow runner's native Jev
+ * executor (src/workflow-jev.ts) and the compiled `jev/systemone_ask` tool
+ * (~/prism-plugins/jev) call this service; nothing else knows the SDK exists.
+ *
+ * Design contract:
+ * - Credentials and endpoints are captured once, when the layer is built.
+ *   `JevClientLive` reads TYPESAFE_API_KEY / TYPESAFE_BASE_URL /
+ *   TYPESAFE_DEFAULT_MODEL; `JevClientWith` takes explicit options and never
+ *   consults the environment.
+ * - The TypeSafeClient is constructed lazily on the first live call, because
+ *   its constructor throws when the API key is missing. Importing this module,
+ *   compiling plugins, validating workflows, and replaying cached outputs must
+ *   never require credentials.
+ * - The SDK owns transport retry (408/429/5xx, backoff, Retry-After). Prism
+ *   adds no second retry layer; `timeoutMs` is per HTTP attempt, matching the
+ *   SDK.
+ * - SDK logging is forced off: SDK debug logs can include request/response
+ *   bodies, i.e. workflow state. Prism telemetry is the bounded channel.
+ * - `APIUserAbortError` maps to Effect interruption (the only abort source is
+ *   the Effect-provided signal); every other SDK error maps to a tagged
+ *   `JevError.kind`. Raw SDK errors are never rethrown or serialized — they
+ *   can carry response bodies.
+ * - Pre-flight budget guard: requests estimated above
+ *   `JEV_TOKEN_REQUEST_TARGET` fail `kind: "request"` with a chunking hint
+ *   instead of a raw API 400 — agent callers can act on that message.
+ */
+import { Context, Effect, Layer, Schema } from "effect";
+import { type Fetch as SdkFetch, type RetryPolicy as SdkRetryPolicy } from "@typesafe-ai/sdk";
+import { type JevAnswers, type JevQuestions, type JevRequest, type JevResult, type JevUsage } from "../jev.js";
+export declare const JEV_ERROR_KINDS: readonly ["configuration", "request", "authentication", "permission", "rate-limit", "timeout", "connection", "http", "protocol"];
+/**
+ * - `configuration`: missing/invalid client configuration (missing API key).
+ * - `request`: the request itself was rejected — local validation, the
+ *   pre-flight token-budget guard, or API 400/422.
+ * - `authentication` / `permission`: API 401/403.
+ * - `rate-limit`: API 429 (carries `retryAfterMs` when the server sent one).
+ * - `timeout` / `connection`: transport failures after SDK retries exhaust.
+ * - `http`: any other non-2xx API error, including exhausted 5xx.
+ * - `protocol`: a nominally successful response failed the request-correlated
+ *   result contract (malformed envelope, answer/key mismatch). Terminal and
+ *   never repairable by re-asking the model.
+ */
+export type JevErrorKind = (typeof JEV_ERROR_KINDS)[number];
+declare const JevError_base: Schema.Class<JevError, Schema.TaggedStruct<"JevError", {
+    readonly kind: Schema.Literals<readonly ["configuration", "request", "authentication", "permission", "rate-limit", "timeout", "connection", "http", "protocol"]>;
+    readonly message: Schema.String;
+    readonly status: Schema.optionalKey<Schema.Number>;
+    readonly retryAfterMs: Schema.optionalKey<Schema.Number>;
+    readonly sdkErrorName: Schema.optionalKey<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+export declare class JevError extends JevError_base {
+}
+/** Replacement text for a scrubbed credential. */
+export declare const JEV_REDACTED_SECRET = "[redacted]";
+/**
+ * Redact exact occurrences of each known secret from outward diagnostic text.
+ * SDK error messages carry server-provided text verbatim (`APIError.describe`
+ * copies the response body's error/message/detail), and an upstream
+ * diagnostic can echo the Authorization header back — so every JevError that
+ * leaves the service boundary is scrubbed with the configured credential.
+ * Secrets shorter than 8 characters are skipped: redacting a tiny needle
+ * would mangle prose, and real credentials are never that short.
+ */
+export declare const redactJevSecrets: (text: string, secrets: ReadonlyArray<string | undefined>) => string;
+/** Non-secret resolved configuration, safe for identity hashing and logs. */
+export interface JevPublicConfig {
+    readonly baseURL: string;
+    readonly defaultModel: string;
+}
+export interface JevCallOptions {
+    /** Per-HTTP-attempt timeout override, passed through to the SDK. */
+    readonly timeoutMs?: number;
+}
+export interface JevClientShape {
+    readonly config: JevPublicConfig;
+    readonly systemOne: <const Q extends JevQuestions>(request: JevRequest<Q>, options?: JevCallOptions) => Effect.Effect<JevResult<Q>, JevError>;
+}
+/**
+ * Resolve the non-secret Jev configuration (base URL + default model) without
+ * touching the API key. Identity hashing, workflow snapshots, and the CLI use
+ * this so a jev task's cache identity is computable without credentials.
+ */
+export type JevEnvLike = {
+    readonly TYPESAFE_BASE_URL?: string | undefined;
+    readonly TYPESAFE_DEFAULT_MODEL?: string | undefined;
+    readonly [key: string]: string | undefined;
+};
+export declare const resolveJevPublicConfig: (env?: JevEnvLike) => JevPublicConfig;
+declare const JevClient_base: Context.ServiceClass<JevClient, "prism/JevClient", JevClientShape>;
+export declare class JevClient extends JevClient_base {
+}
+export type JevClientService = JevClient["Service"];
+export interface JevClientOptions {
+    readonly apiKey?: string;
+    readonly baseURL?: string;
+    readonly defaultModel?: string;
+    readonly fetch?: SdkFetch;
+    /** SDK retry override (transport-level only). */
+    readonly retry?: Partial<SdkRetryPolicy>;
+    /** SDK per-attempt timeout override in milliseconds. */
+    readonly timeoutMs?: number;
+}
+/**
+ * Live layer: captures the TYPESAFE_* environment once at build; the API key
+ * is only required when a live call is made.
+ */
+export declare const JevClientLive: Layer.Layer<JevClient>;
+/**
+ * Explicit-config layer; never reads environment variables. Missing optional
+ * settings fall back to documented non-secret defaults.
+ */
+export declare const JevClientWith: (options: JevClientOptions) => Layer.Layer<JevClient>;
+export interface JevClientTestOptions {
+    readonly model?: string;
+    readonly usage?: JevUsage;
+    /** Override the public config observed by identity/telemetry code. */
+    readonly config?: JevPublicConfig;
+}
+/**
+ * Stub layer for tests: answers a registered questions contract from memory.
+ * The registered answers are validated at construction against the real
+ * result codec, so a malformed stub fails the test that wrote it, not the
+ * system under test. Calls with a different questions map fail
+ * `kind: "request"`. Never touches network or environment.
+ */
+export declare const JevClientTest: <const Q extends JevQuestions>(questions: Q, answers: JevAnswers<Q>, options?: JevClientTestOptions) => Layer.Layer<JevClient>;
+export {};

package/types/types.d.ts

@@ -1,7 +1,7 @@
 /**
  * Core types for prism - the unified plugin distribution system
  */
-export type HarnessId = "claude-code" | "opencode" | "opencode2" | "openclaw" | "hermes" | "codex-cli" | "antigravity-cli" | "kimi-code" | "amp-code" | "cursor" | "factory-droid" | "pi" | "omp" | "grok" | "devin";
+export type HarnessId = "claude-code" | "opencode" | "opencode2" | "openclaw" | "hermes" | "codex-cli" | "antigravity-cli" | "kimi-code" | "amp-code" | "amp-orb" | "cursor" | "factory-droid" | "pi" | "omp" | "grok" | "devin";
 export declare const HARNESS_SCOPES: readonly ["global", "project"];
 export type HarnessScope = (typeof HARNESS_SCOPES)[number];
 export interface HarnessConfig {
@@ -146,6 +146,7 @@ export interface UnifiedFrontmatter {
     "antigravity-cli"?: Record<string, unknown>;
     "kimi-code"?: Record<string, unknown>;
     "amp-code"?: Record<string, unknown>;
+    "amp-orb"?: Record<string, unknown>;
     cursor?: CursorFrontmatter;
     "factory-droid"?: FactoryDroidFrontmatter;
     pi?: Record<string, unknown>;

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-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,55 @@ 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 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-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;

package/types/workflow-session.d.ts

@@ -1,30 +1,37 @@
 import { Schema } from "effect";
-export declare const WorkflowContinuationAdapterIdSchema: Schema.Literal<["amp-code", "antigravity-cli", "claude-code", "codex-cli", "cursor", "devin", "grok-cli", "hermes", "kimi-code", "opencode-cli", "opencode2-cli", "omp-cli"]>;
+export declare const WorkflowContinuationAdapterIdSchema: Schema.Literals<readonly ["amp-code", "antigravity-cli", "claude-code", "codex-cli", "cursor", "devin", "grok-cli", "hermes", "kimi-code", "opencode-cli", "opencode2-cli", "omp-cli"]>;
 export type WorkflowContinuationAdapterId = typeof WorkflowContinuationAdapterIdSchema.Type;
-export declare const WorkflowContinuationWorkerIdSchema: Schema.Literal<["amp-code", "antigravity-cli", "claude-code", "codex-cli", "cursor", "devin", "grok", "hermes", "kimi-code", "opencode", "opencode2", "omp"]>;
+/**
+ * Workflow workers that can continue a session.
+ *
+ * Derived from the `workflowWorker` bit in lowerer-capabilities.ts — the single
+ * harness enumeration — rather than re-listed here, which is what
+ * scripts/harness-enumeration-guard.ts enforces.
+ */
+export declare const WorkflowContinuationWorkerIdSchema: Schema.Literals<readonly import("./lowerer-capabilities.js").WorkflowWorkerHarnessId[]>;
 export type WorkflowContinuationWorkerId = typeof WorkflowContinuationWorkerIdSchema.Type;
-export declare const StableSessionIdSchema: Schema.brand<typeof Schema.NonEmptyTrimmedString, "StableSessionId">;
+export declare const StableSessionIdSchema: Schema.brand<Schema.NonEmptyString, "StableSessionId">;
 export type StableSessionId = typeof StableSessionIdSchema.Type;
 export declare const WorkflowStableSessionSchema: Schema.Struct<{
-    adapter: Schema.Literal<["amp-code", "antigravity-cli", "claude-code", "codex-cli", "cursor", "devin", "grok-cli", "hermes", "kimi-code", "opencode-cli", "opencode2-cli", "omp-cli"]>;
-    sessionId: Schema.brand<typeof Schema.NonEmptyTrimmedString, "StableSessionId">;
+    readonly adapter: Schema.Literals<readonly ["amp-code", "antigravity-cli", "claude-code", "codex-cli", "cursor", "devin", "grok-cli", "hermes", "kimi-code", "opencode-cli", "opencode2-cli", "omp-cli"]>;
+    readonly sessionId: Schema.brand<Schema.NonEmptyString, "StableSessionId">;
 }>;
 export type WorkflowStableSession = typeof WorkflowStableSessionSchema.Type;
-export declare const WorkflowHarnessContinuationSupportSchema: Schema.Union<[Schema.Struct<{
-    adapter: Schema.Literal<["amp-code", "antigravity-cli", "claude-code", "codex-cli", "cursor", "devin", "grok-cli", "hermes", "kimi-code", "opencode-cli", "opencode2-cli", "omp-cli"]>;
-    workflowWorker: typeof Schema.Boolean;
-    stableSessionIds: Schema.Literal<[true]>;
-    exactSameSessionContinuation: Schema.Literal<[true]>;
-    sessionIdField: Schema.Literal<["sessionId"]>;
-    continueCommand: typeof Schema.NonEmptyTrimmedString;
-    capture: typeof Schema.NonEmptyTrimmedString;
+export declare const WorkflowHarnessContinuationSupportSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly adapter: Schema.Literals<readonly ["amp-code", "antigravity-cli", "claude-code", "codex-cli", "cursor", "devin", "grok-cli", "hermes", "kimi-code", "opencode-cli", "opencode2-cli", "omp-cli"]>;
+    readonly workflowWorker: Schema.Boolean;
+    readonly stableSessionIds: Schema.Literal<true>;
+    readonly exactSameSessionContinuation: Schema.Literal<true>;
+    readonly sessionIdField: Schema.Literal<"sessionId">;
+    readonly continueCommand: Schema.NonEmptyString;
+    readonly capture: Schema.NonEmptyString;
 }>, Schema.Struct<{
-    adapter: Schema.Literal<["amp-code", "antigravity-cli", "claude-code", "codex-cli", "cursor", "devin", "grok-cli", "hermes", "kimi-code", "opencode-cli", "opencode2-cli", "omp-cli"]>;
-    workflowWorker: typeof Schema.Boolean;
-    stableSessionIds: Schema.Literal<[false]>;
-    exactSameSessionContinuation: Schema.Literal<[false]>;
-    sessionIdField: Schema.Literal<["sessionId"]>;
-    reason: typeof Schema.NonEmptyTrimmedString;
+    readonly adapter: Schema.Literals<readonly ["amp-code", "antigravity-cli", "claude-code", "codex-cli", "cursor", "devin", "grok-cli", "hermes", "kimi-code", "opencode-cli", "opencode2-cli", "omp-cli"]>;
+    readonly workflowWorker: Schema.Boolean;
+    readonly stableSessionIds: Schema.Literal<false>;
+    readonly exactSameSessionContinuation: Schema.Literal<false>;
+    readonly sessionIdField: Schema.Literal<"sessionId">;
+    readonly reason: Schema.NonEmptyString;
 }>]>;
 export type WorkflowHarnessContinuationSupport = typeof WorkflowHarnessContinuationSupportSchema.Type;
 export declare const workflowContinuationAdapterByWorker: {