@skastr0/prism-linux-x64 0.1.1 → 0.1.3

package/types/workflow-store.d.ts

@@ -0,0 +1,214 @@
+import { Database } from "bun:sqlite";
+import type { AnyWorkflowTask, WorkflowJudgeVerdict, WorkflowRuntimeOptions } from "./workflows.js";
+export interface WorkflowTaskIdentity {
+    readonly workflow: string;
+    readonly taskId: string;
+    readonly cacheKey: string;
+    readonly promptHash: string;
+    readonly agentManifestHash: string;
+}
+export interface WorkflowJudgeIdentity {
+    readonly workflow: string;
+    readonly taskId: string;
+    readonly taskCacheKey: string;
+    readonly criterion: string;
+    readonly cacheKey: string;
+}
+export type WorkflowTaskOutputSource = "mock-output";
+export interface CompletedWorkflowTaskRecord {
+    readonly identity: WorkflowTaskIdentity;
+    readonly agent: {
+        readonly plugin: string;
+        readonly name: string;
+    };
+    readonly output: unknown;
+    readonly metadata?: Record<string, unknown>;
+    readonly outputSource?: WorkflowTaskOutputSource;
+}
+export interface WorkflowCacheRecord extends CompletedWorkflowTaskRecord {
+    readonly status: string;
+    readonly outputSource?: WorkflowTaskOutputSource;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}
+export interface WorkflowJudgeRecord {
+    readonly identity: WorkflowJudgeIdentity;
+    readonly verdict: WorkflowJudgeVerdict["verdict"];
+    readonly feedback?: string;
+    readonly evidence: unknown;
+    readonly output: unknown;
+    readonly taskMetadata: unknown;
+    readonly metadata?: Record<string, unknown>;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}
+export type WorkflowRunTaskStatus = "completed" | "failed" | "escalated";
+export interface WorkflowRunTaskRecord {
+    readonly runId: string;
+    readonly taskId: string;
+    readonly cacheKey: string;
+    readonly status: WorkflowRunTaskStatus;
+    readonly cached: boolean;
+    readonly agent: {
+        readonly plugin: string;
+        readonly name: string;
+    };
+    readonly output: unknown;
+    readonly metadata?: Record<string, unknown>;
+}
+export type WorkflowRunTaskProgressStatus = "running" | "completed" | "failed" | "escalated";
+export type WorkflowRunTaskCacheLookup = "hit" | "miss" | "skipped";
+export interface WorkflowRunTaskProgress {
+    readonly taskId: string;
+    readonly status: WorkflowRunTaskProgressStatus;
+    readonly cacheKey?: string;
+    readonly cached?: boolean;
+    readonly cacheLookup?: WorkflowRunTaskCacheLookup;
+    readonly repairs: number;
+    readonly agent?: {
+        readonly plugin: string;
+        readonly name: string;
+    };
+    readonly lastEventType?: string;
+    readonly lastEventAt?: string;
+}
+export type WorkflowRunTaskExecutionSource = "cached" | "fresh" | "unknown";
+export type WorkflowRunTaskEvidenceSource = "this-run" | "prior-cache-record" | "run-events" | "unknown";
+export interface WorkflowRunTaskCompactSummary {
+    readonly taskId: string;
+    readonly status: WorkflowRunTaskProgressStatus;
+    readonly execution: WorkflowRunTaskExecutionSource;
+    readonly evidenceSource: WorkflowRunTaskEvidenceSource;
+    readonly cached: boolean | null;
+    readonly cacheLookup?: WorkflowRunTaskCacheLookup;
+    readonly agent?: {
+        readonly plugin: string;
+        readonly name: string;
+    };
+    readonly workerAdapter: string | null;
+    readonly model: string | null;
+    readonly nativeAgent: string | null;
+    readonly repairCount: number;
+    readonly repairMode: string | null;
+    readonly durationMs: number | null;
+    readonly externalSessionPointer: string | null;
+    readonly lastEventType?: string;
+    readonly lastEventAt?: string;
+}
+export interface WorkflowRunCompactSummary {
+    readonly kind: "workflow-execution-evidence";
+    readonly semanticCorrectness: "not-evaluated";
+    readonly disclaimer: string;
+    readonly run: WorkflowRunRecord;
+    readonly totals: {
+        readonly totalTasks: number;
+        readonly freshExecutions: number;
+        readonly cacheHits: number;
+        readonly repairs: number;
+        readonly status: WorkflowRunStatus;
+        readonly durationMs: number | null;
+    };
+    readonly tasks: WorkflowRunTaskCompactSummary[];
+}
+export interface WorkflowRunRecord {
+    readonly runId: string;
+    readonly workflow: string;
+    readonly status: WorkflowRunStatus;
+    readonly finishedAt: string | null;
+    readonly runnerPid?: number;
+    readonly heartbeatAt?: string;
+}
+export type WorkflowRunStatus = "running" | "completed" | "failed" | "escalated" | "unknown";
+export interface WorkflowEventRecord {
+    readonly sequence: number;
+    readonly runId: string;
+    readonly taskId: string | null;
+    readonly type: string;
+    readonly payload: unknown;
+    readonly createdAt: string;
+}
+export declare const defaultWorkflowStorePath: (projectPath: string) => string;
+export declare const workflowTaskIdentity: (workflow: string, task: AnyWorkflowTask, runtimeOptions?: WorkflowRuntimeOptions) => WorkflowTaskIdentity;
+export declare class WorkflowStore {
+    private readonly db;
+    constructor(db: Database);
+    static open(path: string): Promise<WorkflowStore>;
+    close(): void;
+    getCompleted(identity: WorkflowTaskIdentity, options?: {
+        readonly allowMockSourced?: boolean;
+    }): CompletedWorkflowTaskRecord | null;
+    getJudgeRecord(identity: WorkflowJudgeIdentity): WorkflowJudgeRecord | null;
+    recordJudge(input: {
+        readonly identity: WorkflowJudgeIdentity;
+        readonly verdict: WorkflowJudgeVerdict;
+        readonly evidence: unknown;
+        readonly output: unknown;
+        readonly taskMetadata: unknown;
+    }): void;
+    listJudgeRecords(options?: {
+        readonly workflow?: string;
+        readonly taskId?: string;
+        readonly criterion?: string;
+    }): WorkflowJudgeRecord[];
+    listCompletedCache(options?: {
+        readonly workflow?: string;
+        readonly taskId?: string;
+        readonly cacheKey?: string;
+        readonly promptHash?: string;
+        readonly agentManifestHash?: string;
+    }): WorkflowCacheRecord[];
+    createRun(workflow: string, runId?: string): string;
+    setRunHandoffToken(runId: string, token: string): void;
+    consumeRunHandoffToken(runId: string, token: string): boolean;
+    markRunRunnerStarted(runId: string, runnerPid: number): void;
+    heartbeatRun(runId: string): void;
+    finishRun(runId: string, status: Exclude<WorkflowRunStatus, "running" | "unknown">): void;
+    stopRun(runId: string, reason?: string): WorkflowRunRecord | null;
+    stopRunningRun(runId: string, reason?: string): WorkflowRunRecord | null;
+    restartRunningRun(input: {
+        readonly previousRunId: string;
+        readonly nextRunId: string;
+        readonly nextWorkflow: string;
+        readonly handoffToken: string;
+        readonly reason?: string;
+        readonly mode?: string;
+    }): WorkflowRunRecord | null;
+    getRun(runId: string): WorkflowRunRecord | null;
+    recordEvent(input: {
+        readonly runId: string;
+        readonly taskId?: string;
+        readonly type: string;
+        readonly payload: unknown;
+    }): void;
+    listRunEvents(runId: string): WorkflowEventRecord[];
+    failDeadPidRuns(): WorkflowRunRecord[];
+    failStaleRuns(olderThanMs: number, now?: Date): WorkflowRunRecord[];
+    listRuns(): WorkflowRunRecord[];
+    recordRunTask(input: {
+        readonly runId: string;
+        readonly ordinal: number;
+        readonly identity: WorkflowTaskIdentity;
+        readonly agent: {
+            readonly plugin: string;
+            readonly name: string;
+        };
+        readonly status: WorkflowRunTaskStatus;
+        readonly cached: boolean;
+        readonly output: unknown;
+        readonly metadata?: Record<string, unknown>;
+        readonly finishRunStatus?: Exclude<WorkflowRunStatus, "running" | "unknown">;
+    }): void;
+    listRunTasks(runId: string): WorkflowRunTaskRecord[];
+    summarizeRunTasks(runId: string): WorkflowRunTaskProgress[];
+    compactRunSummary(runId: string): WorkflowRunCompactSummary | null;
+    recordCompleted(input: {
+        readonly identity: WorkflowTaskIdentity;
+        readonly agent: {
+            readonly plugin: string;
+            readonly name: string;
+        };
+        readonly output: unknown;
+        readonly metadata?: Record<string, unknown>;
+        readonly outputSource?: WorkflowTaskOutputSource;
+    }): void;
+}

package/types/workflow-tsconfig.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Generate the Prism-owned authoring tsconfig for workflow .ts files.
+ *
+ * The generated tsconfig maps the three virtual specifiers a workflow author
+ * uses to their shipped type declarations:
+ *
+ *   "prism"      → <platform-package>/types/index.d.ts  (the emitted prism.d.ts)
+ *   "prism/refs" → ~/.prism/state/projects/<key>/generated/agents.ts  (per-project refs)
+ *   "effect"     → <platform-package>/node_modules/effect/dist/dts/index.d.ts
+ *
+ * Resolution strategy:
+ *
+ * When the Prism binary is installed, the platform package sits beside the
+ * binary: `dirname(dirname(process.execPath))`. During development (source
+ * checkout) the shipped declarations live inside the matching
+ * packages/npm/prism-<platform>/types directory (populated by build:npm), with
+ * the repo's node_modules/effect and dist/dts-tmp/ as further fallbacks — so
+ * the type surface resolves without an install.
+ *
+ * The resolved type dirs (resolveWorkflowTypeDirs) and path builder
+ * (buildWorkflowPaths) are shared with the in-process typecheck in
+ * workflow-loader, which constructs compilerOptions in-memory rather than
+ * relying solely on the on-disk tsconfig.
+ *
+ * The generated tsconfig is written to prismHome/state/tsconfig.workflow.json.
+ * This file is Prism-owned and must never be committed to the user's project.
+ */
+export interface WorkflowTypeDirs {
+    /** Directory holding the shipped prism declarations (types/index.d.ts). */
+    readonly prismTypesDir: string | undefined;
+    /** Directory holding the effect declarations (dist/dts/index.d.ts). */
+    readonly effectDtsDir: string | undefined;
+}
+/**
+ * Resolve the prism and effect declaration directories for the running
+ * environment (installed binary or source checkout). Either may be undefined
+ * when the corresponding type surface cannot be located.
+ */
+export declare const resolveWorkflowTypeDirs: () => WorkflowTypeDirs;
+/**
+ * Build the `compilerOptions.paths` map for typechecking a workflow file from
+ * the resolved type dirs and (optionally) the project-keyed generated refs.
+ *
+ * Entries are only emitted when the underlying declaration exists, so callers
+ * can detect a missing type environment (empty/partial paths) and warn+proceed
+ * instead of pointing a specifier at a nonexistent file.
+ */
+export declare const buildWorkflowPaths: (options: {
+    readonly typeDirs: WorkflowTypeDirs;
+    /** Absolute path to the generated refs file (~/.../generated/agents.ts). */
+    readonly refsFile?: string;
+}) => Record<string, string[]>;
+export interface WorkflowTsconfigOptions {
+    /**
+     * Prism home directory. Defaults to ~/.prism via resolvePrismHome().
+     * The generated tsconfig is written to prismHome/state/tsconfig.workflow.json.
+     */
+    readonly prismHome: string;
+    /**
+     * Absolute path to the project's generated refs directory
+     * (~/.prism/state/projects/<key>/generated/).
+     * Used to wire "prism/refs" paths.
+     * If omitted, "prism/refs" paths entry is omitted from the tsconfig.
+     */
+    readonly refsDir?: string;
+    /**
+     * Absolute path to the directory containing the user's workflow .ts files.
+     * Added to tsconfig `include` so the IDE and tsc pick them up automatically.
+     */
+    readonly workflowDir?: string;
+}
+export interface GeneratedWorkflowTsconfig {
+    /** Absolute path where the tsconfig was written. */
+    readonly path: string;
+    /** Absolute path to the prism types directory (types/index.d.ts). */
+    readonly prismTypesDir: string | undefined;
+    /** Absolute path to the effect dts directory (dist/dts/index.d.ts). */
+    readonly effectDtsDir: string | undefined;
+}
+/** The filename for the generated workflow authoring tsconfig. */
+export declare const WORKFLOW_TSCONFIG_FILENAME = "tsconfig.workflow.json";
+/**
+ * Generate and write the Prism workflow-authoring tsconfig.
+ *
+ * Returns the path where the tsconfig was written, plus the resolved type
+ * directories for caller inspection or further wiring.
+ */
+export declare const generateWorkflowTsconfig: (options: WorkflowTsconfigOptions) => Promise<GeneratedWorkflowTsconfig>;
+/** Returns the expected tsconfig path given a prismHome directory. */
+export declare const workflowTsconfigPath: (prismHome: string) => string;

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

@@ -0,0 +1,10 @@
+import type { AnyWorkflowTask } from "./workflows.js";
+export declare const WORKFLOW_WORKER_JSON_CONTRACT_VERSION = "v1";
+export declare const WORKFLOW_WORKER_JSON_INSTRUCTION_SOURCE = "workflow-worker-json-instruction-v1";
+export declare class WorkflowOutputParseError extends Error {
+    readonly name = "WorkflowOutputParseError";
+    readonly rawText?: string;
+    constructor(message: string, rawText?: string);
+}
+export declare const workflowWorkerJsonInstruction: (task: AnyWorkflowTask) => string;
+export declare const parseWorkflowWorkerJsonOutput: (text: string) => unknown;

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

@@ -0,0 +1,8 @@
+export declare const DEFAULT_WORKFLOW_WORKER_STDERR_EXCERPT_BYTES = 4096;
+export interface WorkflowWorkerStderrMetadata {
+    readonly stderrBytes?: number;
+    readonly stderrSha256?: string;
+    readonly stderrExcerpt?: string;
+    readonly stderrTruncated?: boolean;
+}
+export declare const summarizeWorkflowWorkerStderr: (stderr: string, maxExcerptBytes?: number) => WorkflowWorkerStderrMetadata;

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

@@ -0,0 +1,19 @@
+export interface WorkflowWorkerProcessOptions {
+    readonly command: string;
+    readonly args: ReadonlyArray<string>;
+    readonly cwd: string;
+    readonly abortSignal?: AbortSignal;
+    readonly processTimeoutMs?: number;
+    readonly env?: Record<string, string>;
+}
+export interface WorkflowWorkerProcessResult {
+    readonly exitCode: number | null;
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly durationMs: number;
+    readonly timedOut: boolean;
+    readonly aborted: boolean;
+}
+export declare const parsePositiveInteger: (value: string | undefined) => number | undefined;
+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,27 @@
+import type { AnyWorkflowTask } from "./workflows.js";
+import type { WorkflowTaskExecution, WorkflowTaskExecutionContext, WorkflowTaskExecutor } from "./workflow-runner.js";
+export interface WorkflowWorkerAdapterOptions {
+    readonly cwd: string;
+    readonly model?: string;
+    readonly profile?: string;
+    readonly abortSignal?: AbortSignal;
+    readonly context?: WorkflowTaskExecutionContext;
+}
+export interface WorkflowWorkerAdapter {
+    readonly id: string;
+    readonly runTask: (task: AnyWorkflowTask, options: WorkflowWorkerAdapterOptions) => Promise<WorkflowTaskExecution>;
+    readonly continueTask?: (task: AnyWorkflowTask, options: WorkflowWorkerAdapterOptions) => 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 const supportedWorkflowWorkers: () => ReadonlyArray<string>;
+export declare const getWorkflowWorkerAdapter: (worker: string) => WorkflowWorkerAdapter;
+export declare const createWorkflowWorkerExecutor: (input: {
+    readonly worker?: string;
+    readonly cwd: string;
+    readonly model?: string;
+}) => WorkflowTaskExecutor;

package/types/workflows.d.ts

@@ -0,0 +1,145 @@
+import { Effect, Schema } from "effect";
+export interface WorkflowModelRef {
+    readonly modelspace?: string;
+    readonly profile?: string;
+}
+export interface WorkflowModelspaceRef {
+    readonly kind: "modelspace-ref";
+    readonly plugin: string;
+    readonly modelspace: string;
+}
+export interface WorkflowModelProfileRef {
+    readonly kind: "model-profile-ref";
+    readonly plugin: string;
+    readonly modelspace: string;
+    readonly profile: string;
+}
+export interface WorkflowManagedSkillRef {
+    readonly kind: "managed-skill-ref";
+    readonly plugin: string;
+    readonly name: string;
+}
+export interface WorkflowSkillspaceRef {
+    readonly kind: "skillspace-ref";
+    readonly plugin: string;
+    readonly skillspace: string;
+    readonly skills: ReadonlyArray<string>;
+}
+export interface WorkflowAgentRef {
+    readonly kind: "agent-ref";
+    readonly plugin: string;
+    readonly name: string;
+    readonly description: string;
+    readonly sourceHash: string;
+    readonly manifestHash: string;
+    readonly model?: WorkflowModelRef;
+    readonly installs: ReadonlyArray<string>;
+}
+export type WorkflowOutputSchema = Schema.Schema.AnyNoContext;
+export type WorkflowWorkerId = "amp-code" | "antigravity-cli" | "claude-code" | "codex-cli" | "grok" | "hermes" | "kimi-code" | "opencode";
+export interface WorkflowTaskWorkerOptions {
+    readonly worker?: WorkflowWorkerId;
+    readonly model?: string;
+    readonly profile?: string;
+}
+export interface WorkflowFinishCriterionContext<Output> {
+    readonly output: Output;
+    readonly rawOutput: unknown;
+    readonly metadata?: Record<string, unknown>;
+}
+export interface WorkflowDeterministicFinishCriterion<Output> {
+    readonly kind?: "deterministic";
+    readonly name: string;
+    readonly check: (context: WorkflowFinishCriterionContext<Output>) => Effect.Effect<void, unknown>;
+    readonly repairPrompt?: (error: unknown, context: WorkflowFinishCriterionContext<Output>) => string;
+}
+export type WorkflowJudgeVerdict = {
+    readonly verdict: "pass";
+    readonly feedback?: string;
+    readonly metadata?: Record<string, unknown>;
+} | {
+    readonly verdict: "continue";
+    readonly feedback: string;
+    readonly metadata?: Record<string, unknown>;
+} | {
+    readonly verdict: "fail";
+    readonly feedback?: string;
+    readonly metadata?: Record<string, unknown>;
+} | {
+    readonly verdict: "escalate";
+    readonly feedback?: string;
+    readonly metadata?: Record<string, unknown>;
+};
+export interface WorkflowJudgeTaskMetadata {
+    readonly id: string;
+    readonly agent: {
+        readonly plugin: string;
+        readonly name: string;
+    };
+    readonly cacheKey?: string;
+    readonly worker?: WorkflowTaskWorkerOptions;
+}
+export interface WorkflowJudgeEvidenceSelectionContext<Output> {
+    readonly goal: string;
+    readonly output: Output;
+    readonly metadata?: Record<string, unknown>;
+    readonly task: WorkflowJudgeTaskMetadata;
+}
+export interface WorkflowJudgeCriterionContext<Output, Evidence = unknown> extends WorkflowJudgeEvidenceSelectionContext<Output> {
+    readonly evidence: Evidence;
+}
+export interface WorkflowJudgeFinishCriterion<Output, Evidence = unknown> {
+    readonly kind: "judge";
+    readonly name: string;
+    readonly goal?: string | ((context: Omit<WorkflowJudgeEvidenceSelectionContext<Output>, "goal">) => string);
+    readonly selectEvidence?: (context: WorkflowJudgeEvidenceSelectionContext<Output>) => Evidence;
+    readonly evaluate: (context: WorkflowJudgeCriterionContext<Output, Evidence>) => Effect.Effect<WorkflowJudgeVerdict, unknown>;
+}
+export type WorkflowFinishCriterion<Output> = WorkflowDeterministicFinishCriterion<Output> | WorkflowJudgeFinishCriterion<Output>;
+export interface WorkflowFinishOptions<Output> {
+    readonly maxRepairs?: number;
+    readonly criteria?: ReadonlyArray<WorkflowFinishCriterion<Output>>;
+}
+export interface WorkflowTaskDefinition<Id extends string, Agent extends WorkflowAgentRef, Output extends WorkflowOutputSchema> {
+    readonly id: Id;
+    readonly agent: Agent;
+    readonly prompt: string;
+    readonly output: Output;
+    readonly cacheKey?: string;
+    readonly worker?: WorkflowTaskWorkerOptions;
+    readonly finish?: WorkflowFinishOptions<Schema.Schema.Type<Output>>;
+}
+export interface WorkflowTask<Id extends string = string, Agent extends WorkflowAgentRef = WorkflowAgentRef, Output extends WorkflowOutputSchema = WorkflowOutputSchema> extends WorkflowTaskDefinition<Id, Agent, Output> {
+    readonly kind: "workflow-task";
+}
+export type AnyWorkflowTask = WorkflowTask<string, WorkflowAgentRef, WorkflowOutputSchema>;
+export type WorkflowTaskOutput<Task extends AnyWorkflowTask> = Schema.Schema.Type<Task["output"]>;
+export interface WorkflowDefinition<Name extends string, Tasks extends ReadonlyArray<AnyWorkflowTask>> {
+    readonly kind: "workflow";
+    readonly name: Name;
+    readonly tasks: Tasks;
+}
+export interface WorkflowRuntime {
+    runTask: <Task extends AnyWorkflowTask>(task: Task) => Effect.Effect<WorkflowTaskOutput<Task>, unknown>;
+}
+export interface WorkflowRuntimeOptions {
+    readonly fallbackWorker?: string;
+    readonly fallbackModel?: string;
+}
+export interface DynamicWorkflowDefinition<Name extends string> {
+    readonly kind: "workflow";
+    readonly name: Name;
+    readonly tasks: readonly [];
+    readonly run: (runtime: WorkflowRuntime) => Effect.Effect<unknown, unknown>;
+}
+export type AnyWorkflowDefinition = WorkflowDefinition<string, ReadonlyArray<AnyWorkflowTask>> | DynamicWorkflowDefinition<string>;
+export declare const defineTask: <const Id extends string, const Agent extends WorkflowAgentRef, const Output extends WorkflowOutputSchema>(definition: WorkflowTaskDefinition<Id, Agent, Output>) => WorkflowTask<Id, Agent, Output>;
+export declare function defineWorkflow<const Name extends string, const Tasks extends ReadonlyArray<AnyWorkflowTask>>(definition: {
+    readonly name: Name;
+    readonly tasks: Tasks;
+}): WorkflowDefinition<Name, Tasks>;
+export declare function defineWorkflow<const Name extends string>(definition: {
+    readonly name: Name;
+    readonly run: (runtime: WorkflowRuntime) => Effect.Effect<unknown, unknown>;
+}): DynamicWorkflowDefinition<Name>;
+export declare const decodeTaskOutput: <Task extends AnyWorkflowTask>(task: Task, value: unknown) => import("effect/Either").Either<any, import("effect/ParseResult").ParseError>;