@skastr0/prism-darwin-x64 0.3.3 → 0.3.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skastr0/prism-darwin-x64",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "type": "module",
   "description": "Prism standalone CLI binary for macOS x64.",
   "license": "MIT",
@@ -20,7 +20,7 @@
     "@modelcontextprotocol/sdk": "1.29.0",
     "@opencode-ai/plugin": "^1.15.13",
     "@opentui/core-darwin-x64": "0.4.1",
-    "@skastr0/prism-sdk": "0.3.3",
+    "@skastr0/prism-sdk": "0.3.5",
     "effect": "^3.21.1",
     "typescript": "^5.8.3",
     "zod": "4.4.3"

package/types/index.d.ts

@@ -182,6 +182,15 @@ export interface OrbitPhaseDefinition {
      * into generated orbit skills, but does not attach runtime semantics to it.
      */
     readonly workflow?: OrbitPhaseWorkflowDefinition;
+    /**
+     * Typed workflow I/O contract for this phase. Serialized to JSON Schema in
+     * the compile manifest for workflow runtimes; unsupported schema constructs
+     * fail the compile.
+     */
+    readonly contract?: {
+        readonly input?: import("effect/Schema").Schema.AnyNoContext;
+        readonly output?: import("effect/Schema").Schema.AnyNoContext;
+    };
     /**
      * Long-form markdown for this phase. When present, lowerers write it to
      * `references/<phase-name>.md` next to the orbit SKILL.md. Treat this as
@@ -313,6 +322,13 @@ export declare const hookEvent: {
     readonly permissionRequest: "permission.request";
     readonly sessionStart: "session.start";
     readonly sessionEnd: "session.end";
+    readonly toolFailure: "tool.failure";
+    readonly stop: "stop";
+    readonly subagentStart: "subagent.start";
+    readonly subagentStop: "subagent.stop";
+    readonly compactBefore: "compact.before";
+    readonly compactAfter: "compact.after";
+    readonly notification: "notification";
 };
 export type HookEvent = (typeof hookEvent)[keyof typeof hookEvent];
 export interface HookTargetContextDefinition {
@@ -378,7 +394,70 @@ export interface SessionEndHookEventDefinition {
     readonly reason?: string;
     readonly native?: Record<string, unknown>;
 }
-export type HookEventPayloadDefinition = ToolBeforeHookEventDefinition | ToolAfterHookEventDefinition | PromptSubmitHookEventDefinition | PermissionRequestHookEventDefinition | SessionStartHookEventDefinition | SessionEndHookEventDefinition;
+export interface ToolFailureHookEventDefinition {
+    readonly event: typeof hookEvent.toolFailure;
+    readonly target: HookTargetContextDefinition;
+    readonly tool: HookToolContextDefinition & {
+        readonly error: unknown;
+    };
+    readonly cwd?: string;
+    readonly session?: HookSessionContextDefinition;
+    readonly native?: Record<string, unknown>;
+}
+export interface StopHookEventDefinition {
+    readonly event: typeof hookEvent.stop;
+    readonly target: HookTargetContextDefinition;
+    readonly cwd?: string;
+    readonly session?: HookSessionContextDefinition;
+    readonly stopHookActive?: boolean;
+    readonly native?: Record<string, unknown>;
+}
+export interface SubagentContextDefinition {
+    readonly id?: string;
+    readonly type?: string;
+}
+export interface SubagentStartHookEventDefinition {
+    readonly event: typeof hookEvent.subagentStart;
+    readonly target: HookTargetContextDefinition;
+    readonly cwd?: string;
+    readonly session?: HookSessionContextDefinition;
+    readonly subagent?: SubagentContextDefinition;
+    readonly native?: Record<string, unknown>;
+}
+export interface SubagentStopHookEventDefinition {
+    readonly event: typeof hookEvent.subagentStop;
+    readonly target: HookTargetContextDefinition;
+    readonly cwd?: string;
+    readonly session?: HookSessionContextDefinition;
+    readonly subagent?: SubagentContextDefinition;
+    readonly native?: Record<string, unknown>;
+}
+export interface CompactBeforeHookEventDefinition {
+    readonly event: typeof hookEvent.compactBefore;
+    readonly target: HookTargetContextDefinition;
+    readonly cwd?: string;
+    readonly session?: HookSessionContextDefinition;
+    readonly trigger?: string;
+    readonly native?: Record<string, unknown>;
+}
+export interface CompactAfterHookEventDefinition {
+    readonly event: typeof hookEvent.compactAfter;
+    readonly target: HookTargetContextDefinition;
+    readonly cwd?: string;
+    readonly session?: HookSessionContextDefinition;
+    readonly trigger?: string;
+    readonly native?: Record<string, unknown>;
+}
+export interface NotificationHookEventDefinition {
+    readonly event: typeof hookEvent.notification;
+    readonly target: HookTargetContextDefinition;
+    readonly cwd?: string;
+    readonly session?: HookSessionContextDefinition;
+    readonly message?: string;
+    readonly kind?: string;
+    readonly native?: Record<string, unknown>;
+}
+export type HookEventPayloadDefinition = ToolBeforeHookEventDefinition | ToolAfterHookEventDefinition | PromptSubmitHookEventDefinition | PermissionRequestHookEventDefinition | SessionStartHookEventDefinition | SessionEndHookEventDefinition | ToolFailureHookEventDefinition | StopHookEventDefinition | SubagentStartHookEventDefinition | SubagentStopHookEventDefinition | CompactBeforeHookEventDefinition | CompactAfterHookEventDefinition | NotificationHookEventDefinition;
 export type HookEventPayloadFor<E extends HookEvent> = Extract<HookEventPayloadDefinition, {
     readonly event: E;
 }>;
@@ -386,18 +465,30 @@ export interface ContinueHookResultDefinition {
     readonly decision: "continue";
     readonly systemMessage?: string;
     readonly additionalContext?: string;
+    /** tool.before: replace the tool arguments before execution. */
+    readonly updatedInput?: unknown;
+    /** tool.after: replace the tool result before the model sees it. */
+    readonly updatedOutput?: unknown;
 }
 export interface BlockHookResultDefinition {
     readonly decision: "block";
     readonly message: string;
+    readonly systemMessage?: string;
 }
 export interface AllowHookResultDefinition {
     readonly decision: "allow";
     readonly systemMessage?: string;
+    readonly updatedInput?: unknown;
+}
+export interface AskHookResultDefinition {
+    readonly decision: "ask";
+    readonly systemMessage?: string;
 }
 export type ToolBeforeHookResultDefinition = ContinueHookResultDefinition | BlockHookResultDefinition;
-export type PermissionRequestHookResultDefinition = ContinueHookResultDefinition | AllowHookResultDefinition | BlockHookResultDefinition;
-export type HookResultFor<E extends HookEvent> = E extends typeof hookEvent.toolBefore ? ToolBeforeHookResultDefinition : E extends typeof hookEvent.permissionRequest ? PermissionRequestHookResultDefinition : ContinueHookResultDefinition;
+export type PermissionRequestHookResultDefinition = ContinueHookResultDefinition | AllowHookResultDefinition | AskHookResultDefinition | BlockHookResultDefinition;
+/** prompt.submit, stop, subagent.stop, compact.before — continue or block. */
+export type BlockableHookResultDefinition = ContinueHookResultDefinition | BlockHookResultDefinition;
+export type HookResultFor<E extends HookEvent> = E extends typeof hookEvent.toolBefore ? ToolBeforeHookResultDefinition : E extends typeof hookEvent.permissionRequest ? PermissionRequestHookResultDefinition : E extends typeof hookEvent.promptSubmit | typeof hookEvent.stop | typeof hookEvent.subagentStop | typeof hookEvent.compactBefore ? BlockableHookResultDefinition : ContinueHookResultDefinition;
 export type HookHandlerDefinition<E extends HookEvent> = (event: HookEventPayloadFor<E>) => import("effect").Effect.Effect<HookResultFor<E>, unknown, never>;
 export interface HookAnyToolMatcherDefinition {
     readonly kind: "hook-any-tool";
@@ -418,13 +509,17 @@ export type HookToolMatcherDefinition = HookAnyToolMatcherDefinition | HookTools
 export interface ToolHookMatchDefinition {
     readonly tool?: HookToolMatcherDefinition;
 }
-export type HookMatchDefinition<E extends HookEvent> = E extends typeof hookEvent.toolBefore | typeof hookEvent.toolAfter | typeof hookEvent.permissionRequest ? ToolHookMatchDefinition : never;
+export type HookMatchDefinition<E extends HookEvent> = E extends typeof hookEvent.toolBefore | typeof hookEvent.toolAfter | typeof hookEvent.toolFailure | typeof hookEvent.permissionRequest ? ToolHookMatchDefinition : never;
 export interface HookDefinition<E extends HookEvent = HookEvent> {
     readonly name: string;
     readonly description?: string;
     readonly event: E;
     readonly targets?: readonly string[];
     readonly match?: HookMatchDefinition<E>;
+    /** How to lower this hook on a target that cannot deliver every control it
+     * declares: "degrade" (default) omits with a fidelity note, "skip" omits
+     * silently, "fail" makes it a compile error. */
+    readonly onDegraded?: "fail" | "degrade" | "skip";
     readonly handle: HookHandlerDefinition<E>;
 }
 export type HookSource<E extends HookEvent = HookEvent> = HookDefinition<E>;

package/types/lowerer-capabilities.d.ts

@@ -176,7 +176,11 @@ export declare const LOWERER_CAPABILITIES: {
                 readonly path: "<prism-home>/runtime/mcp/<plugin>/server.mjs";
                 readonly summary: "Canonical tools lower to the canonical PRISM_HOME union MCP server referenced from config.yaml.";
             };
-            readonly hooks: LowererSurfaceCapability;
+            readonly hooks: {
+                readonly kind: "config-patch";
+                readonly path: "<hermes-root>/config.yaml#hooks";
+                readonly summary: "Compile patches managed Hermes hook entries and wrapper files.";
+            };
             readonly mcpConfig: {
                 readonly kind: "config-patch";
                 readonly path: "<hermes-root>/config.yaml#mcp_servers";
@@ -577,6 +581,46 @@ export declare const LOWERER_CAPABILITIES: {
             };
         };
     };
+    readonly devin: {
+        readonly harness: "devin";
+        readonly family: "coding-harness";
+        readonly workflowWorker: true;
+        readonly compile: {
+            readonly agents: "unsupported";
+            readonly agentModelBindings: "ignored";
+            readonly generatedCanonicalTools: "unsupported";
+            readonly hooks: "supported";
+            readonly skillPermissions: "unsupported";
+        };
+        readonly surfaces: {
+            readonly pluginBundle: LowererSurfaceCapability;
+            readonly rules: {
+                readonly kind: "direct-file";
+                readonly path: "<devin-root>/AGENTS.md";
+                readonly summary: "Install appends managed sections to the native AGENTS.md instructions file.";
+            };
+            readonly commands: LowererSurfaceCapability;
+            readonly agents: LowererSurfaceCapability;
+            readonly skills: {
+                readonly kind: "direct-file";
+                readonly path: "<devin-root>/skills/";
+                readonly summary: "Install and compile write Agent Skill folders (global and project .devin/skills).";
+            };
+            readonly generatedTools: LowererSurfaceCapability;
+            readonly hooks: {
+                readonly kind: "direct-file";
+                readonly path: "project: hooks.v1.json; global: config.json#hooks json-array-member + hooks/*.mjs";
+                readonly summary: "Project scope writes hooks.v1.json; global scope upserts Prism entries into config.json hooks without whole-file adopt. Wrappers under hooks/.";
+            };
+            readonly mcpConfig: LowererSurfaceCapability;
+            readonly agentConfig: {
+                readonly kind: "direct-file";
+                readonly path: "ephemeral --agent-config for workflow runs";
+                readonly summary: "Workflow worker writes temporary agent-config (system_instructions, allowed_tools); not a durable install surface.";
+            };
+        };
+        readonly notes: readonly ["Never whole-file adopt ~/.config/devin/config.json — herdr hooks and user prefs live there.", "Workflow default model is swe-1-7; headless via `devin -p` + ATIF --export session resume via -r."];
+    };
 };
 export declare const getCompileTargetCapabilities: (harness: string) => CompileTargetCapabilities;
 /**

package/types/types.d.ts

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

package/types/workflow-session.d.ts

@@ -1,17 +1,17 @@
 import { Schema } from "effect";
-export declare const WorkflowContinuationAdapterIdSchema: Schema.Literal<["amp-code", "antigravity-cli", "claude-code", "codex-cli", "grok-cli", "hermes", "kimi-code", "opencode-cli"]>;
+export declare const WorkflowContinuationAdapterIdSchema: Schema.Literal<["amp-code", "antigravity-cli", "claude-code", "codex-cli", "devin", "grok-cli", "hermes", "kimi-code", "opencode-cli"]>;
 export type WorkflowContinuationAdapterId = typeof WorkflowContinuationAdapterIdSchema.Type;
-export declare const WorkflowContinuationWorkerIdSchema: Schema.Literal<["amp-code", "antigravity-cli", "claude-code", "codex-cli", "grok", "hermes", "kimi-code", "opencode"]>;
+export declare const WorkflowContinuationWorkerIdSchema: Schema.Literal<["amp-code", "antigravity-cli", "claude-code", "codex-cli", "devin", "grok", "hermes", "kimi-code", "opencode"]>;
 export type WorkflowContinuationWorkerId = typeof WorkflowContinuationWorkerIdSchema.Type;
 export declare const StableSessionIdSchema: Schema.brand<typeof Schema.NonEmptyTrimmedString, "StableSessionId">;
 export type StableSessionId = typeof StableSessionIdSchema.Type;
 export declare const WorkflowStableSessionSchema: Schema.Struct<{
-    adapter: Schema.Literal<["amp-code", "antigravity-cli", "claude-code", "codex-cli", "grok-cli", "hermes", "kimi-code", "opencode-cli"]>;
+    adapter: Schema.Literal<["amp-code", "antigravity-cli", "claude-code", "codex-cli", "devin", "grok-cli", "hermes", "kimi-code", "opencode-cli"]>;
     sessionId: Schema.brand<typeof Schema.NonEmptyTrimmedString, "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", "grok-cli", "hermes", "kimi-code", "opencode-cli"]>;
+    adapter: Schema.Literal<["amp-code", "antigravity-cli", "claude-code", "codex-cli", "devin", "grok-cli", "hermes", "kimi-code", "opencode-cli"]>;
     workflowWorker: typeof Schema.Boolean;
     stableSessionIds: Schema.Literal<[true]>;
     exactSameSessionContinuation: Schema.Literal<[true]>;
@@ -19,7 +19,7 @@ export declare const WorkflowHarnessContinuationSupportSchema: Schema.Union<[Sch
     continueCommand: typeof Schema.NonEmptyTrimmedString;
     capture: typeof Schema.NonEmptyTrimmedString;
 }>, Schema.Struct<{
-    adapter: Schema.Literal<["amp-code", "antigravity-cli", "claude-code", "codex-cli", "grok-cli", "hermes", "kimi-code", "opencode-cli"]>;
+    adapter: Schema.Literal<["amp-code", "antigravity-cli", "claude-code", "codex-cli", "devin", "grok-cli", "hermes", "kimi-code", "opencode-cli"]>;
     workflowWorker: typeof Schema.Boolean;
     stableSessionIds: Schema.Literal<[false]>;
     exactSameSessionContinuation: Schema.Literal<[false]>;
@@ -32,6 +32,7 @@ export declare const workflowContinuationAdapterByWorker: {
     readonly "antigravity-cli": "antigravity-cli";
     readonly "claude-code": "claude-code";
     readonly "codex-cli": "codex-cli";
+    readonly devin: "devin";
     readonly grok: "grok-cli";
     readonly hermes: "hermes";
     readonly "kimi-code": "kimi-code";
@@ -104,6 +105,15 @@ export declare const workflowHarnessContinuationSupport: {
         readonly continueCommand: "kimi --session <sessionId> --prompt <prompt>";
         readonly capture: "stream-json session.resume_hint.session_id or session index recovery";
     };
+    readonly devin: {
+        readonly adapter: "devin";
+        readonly workflowWorker: true;
+        readonly stableSessionIds: true;
+        readonly exactSameSessionContinuation: true;
+        readonly sessionIdField: "sessionId";
+        readonly continueCommand: "devin -p -r <sessionId> --prompt-file <prompt>";
+        readonly capture: "ATIF export session_id via --export";
+    };
     readonly "opencode-cli": {
         readonly adapter: "opencode-cli";
         readonly workflowWorker: true;

package/types/workflow-store.d.ts

@@ -2,6 +2,7 @@ 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 WorkflowDatabase } from "./workflow-runtime.js";
+import type { WorkflowSpanRecord } from "./workflow-tracing.js";
 export type WorkflowTaskOutputSource = "mock-output";
 export interface CompletedWorkflowTaskRecord {
     readonly identity: WorkflowTaskIdentity;
@@ -140,6 +141,7 @@ export interface WorkflowRunRecord {
     readonly finishedAt: string | null;
     readonly runnerPid?: number;
     readonly heartbeatAt?: string;
+    readonly createdAt?: string;
 }
 export type WorkflowRunStatus = "running" | "completed" | "failed" | "escalated" | "unknown";
 /**
@@ -220,6 +222,15 @@ export declare class WorkflowStore {
         readonly type: string;
         readonly payload: unknown;
     }): void;
+    recordSpanStart(span: WorkflowSpanRecord): void;
+    recordSpanEnd(input: {
+        readonly spanId: string;
+        readonly endNs: bigint;
+        readonly status: "ok" | "error";
+        readonly errorMessage: string | null;
+        readonly attributes: Record<string, unknown>;
+    }): void;
+    listSpans(runId: string): WorkflowSpanRecord[];
     listRunEvents(runId: string): WorkflowEventRecord[];
     failDeadPidRuns(): WorkflowRunRecord[];
     failStaleRuns(olderThanMs: number, now?: Date): WorkflowRunRecord[];

package/types/workflow-tracing.d.ts

@@ -0,0 +1,85 @@
+import { Tracer } from "effect";
+import type { WorkflowStore } from "./workflow-store.js";
+export type WorkflowSpanStatus = "ok" | "error" | "unset";
+/** One row in `workflow_spans` — the sqlite-native span shape shared by the engine, the Effect tracer bridge, and the CLI trace renderer. */
+export interface WorkflowSpanRecord {
+    readonly runId: string;
+    readonly traceId: string;
+    readonly spanId: string;
+    readonly parentSpanId: string | null;
+    readonly taskId: string | null;
+    readonly name: string;
+    readonly kind: string;
+    readonly startNs: bigint;
+    readonly endNs: bigint | null;
+    readonly status: WorkflowSpanStatus;
+    readonly errorMessage: string | null;
+    readonly attributes: Record<string, unknown>;
+}
+export declare const generateWorkflowTraceId: () => string;
+export declare const generateWorkflowSpanId: () => string;
+export declare const currentTimeNanos: () => bigint;
+export interface WorkflowSpanStartInput {
+    readonly traceId: string;
+    readonly spanId: string;
+    readonly parentSpanId: string | null;
+    readonly taskId: string | null;
+    readonly name: string;
+    readonly kind: string;
+    readonly startNs: bigint;
+}
+export interface WorkflowSpanEndInput {
+    readonly spanId: string;
+    readonly endNs: bigint;
+    readonly status: Exclude<WorkflowSpanStatus, "unset">;
+    readonly errorMessage: string | null;
+    readonly attributes: Record<string, unknown>;
+}
+export interface WorkflowSpanHandle {
+    readonly spanId: string;
+    readonly traceId: string;
+    annotate(key: string, value: unknown): void;
+    end(status: Exclude<WorkflowSpanStatus, "unset">, error?: unknown): void;
+}
+/**
+ * The per-run span sink. Spans are written to the run's own sqlite store
+ * (start row on open, end update on close) so a killed run still shows its
+ * partial trace, and a running run is traceable live. When the run is not
+ * persisted (no store / null runId) every operation is a no-op.
+ */
+export interface WorkflowTraceRecorder {
+    readonly enabled: boolean;
+    readonly traceId: string;
+    recordSpanStart(input: WorkflowSpanStartInput): void;
+    recordSpanEnd(input: WorkflowSpanEndInput): void;
+    startSpan(name: string, options?: {
+        readonly parentSpanId?: string | null;
+        readonly taskId?: string | null;
+        readonly attributes?: Record<string, unknown>;
+    }): WorkflowSpanHandle;
+}
+export declare const createWorkflowTraceRecorder: (input: {
+    readonly store?: WorkflowStore;
+    readonly runId: string | null;
+    readonly traceId?: string;
+}) => WorkflowTraceRecorder;
+export declare const makeWorkflowEffectTracer: (recorder: WorkflowTraceRecorder, options?: {
+    readonly defaultParentSpanId?: string;
+}) => Tracer.Tracer;
+export interface WorkflowSpanTreeNode {
+    readonly span: WorkflowSpanRecord;
+    readonly children: ReadonlyArray<WorkflowSpanTreeNode>;
+}
+/** Spans whose parent is unknown (or absent) become roots; children stay in start order. */
+export declare const buildWorkflowSpanTree: (spans: ReadonlyArray<WorkflowSpanRecord>) => ReadonlyArray<WorkflowSpanTreeNode>;
+export declare const renderWorkflowTraceHuman: (spans: ReadonlyArray<WorkflowSpanRecord>, options?: {
+    readonly minDurationMs?: number;
+}) => string;
+/**
+ * Serialize span records as an OTLP/HTTP JSON `ExportTraceServiceRequest`,
+ * POSTable to any collector's `/v1/traces` endpoint.
+ */
+export declare const workflowSpansToOtlpJson: (spans: ReadonlyArray<WorkflowSpanRecord>, resource: {
+    readonly serviceName: string;
+    readonly attributes?: Record<string, unknown>;
+}) => unknown;

package/types/workflows.d.ts

@@ -58,7 +58,7 @@ export interface WorkflowValidationSummary {
 }
 export type WorkflowOutputSchema = Schema.Schema.AnyNoContext;
 export type WorkflowFinishCriterionError = Error;
-export type WorkflowWorkerId = "amp-code" | "antigravity-cli" | "claude-code" | "codex-cli" | "grok" | "hermes" | "kimi-code" | "opencode";
+export type WorkflowWorkerId = "amp-code" | "antigravity-cli" | "claude-code" | "codex-cli" | "devin" | "grok" | "hermes" | "kimi-code" | "opencode";
 export type WorkflowPermissionMode = "legacy" | "permissive" | "restricted" | "interactive" | "sandbox-read-only" | "sandbox-workspace-write" | "full-access";
 export type AntigravityWorkflowPermissionMode = Extract<WorkflowPermissionMode, "legacy" | "permissive" | "full-access">;
 type WorkflowTaskWorkerOptionsBase = {
@@ -177,8 +177,43 @@ export interface WorkflowDefinition<Name extends string, Tasks extends ReadonlyA
     readonly name: Name;
     readonly tasks: Tasks;
 }
+export interface PhaseFraming {
+    readonly telos?: string;
+    readonly when?: string;
+    readonly coordination?: string;
+    readonly escalation?: string;
+}
+export interface PhaseContract<Name extends string, Agents extends Readonly<Record<string, WorkflowAgentRef>>, Output extends WorkflowOutputSchema> {
+    readonly name: Name;
+    readonly orbit: string;
+    readonly plugin: string;
+    readonly agents: Agents;
+    readonly output: Output;
+    readonly criteria?: readonly string[];
+    readonly framing?: PhaseFraming;
+}
+export type PhaseTaskFinishOptions<Output> = WorkflowFinishOptions<Output> & {
+    readonly inherit?: boolean;
+};
+export type PhaseTaskDefinition<Id extends string, Agent extends WorkflowAgentRef, Output extends WorkflowOutputSchema = WorkflowOutputSchema> = Omit<WorkflowTaskDefinition<Id, Agent, Output>, "output" | "phase" | "finish"> & {
+    readonly output?: Output;
+    readonly phase?: string;
+    readonly finish?: PhaseTaskFinishOptions<Schema.Schema.Type<Output>>;
+    readonly brief?: boolean;
+};
+export type PhaseCtxTask<Agents extends Readonly<Record<string, WorkflowAgentRef>>, DefaultOutput extends WorkflowOutputSchema> = <const Id extends string, const Agent extends Agents[keyof Agents], const TaskOutput extends WorkflowOutputSchema = DefaultOutput>(def: PhaseTaskDefinition<Id, Agent, TaskOutput>) => Effect.Effect<WorkflowTaskOutput<WorkflowTask<Id, Agent, TaskOutput>>, WorkflowRuntimeError>;
+export interface PhaseCtx<Name extends string, Agents extends Readonly<Record<string, WorkflowAgentRef>>, DefaultOutput extends WorkflowOutputSchema> {
+    readonly name: Name;
+    readonly orbit: string;
+    readonly plugin: string;
+    readonly agents: Agents;
+    readonly phase: string;
+    readonly task: PhaseCtxTask<Agents, DefaultOutput>;
+}
+export declare const phase: <const Name extends string, const Agents extends Readonly<Record<string, WorkflowAgentRef>>, const Output extends WorkflowOutputSchema, Result, Err = WorkflowRuntimeError>(runtime: Pick<WorkflowRuntime, "runTask">, contract: PhaseContract<Name, Agents, Output>, fn: (ctx: PhaseCtx<Name, Agents, Output>) => Effect.Effect<Result, Err, never>) => Effect.Effect<Result, Err | WorkflowRuntimeError, never>;
 export interface WorkflowRuntime {
     runTask: <Task extends AnyWorkflowTask>(task: Task) => Effect.Effect<WorkflowTaskOutput<Task>, WorkflowRuntimeError>;
+    phase: <const Name extends string, const Agents extends Readonly<Record<string, WorkflowAgentRef>>, const Output extends WorkflowOutputSchema, Result, Err = WorkflowRuntimeError>(contract: PhaseContract<Name, Agents, Output>, fn: (ctx: PhaseCtx<Name, Agents, Output>) => Effect.Effect<Result, Err, never>) => Effect.Effect<Result, Err | WorkflowRuntimeError, never>;
 }
 export interface WorkflowRuntimeOptions {
     readonly fallbackWorker?: string;