@skastr0/prism-linux-x64 0.5.1 → 0.8.0

package/types/workflow-session.d.ts

@@ -1,34 +1,43 @@
 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", "amp-orb", "amp-runner", "antigravity-cli", "claude-code", "codex-cli", "cursor", "devin", "grok-cli", "hermes", "kimi-code", "opencode-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", "amp-orb", "amp-runner", "antigravity-cli", "claude-code", "codex-cli", "cursor", "devin", "grok-cli", "hermes", "kimi-code", "opencode-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", "amp-orb", "amp-runner", "antigravity-cli", "claude-code", "codex-cli", "cursor", "devin", "grok-cli", "hermes", "kimi-code", "opencode-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", "amp-orb", "amp-runner", "antigravity-cli", "claude-code", "codex-cli", "cursor", "devin", "grok-cli", "hermes", "kimi-code", "opencode-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: {
     readonly "amp-code": "amp-code";
+    readonly "amp-orb": "amp-orb";
+    readonly "amp-runner": "amp-runner";
     readonly "antigravity-cli": "antigravity-cli";
     readonly "claude-code": "claude-code";
     readonly "codex-cli": "codex-cli";
@@ -38,7 +47,6 @@ export declare const workflowContinuationAdapterByWorker: {
     readonly hermes: "hermes";
     readonly "kimi-code": "kimi-code";
     readonly opencode: "opencode-cli";
-    readonly opencode2: "opencode2-cli";
     readonly omp: "omp-cli";
 };
 export type WorkflowRepairLoopContinuationWorkerId = keyof typeof workflowContinuationAdapterByWorker;
@@ -54,6 +62,24 @@ export declare const workflowHarnessContinuationSupport: {
         readonly continueCommand: "amp threads continue <sessionId> --execute <prompt>";
         readonly capture: "stream-json session_id, local thread metadata, or threads list/search recovery";
     };
+    readonly "amp-orb": {
+        readonly adapter: "amp-orb";
+        readonly workflowWorker: true;
+        readonly stableSessionIds: true;
+        readonly exactSameSessionContinuation: true;
+        readonly sessionIdField: "sessionId";
+        readonly continueCommand: "amp threads continue <sessionId> --orb-execute --execute <prompt> --stream-json";
+        readonly capture: "stream-json session_id (the orb thread id); never list readback";
+    };
+    readonly "amp-runner": {
+        readonly adapter: "amp-runner";
+        readonly workflowWorker: true;
+        readonly stableSessionIds: true;
+        readonly exactSameSessionContinuation: true;
+        readonly sessionIdField: "sessionId";
+        readonly continueCommand: "amp threads continue <sessionId> --orb-execute --execute <prompt> --stream-json";
+        readonly capture: "stream-json session_id (the runner thread id); never list readback";
+    };
     readonly "antigravity-cli": {
         readonly adapter: "antigravity-cli";
         readonly workflowWorker: true;
@@ -135,15 +161,6 @@ export declare const workflowHarnessContinuationSupport: {
         readonly continueCommand: "opencode run -s <sessionId> <prompt>";
         readonly capture: "json step_start sessionID, session list, export, database, or log recovery";
     };
-    readonly "opencode2-cli": {
-        readonly adapter: "opencode2-cli";
-        readonly workflowWorker: true;
-        readonly stableSessionIds: true;
-        readonly exactSameSessionContinuation: true;
-        readonly sessionIdField: "sessionId";
-        readonly continueCommand: "opencode2 run -s <sessionId> <prompt>";
-        readonly capture: "json step_start sessionID, session list, export, database, or log recovery";
-    };
     readonly "omp-cli": {
         readonly adapter: "omp-cli";
         readonly workflowWorker: true;

package/types/workflow-store.d.ts

@@ -1,7 +1,7 @@
 import { type WorkflowRetentionCleanupReport, type WorkflowRunArtifactCounts, type WorkflowRunDeletionReport } from "./workflow-data-governance.js";
 import type { WorkflowJudgeVerdict } from "./workflows.js";
-import type { WorkflowJudgeIdentity, WorkflowRunTaskSnapshot, WorkflowTaskIdentity } from "./workflow-identity.js";
-export { workflowRunTaskSnapshotForTask, workflowTaskIdentity, type WorkflowJudgeIdentity, type WorkflowRunTaskSnapshot, type WorkflowTaskIdentity } from "./workflow-identity.js";
+import type { WorkflowJudgeIdentity, WorkflowRunTaskSnapshot, WorkflowRunTaskSnapshotInput, WorkflowTaskIdentity } from "./workflow-identity.js";
+export { workflowRunTaskSnapshotForTask, workflowTaskIdentity, type JevRunTaskSnapshot, type WorkflowJudgeIdentity, type WorkflowRunTaskSnapshot, type WorkflowRunTaskSnapshotInput, type WorkflowTaskIdentity, type WorkflowWorkerRunTaskSnapshot, } from "./workflow-identity.js";
 import { type WorkflowDatabase } from "./workflow-runtime.js";
 import type { WorkflowSpanRecord } from "./workflow-tracing.js";
 import { type WorkflowUsage, type WorkflowUsageTotals } from "./workflow-usage.js";
@@ -200,11 +200,73 @@ export type WorkflowRunStatus = "running" | "completed" | "failed" | "escalated"
  * A run's persisted status can read "completed" while carrying isolated task failures: the
  * dynamic runtime's fault-isolation contract (PQ-166) lets an author's `run` program finish
  * successfully after recovering from a task that itself failed or escalated (e.g. via
- * `Effect.either`). That is not a caller-visible success — a caller gating on `$?` (the CLI)
+ * `Effect.result`). That is not a caller-visible success — a caller gating on `$?` (the CLI)
  * must still see the partial failure. Success requires both: the run itself reached
  * "completed", and every recorded task did too.
  */
 export declare function isWorkflowRunOutcomeSuccessful(runStatus: WorkflowRunStatus, taskStatuses: ReadonlyArray<WorkflowRunTaskProgressStatus>): boolean;
+/**
+ * Provenance for a run the scheduler launched, rather than one a human started.
+ *
+ * Absent on a hand-run workflow. That absence is the honest answer — there was
+ * no execution and no occurrence — so it is modelled as an optional parameter
+ * and a nullable column, not as a sentinel string.
+ */
+export interface WorkflowRunScheduling {
+    /** The scheduler execution that launched this run. */
+    readonly executionId: string;
+    /** The installed schedule the execution belongs to. */
+    readonly scheduleId: string;
+    /** The cron occurrence this run represents, as an ISO-8601 instant. */
+    readonly scheduledFor: string | null;
+}
+/** The triple that identifies a runner process without relying on the pid alone. */
+export interface WorkflowRunRunnerIdentity {
+    readonly pid: number;
+    readonly bootId: string | null;
+    readonly startId: string | null;
+}
+/**
+ * The scheduler's read-only view of a run it owns.
+ *
+ * Purpose-built rather than reusing `WorkflowRunRecord`: reconciliation needs
+ * the runner identity and the launch-authorization state, which are internal to
+ * the scheduling protocol and not part of the general run surface.
+ */
+export interface WorkflowScheduledRunState {
+    readonly runId: string;
+    readonly workflow: string;
+    readonly status: WorkflowRunStatus;
+    readonly schedulingExecutionId: string | null;
+    readonly schedulingScheduleId: string | null;
+    readonly scheduledFor: string | null;
+    readonly runner: WorkflowRunRunnerIdentity | null;
+    /**
+     * Whether a runner consumed this run's launch authorization.
+     *
+     * Meaningful only when `schedulingExecutionId` is set. The scheduler always
+     * issues an authorization token before spawning, so for a scheduled run a
+     * present token means no runner ever consumed it, and a consumed token means
+     * a runner did. A hand-run workflow has no token to consume and no execution
+     * to reconcile, so this field is not consulted for one.
+     */
+    readonly launchAuthorized: boolean;
+    readonly terminalCause: WorkflowRunTerminalCause | null;
+    readonly finishedAt: string | null;
+    readonly heartbeatAt: string | null;
+}
+/** The outcome of a runner attempting to consume its launch authorization. */
+export type WorkflowRunLaunchAuthorization = {
+    readonly kind: "authorized";
+} | {
+    readonly kind: "not-found";
+} | {
+    readonly kind: "unauthorized";
+    readonly reason: string;
+} | {
+    readonly kind: "terminal";
+    readonly status: WorkflowRunStatus;
+};
 export interface WorkflowEventRecord {
     readonly sequence: number;
     readonly runId: string;
@@ -292,7 +354,7 @@ export interface WorkflowTaskAttemptRecord {
 }
 export declare const projectWorkflowStoreDir: (prismHome: string, cwd?: string) => string;
 export declare const defaultWorkflowStorePath: (prismHome: string, cwd?: string) => string;
-export declare const WORKFLOW_STORE_SCHEMA_VERSION = 6;
+export declare const WORKFLOW_STORE_SCHEMA_VERSION = 8;
 /**
  * Surfaces the one-time soft-divergence direction (WFE-007): a pre-existing store opened at a
  * schema version older than the binary's `WORKFLOW_STORE_SCHEMA_VERSION` migrates in place inside
@@ -352,17 +414,78 @@ export declare class WorkflowStore {
         readonly cacheKey?: string;
         readonly promptHash?: string;
     }): WorkflowCacheRecord[];
-    createRun(workflow: string, runId?: string): string;
+    /**
+     * Create a run row.
+     *
+     * `scheduling` records provenance for a run the scheduler launched. It is
+     * written in the same transaction as the row itself, because a run that
+     * exists without its provenance would be a run the scheduler cannot claim
+     * during reconciliation.
+     */
+    createRun(workflow: string, runId?: string, scheduling?: WorkflowRunScheduling): string;
+    /**
+     * Consume a run's launch authorization and record the runner's identity.
+     *
+     * This is the linearization point of the launch protocol, and it is one
+     * transaction on purpose. "A runner was authorized" and "here is the runner's
+     * identity" must not be able to disagree, or reconciliation would face a
+     * window where a runner may have imported user code but left no identity to
+     * observe — an ambiguity with no honest resolution.
+     *
+     * The token comparison is timing-safe and the update is a compare-and-set on
+     * the token column, so two runners racing for the same authorization produce
+     * exactly one winner and one `unauthorized`.
+     *
+     * This deliberately does **not** touch `heartbeat_at`. The heartbeat is the
+     * *readiness* marker a detached launcher waits on, and readiness means "the
+     * runner is executing", not "the runner claimed the run" — so it is published
+     * by `markRunRunnerStarted` after the workflow module has loaded. Publishing it
+     * here would make a workflow whose top-level code exits look like a successful
+     * start, because authorization now happens before the import.
+     */
+    beginScheduledRun(input: {
+        readonly runId: string;
+        readonly token: string;
+        readonly runnerPid: number;
+        readonly runnerBootId: string | null;
+        readonly runnerStartId: string | null;
+    }): WorkflowRunLaunchAuthorization;
+    /**
+     * The scheduler's reconciliation view of one run. Null when the run does not
+     * exist — which is itself meaningful, since the scheduler creates the run
+     * before it spawns anything.
+     */
+    scheduledRunState(runId: string): WorkflowScheduledRunState | null;
+    /**
+     * Terminalize a scheduled run the scheduler has established cannot continue.
+     *
+     * Returns whether it wrote, so the caller can tell "we closed it" from "the
+     * runner claimed it first". The ledger keeps its existing status vocabulary —
+     * `crashed` for a worker that died mid-run, `stopped` for one that never
+     * received its authorization — while the scheduler's more specific knowledge
+     * lives on the execution row and in the event stream. Widening
+     * `WorkflowRunStatus` for the scheduler's benefit would put a new state in
+     * front of every consumer of run history for no gain.
+     *
+     * The update is guarded on `status = 'running'`, so it is a compare-and-set
+     * against a runner claiming the run concurrently: exactly one wins.
+     */
+    interruptScheduledRun(input: {
+        readonly runId: string;
+        readonly kind: "interrupted" | "cancelled";
+        readonly reason: string;
+        readonly runnerPid?: number | null;
+        readonly heartbeatAt?: string | null;
+    }): boolean;
     recordRunSnapshot(input: {
         readonly runId: string;
         readonly workflowFile: string;
         readonly options?: Record<string, unknown>;
     }): void;
     getRunSnapshot(runId: string): WorkflowRunSnapshot | null;
-    recordRunTaskSnapshot(input: Omit<WorkflowRunTaskSnapshot, "createdAt">): void;
+    recordRunTaskSnapshot(input: WorkflowRunTaskSnapshotInput): void;
     listRunTaskSnapshots(runId: string): WorkflowRunTaskSnapshot[];
     setRunHandoffToken(runId: string, token: string): void;
-    consumeRunHandoffToken(runId: string, token: string): boolean;
     markRunRunnerStarted(runId: string, runnerPid: number): void;
     heartbeatRun(runId: string): void;
     recordTaskAttemptStarted(input: WorkflowTaskAttemptStartedInput): void;
@@ -380,6 +503,18 @@ export declare class WorkflowStore {
         readonly reason?: string;
         readonly mode?: string;
     }): WorkflowRunRecord | null;
+    /**
+     * Read a run **without** observer reconciliation.
+     *
+     * The detached launcher polls its own run while it waits for the readiness
+     * handshake, and during startup it is the authority on that run. `getRun`
+     * runs `failDeadPidRuns` first, so a launcher polling its own child would
+     * terminalize the run as `dead-runner-pid` the instant the child died —
+     * preempting the launcher's own, more specific `runner-start-failed` cause and
+     * the stderr evidence it captured. Reconciliation is for observers, not for
+     * the process that owns the handshake.
+     */
+    peekRun(runId: string): WorkflowRunRecord | null;
     getRun(runId: string): WorkflowRunRecord | null;
     recordEvent(input: {
         readonly runId: string;

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

@@ -0,0 +1,40 @@
+import { parsePositiveInteger } from "./workflow-harness-detection.js";
+export { parsePositiveInteger };
+export interface WorkflowWorkerProcessOptions {
+    readonly command: string;
+    readonly args: ReadonlyArray<string>;
+    readonly cwd: string;
+    readonly abortSignal?: AbortSignal;
+    readonly env?: Record<string, string>;
+    readonly onOutputActivity?: (stream: WorkflowWorkerOutputStream) => void;
+    readonly earlyExitPatterns?: ReadonlyArray<{
+        readonly name: string;
+        readonly pattern: RegExp;
+    }>;
+}
+export type WorkflowWorkerOutputStream = "stdout" | "stderr";
+export interface WorkflowWorkerProcessResult {
+    readonly exitCode: number | null;
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly durationMs: number;
+    readonly aborted: boolean;
+    readonly earlyExit?: string;
+}
+/**
+ * Worker output is captured in full, without a byte ceiling. Harness workers are
+ * long-running agents whose event streams routinely reach tens or hundreds of
+ * megabytes; a size cap turned normal agent verbosity into a task failure and
+ * forced callers to guess a number they cannot know in advance. Runaway workers
+ * are bounded by run control (`workflow runs stop`), the opt-in inactivity
+ * watchdog, and cost budgets \u2014 not by truncating their output.
+ */
+export declare class WorkflowWorkerOutputCapture {
+    private readonly streams;
+    private totalBytes;
+    append(source: WorkflowWorkerOutputStream, text: string, byteLength?: number): void;
+    output(source: WorkflowWorkerOutputStream): string;
+    bytes(): number;
+}
+export declare const workflowWorkerProcessExcerpt: (stdout: string, stderr: string) => string;
+export declare const runWorkflowWorkerProcess: (options: WorkflowWorkerProcessOptions) => Promise<WorkflowWorkerProcessResult>;

package/types/workflow-workers.d.ts

@@ -0,0 +1,50 @@
+import { type AnyWorkflowWorkerTask, type WorkflowPermissionMode, type WorkflowWorkerId } from "./workflows.js";
+import type { WorkflowTaskExecution, WorkflowTaskExecutionContext, WorkflowTaskExecutionContextWithoutRepair, WorkflowWorkerTaskExecutor } from "./workflow-runner.js";
+import { type WorkflowRepairLoopContinuationCapability, type WorkflowRepairLoopContinuationCapabilityForWorker } from "./workflow-session.js";
+export { WorkflowPermissionError } from "./workflow-permissions.js";
+export interface WorkflowWorkerAdapterOptionsBase {
+    readonly cwd: string;
+    readonly model?: string;
+    readonly profile?: string;
+    readonly resolvedPermission: WorkflowPermissionMode;
+    readonly restrictedTools?: readonly string[];
+    readonly abortSignal?: AbortSignal;
+}
+export type WorkflowWorkerAdapterOptionsForCapability<Capability extends WorkflowRepairLoopContinuationCapability> = WorkflowWorkerAdapterOptionsBase & (Capability extends "stable-session-repair-loop" ? {
+    readonly context?: WorkflowTaskExecutionContext;
+} : {
+    readonly context?: WorkflowTaskExecutionContextWithoutRepair;
+});
+export type WorkflowWorkerAdapterOptions<Worker extends WorkflowWorkerId = WorkflowWorkerId> = WorkflowWorkerAdapterOptionsForCapability<WorkflowRepairLoopContinuationCapabilityForWorker<Worker>>;
+export interface WorkflowWorkerAdapter<Worker extends WorkflowWorkerId = WorkflowWorkerId> {
+    readonly id: Worker;
+    readonly runTask: (task: AnyWorkflowWorkerTask, options: WorkflowWorkerAdapterOptions<Worker>) => Promise<WorkflowTaskExecution>;
+}
+export declare class UnsupportedWorkflowWorkerError extends Error {
+    readonly worker: string;
+    readonly supportedWorkers: ReadonlyArray<string>;
+    readonly name = "UnsupportedWorkflowWorkerError";
+    constructor(worker: string, supportedWorkers: ReadonlyArray<string>);
+}
+export declare class WorkflowWorkerContinuationError extends Error {
+    readonly name = "WorkflowWorkerContinuationError";
+}
+export declare const supportedWorkflowWorkers: () => ReadonlyArray<string>;
+export declare function getWorkflowWorkerAdapter<Worker extends WorkflowWorkerId>(worker: Worker): WorkflowWorkerAdapter<Worker>;
+export declare function getWorkflowWorkerAdapter(worker: string): WorkflowWorkerAdapter;
+/**
+ * Per-worker default permission. Remote Amp executors (orb, runner) accept only
+ * `legacy` — no per-invocation override reaches the remote amp process — so an
+ * unconfigured remote task must default to `legacy`, not the local `permissive`
+ * default that dispatch would then reject.
+ */
+export declare const defaultWorkflowWorkerPermission: (worker?: string) => WorkflowPermissionMode;
+export declare const resolveWorkflowTaskPermission: (task: AnyWorkflowWorkerTask, fallbackPermission?: WorkflowPermissionMode) => WorkflowPermissionMode;
+/** Same argv interpreters run uses. Validate calls this so illegal pins fail before spend. */
+export declare const assertWorkflowWorkerPermission: (worker: string, mode: WorkflowPermissionMode, restrictedTools?: readonly string[]) => void;
+export declare const createWorkflowWorkerExecutor: (input: {
+    readonly worker?: string;
+    readonly cwd: string;
+    readonly model?: string;
+    readonly fallbackPermission?: WorkflowPermissionMode;
+}) => WorkflowWorkerTaskExecutor;