@skastr0/prism-linux-x64 0.4.6 → 0.5.0

package/types/index.d.ts

@@ -3,9 +3,7 @@
  *
  * The canonical structured source model is TypeScript-first:
  * - agents/*.agent.ts
- * - traits/*.trait.ts
- * - orbits/*.orbit.ts
- * - toolspaces/*.toolspace.ts
+ * - sops/*.sop.ts
  * - modelspaces/*.modelspace.ts
  * - skillspaces/*.skillspace.ts
  * - hooks/*.hook.ts
@@ -22,27 +20,9 @@ export interface NamedRefDefinition {
     readonly plugin?: string;
     readonly name: string;
 }
-export interface TraitRefDefinition extends NamedRefDefinition {
-    readonly kind: "trait-ref";
-}
 export interface AgentRefDefinition extends NamedRefDefinition {
     readonly kind: "agent-ref";
 }
-export interface OrbitRefDefinition extends NamedRefDefinition {
-    readonly kind: "orbit-ref";
-}
-export interface ToolRefDefinition {
-    readonly kind: "tool-ref";
-    readonly plugin?: string;
-    readonly toolspace: string;
-    readonly name: string;
-}
-export interface ToolGroupRefDefinition {
-    readonly kind: "tool-group-ref";
-    readonly plugin?: string;
-    readonly toolspace: string;
-    readonly name: string;
-}
 export interface ModelProfileRefDefinition {
     readonly kind: "model-profile-ref";
     readonly plugin?: string;
@@ -60,27 +40,16 @@ export interface SkillspaceRefDefinition {
     readonly skillspace: string;
     readonly name: string;
 }
-export type TraitRefInput = string | TraitRefDefinition;
 export type AgentRefInput = string | AgentRefDefinition;
-export type OrbitRefInput = string | OrbitRefDefinition;
-export type ToolRefInput = string | ToolRefDefinition;
-export type ToolGroupRefInput = string | ToolGroupRefDefinition;
 export type ModelProfileRefInput = string | ModelProfileRefDefinition;
 export type SkillRefInput = SkillRefDefinition | SkillspaceRefDefinition;
 export type EffectSchemaValue = import("effect").Schema.Schema.AnyNoContext;
-export interface AccessDefinition {
-    readonly tools?: ReadonlyArray<ToolRefInput>;
-    readonly toolGroups?: ReadonlyArray<ToolGroupRefInput>;
-    readonly skills?: ReadonlyArray<SkillRefInput>;
-}
 export interface AgentDefinition {
     readonly name: string;
     readonly description: string;
     readonly identity: string;
     readonly personality?: string;
     readonly model?: ModelProfileRefInput;
-    readonly traits?: ReadonlyArray<TraitRefInput | TraitBindingSource>;
-    readonly access?: AccessDefinition;
     readonly skills?: ReadonlyArray<SkillRefInput>;
     readonly color?: string;
     readonly targets?: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
@@ -95,192 +64,37 @@ export interface CanonicalToolDefinition {
     readonly handle: (input: unknown, context: import("./compile/runtime/schema-bridge").ToolRuntimeContext) => Promise<unknown>;
 }
 export type ToolSource = CanonicalToolDefinition;
-export interface TraitDefinition {
-    readonly name: string;
-    readonly description?: string;
-    readonly instructions?: string | ReadonlyArray<string>;
-    readonly access?: AccessDefinition;
-    readonly tools?: Readonly<Record<string, TraitToolAttachmentDefinition>>;
-    readonly inject?: {
-        readonly skills?: ReadonlyArray<SkillRefInput>;
-    };
-    readonly require?: {
-        readonly tools?: ReadonlyArray<string>;
-        readonly skills?: ReadonlyArray<SkillRefInput>;
-    };
-}
-export type TraitSource = TraitDefinition;
-export interface TraitBindingDefinition {
-    readonly kind: "trait-binding";
-    readonly trait: TraitRefInput;
-    readonly tools?: Readonly<Record<string, TraitBindingToolDefinition>>;
-}
-export interface PlainTraitBindingDefinition {
-    readonly trait: TraitRefInput;
-    readonly tools?: Readonly<Record<string, TraitBindingToolDefinition>>;
-}
-export type TraitBindingSource = TraitBindingDefinition | PlainTraitBindingDefinition;
 export interface ToolSchemaSlotDefinition {
     readonly kind: "schema";
     readonly description?: string;
 }
 export type ToolSlotDefinition = ToolSchemaSlotDefinition;
-export interface TraitBindingToolDefinition {
-    readonly slots?: Readonly<Record<string, EffectSchemaValue>>;
-}
-export interface TraitToolAttachmentDefinition {
-    readonly ref: string;
-}
-export interface OrbitParameterDefinition {
-    readonly name: string;
-    readonly description?: string;
-    readonly required?: boolean;
-}
-export interface OrbitBindingDefinition {
-    readonly orbit: OrbitRefInput;
-    readonly bindings?: Readonly<Record<string, string>>;
-}
-export interface OrbitTraitRequirementDefinition {
-    readonly all: ReadonlyArray<TraitRefInput>;
-    readonly min?: number;
-}
-export type OrbitToolPermissionToolDefinition = string | {
-    readonly ref: string;
-    readonly as?: string;
-};
-export interface OrbitOrchestratorDefinition {
-    readonly agent: AgentRefInput;
-    readonly tools: ReadonlyArray<OrbitToolPermissionToolDefinition>;
-}
-export interface OrbitPhaseWorkflowDefinition {
-    readonly when?: string;
-    readonly inputs?: ReadonlyArray<string>;
-    readonly outputs?: ReadonlyArray<string>;
-    readonly sequence?: ReadonlyArray<string>;
-    readonly coordination?: string;
-    readonly finish_criteria?: ReadonlyArray<string>;
-    readonly escalation?: string;
-}
-export interface OrbitPhaseDefinition {
+export interface SopPhaseDefinition {
     readonly name: string;
-    readonly orbit?: OrbitRefInput;
-    readonly orbit_binding?: OrbitBindingDefinition;
-    readonly agents?: ReadonlyArray<AgentRefInput>;
-    readonly agent?: AgentRefInput;
-    readonly requires?: ReadonlyArray<OrbitTraitRequirementDefinition>;
-    readonly notes?: Readonly<Record<string, string>>;
-    /**
-     * Short structured fields rendered into the root orbit SKILL.md per-phase
-     * block. Use these to describe the phase at a glance; deep content belongs
-     * in `body` (which lowers to `references/<phase>.md`).
-     */
-    readonly telos?: string;
-    readonly real_world_change?: string;
-    readonly cold_pickup_test?: string;
-    /**
-     * Generic workflow-authoring guidance for this phase. Prism renders this
-     * 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
-     * the full phase download — telos, procrastination shapes, per-agent
-     * focus, links to deeper modules.
-     */
-    readonly body?: string;
-}
-export interface OrbitPulsarCheckpointDefinition {
-    readonly after?: string;
-    readonly before?: string;
-    readonly note?: string;
-}
-export type OrbitSignalEmitterPriority = "low" | "normal" | "high" | "urgent";
-export interface OrbitSignalEmitterDestinationDefinition {
-    readonly project_key: string;
-    readonly orbit: string;
-    readonly default_priority?: OrbitSignalEmitterPriority;
-    readonly note?: string;
-}
-export interface OrbitSignalEmitterDefinition {
-    /**
-     * Known destinations this orbit may emit signals to. Each entry is a
-     * `project_key`/`orbit` pair, optionally with a default priority and a
-     * note describing what the destination handles. Used as structural
-     * documentation, as input for delegation-map validation, and as the
-     * basis for tighter bound trait surfaces (e.g., per-destination
-     * delegate wrappers) when wanted.
-     *
-     * Leaving this empty marks the orbit as an emitter without constraining
-     * destinations — appropriate when the routing table is fluid or
-     * authored entirely in agent doctrine. Filled destinations make the
-     * permission surface explicit and reviewable.
-     */
-    readonly destinations?: ReadonlyArray<OrbitSignalEmitterDestinationDefinition>;
-}
-export interface OrbitDefinitionEntryDefinition {
     readonly purpose: string;
-    readonly contains?: ReadonlyArray<string>;
-    readonly boundaries?: ReadonlyArray<string>;
-    readonly avoid?: ReadonlyArray<string>;
-}
-export interface OrbitDefinitionsDefinition {
-    readonly glyphs?: OrbitDefinitionEntryDefinition;
-    readonly dispatches?: OrbitDefinitionEntryDefinition;
-    readonly chatter?: OrbitDefinitionEntryDefinition;
-    readonly signals?: OrbitDefinitionEntryDefinition;
+    /** Optional typed phase input contract (Effect Schema). */
+    readonly input?: EffectSchemaValue;
+    /** Optional typed phase output contract (Effect Schema). */
+    readonly output?: EffectSchemaValue;
+    /** Judge-level bars a schema cannot express. */
+    readonly acceptance_criteria?: ReadonlyArray<string>;
+    /** When to stop and ask a human. */
+    readonly escalation?: string;
+    /** Full procedure prose for this phase — steps, failure modes, examples. */
+    readonly body: string;
 }
-export interface OrbitDefinition {
+/**
+ * A SOP is a type-safe procedure. It may say what must be true; it never
+ * names who executes it, with what tool, or in what runtime.
+ */
+export interface SopDefinition {
     readonly name: string;
     readonly description: string;
-    readonly produces?: string;
-    readonly definitions?: OrbitDefinitionsDefinition;
-    readonly parameters?: ReadonlyArray<OrbitParameterDefinition>;
-    readonly phases: ReadonlyArray<OrbitPhaseDefinition>;
-    readonly orchestrator?: OrbitOrchestratorDefinition;
-    readonly tool_permissions?: ReadonlyArray<OrbitToolPermissionToolDefinition>;
-    readonly pulsar_checkpoints?: ReadonlyArray<OrbitPulsarCheckpointDefinition>;
-    readonly evolution?: string;
+    readonly phases: ReadonlyArray<SopPhaseDefinition>;
+    /** Cross-phase frame for the whole procedure. */
     readonly body?: string;
-    /**
-     * When present, declares this orbit emits signals to other orbits — the
-     * routing/delegation surface that is privileged separately from the
-     * receive-side signal tools. Authors should attach the `signal-emitter`
-     * trait (from the `oracle` plugin) to the orchestrator agent (and to
-     * any other phase agent that authentically owns inter-orbit
-     * delegation). Declared `destinations` make the routing surface
-     * explicit and auditable.
-     */
-    readonly signal_emitter?: OrbitSignalEmitterDefinition;
-}
-export type OrbitSource = OrbitDefinition;
-export interface ToolTargetBindingDefinition {
-    readonly name: string;
-}
-export interface ToolDefinition {
-    readonly description?: string;
-    readonly targets: Readonly<Record<string, ToolTargetBindingDefinition>>;
-}
-export interface ToolGroupDefinition {
-    readonly description?: string;
-    readonly tools: ReadonlyArray<ToolRefInput>;
 }
-export interface ToolspaceDefinition {
-    readonly name: string;
-    readonly description?: string;
-    readonly tools: Readonly<Record<string, ToolDefinition>>;
-    readonly groups?: Readonly<Record<string, ToolGroupDefinition>>;
-}
-export type ToolspaceSource = ToolspaceDefinition;
+export type SopSource = SopDefinition;
 export interface ModelTargetDefinition {
     readonly model: string;
     readonly variant?: string;
@@ -493,19 +307,15 @@ export type HookHandlerDefinition<E extends HookEvent> = (event: HookEventPayloa
 export interface HookAnyToolMatcherDefinition {
     readonly kind: "hook-any-tool";
 }
-export interface HookToolspaceToolMatcherDefinition {
-    readonly kind: "hook-toolspace-tool";
-    readonly tool: ToolRefInput;
-}
-export interface HookToolspaceGroupMatcherDefinition {
-    readonly kind: "hook-toolspace-group";
-    readonly group: ToolGroupRefInput;
+export interface HookNativeToolMatcherDefinition {
+    readonly kind: "hook-native-tool";
+    readonly name: string;
 }
 export interface HookCanonicalToolMatcherDefinition {
     readonly kind: "hook-canonical-tool";
     readonly ref: string;
 }
-export type HookToolMatcherDefinition = HookAnyToolMatcherDefinition | HookToolspaceToolMatcherDefinition | HookToolspaceGroupMatcherDefinition | HookCanonicalToolMatcherDefinition;
+export type HookToolMatcherDefinition = HookAnyToolMatcherDefinition | HookNativeToolMatcherDefinition | HookCanonicalToolMatcherDefinition;
 export interface ToolHookMatchDefinition {
     readonly tool?: HookToolMatcherDefinition;
 }
@@ -528,16 +338,8 @@ export declare const withNamedRef: <TKind extends string>(kind: TKind, first: st
     readonly plugin?: string;
     readonly name: string;
 };
-export declare function traitRef(name: string): TraitRefDefinition;
-export declare function traitRef(plugin: string, name: string): TraitRefDefinition;
 export declare function agentRef(name: string): AgentRefDefinition;
 export declare function agentRef(plugin: string, name: string): AgentRefDefinition;
-export declare function orbitRef(name: string): OrbitRefDefinition;
-export declare function orbitRef(plugin: string, name: string): OrbitRefDefinition;
-export declare function toolRef(toolspace: string, name: string): ToolRefDefinition;
-export declare function toolRef(plugin: string, toolspace: string, name: string): ToolRefDefinition;
-export declare function toolGroupRef(toolspace: string, name: string): ToolGroupRefDefinition;
-export declare function toolGroupRef(plugin: string, toolspace: string, name: string): ToolGroupRefDefinition;
 export declare function modelProfileRef(modelspace: string, name: string): ModelProfileRefDefinition;
 export declare function modelProfileRef(plugin: string, modelspace: string, name: string): ModelProfileRefDefinition;
 export declare function skillRef(name: string): SkillRefDefinition;
@@ -545,20 +347,15 @@ export declare function skillRef(plugin: string, name: string): SkillRefDefiniti
 export declare function skillspaceRef(skillspace: string, name: string): SkillspaceRefDefinition;
 export declare function skillspaceRef(plugin: string, skillspace: string, name: string): SkillspaceRefDefinition;
 export declare const schemaSlot: (options?: Omit<ToolSchemaSlotDefinition, "kind">) => ToolSchemaSlotDefinition;
-export declare const bindTrait: (trait: TraitRefInput, options?: {
-    readonly tools?: Readonly<Record<string, TraitBindingToolDefinition>>;
-}) => TraitBindingDefinition;
 export declare const hookTool: {
     readonly any: () => HookAnyToolMatcherDefinition;
-    readonly tool: (tool: ToolRefInput) => HookToolspaceToolMatcherDefinition;
-    readonly group: (group: ToolGroupRefInput) => HookToolspaceGroupMatcherDefinition;
+    readonly native: (name: string) => HookNativeToolMatcherDefinition;
     readonly canonical: (ref: string) => HookCanonicalToolMatcherDefinition;
 };
 export declare const hookMatcher: {
     readonly tool: {
         readonly any: () => HookAnyToolMatcherDefinition;
-        readonly tool: (tool: ToolRefInput) => HookToolspaceToolMatcherDefinition;
-        readonly group: (group: ToolGroupRefInput) => HookToolspaceGroupMatcherDefinition;
+        readonly native: (name: string) => HookNativeToolMatcherDefinition;
         readonly canonical: (ref: string) => HookCanonicalToolMatcherDefinition;
     };
 };

package/types/lowerer-capabilities.d.ts

@@ -65,7 +65,7 @@ export declare const LOWERER_CAPABILITIES: {
             readonly skills: {
                 readonly kind: "markdown-file";
                 readonly path: "<generated-plugin>/skills/";
-                readonly summary: "Compile bundles targeted skills and orbit skills as Agent Skills.";
+                readonly summary: "Compile bundles targeted skills and concrete sop skills as Agent Skills.";
             };
             readonly generatedTools: {
                 readonly kind: "direct-file";
@@ -246,7 +246,7 @@ export declare const LOWERER_CAPABILITIES: {
             readonly skills: {
                 readonly kind: "native-plugin-bundle";
                 readonly path: "<generated-plugin>/skills/";
-                readonly summary: "Compile bundles targeted skills and orbit skills.";
+                readonly summary: "Compile bundles targeted skills and concrete sop skills.";
             };
             readonly generatedTools: {
                 readonly kind: "direct-file";
@@ -294,7 +294,7 @@ export declare const LOWERER_CAPABILITIES: {
             readonly skills: {
                 readonly kind: "native-plugin-bundle";
                 readonly path: "<generated-plugin>/skills/";
-                readonly summary: "Compile bundles targeted plugin skills and orbit skills into the generated Kimi plugin.";
+                readonly summary: "Compile bundles targeted plugin skills and concrete sop skills into the generated Kimi plugin.";
             };
             readonly generatedTools: {
                 readonly kind: "direct-file";
@@ -362,7 +362,7 @@ export declare const LOWERER_CAPABILITIES: {
     readonly cursor: {
         readonly harness: "cursor";
         readonly family: "coding-harness";
-        readonly workflowWorker: false;
+        readonly workflowWorker: true;
         readonly compile: CompileTargetCapabilities;
         readonly surfaces: {
             readonly pluginBundle: {
@@ -380,21 +380,29 @@ export declare const LOWERER_CAPABILITIES: {
                 readonly path: "<generated-plugin>/commands/";
                 readonly summary: "Install writes Cursor commands inside the generated local plugin bundle.";
             };
-            readonly agents: LowererSurfaceCapability;
+            readonly agents: {
+                readonly kind: "native-plugin-bundle";
+                readonly path: "<generated-plugin>/agents/";
+                readonly summary: "Compiled agents lower as Cursor plugin subagent markdown (name/description/model).";
+            };
             readonly skills: {
                 readonly kind: "direct-file";
                 readonly path: "<cursor-root>/skills/";
-                readonly summary: "Install writes Agent Skill folders.";
+                readonly summary: "Install writes Agent Skill folders; concrete sop skills also bundle into the generated plugin.";
             };
             readonly generatedTools: {
                 readonly kind: "direct-file";
                 readonly path: "<prism-home>/runtime/tools/<plugin>/runtime.mjs";
                 readonly summary: "Canonical tools lower to the CLI runtime; agents invoke via `prism tools invoke`.";
             };
-            readonly hooks: LowererSurfaceCapability;
+            readonly hooks: {
+                readonly kind: "native-plugin-bundle";
+                readonly path: "<generated-plugin>/hooks/hooks.json";
+                readonly summary: "Prism hooks lower to Cursor plugin command hooks (hooks.json + wrappers), not an SDK.";
+            };
             readonly agentConfig: LowererSurfaceCapability;
         };
-        readonly notes: readonly ["Cursor compile support is tools-only for now; compiled agents, orbits, hooks, and skill permission visibility remain unsupported.", "Cursor command artifacts install through a local plugin bundle under ~/.cursor/plugins/local so Prism uses Cursor's native command discovery instead of direct command files.", "Cursor Agent Skills are docs-backed under .cursor/skills and ~/.cursor/skills, so Prism keeps install-phase skills direct.", "Cursor canonical tools are CLI-only (`prism tools invoke`); no mcp.json patch is emitted."];
+        readonly notes: readonly ["Compiled Cursor agents are plugin subagents under plugins/local/prism-generated-<plugin>/agents/. The Agent CLI has no --agent selector, so the workflow worker still prompt-injects identity.", "Cursor plugin hooks are Claude-shaped command scripts: hooks/hooks.json plus hooks/*.mjs, loaded from the generated plugin and --plugin-dir. Do not whole-file own ~/.cursor/hooks.json.", "Workflow worker dispatches `agent --print --output-format stream-json --trust`; default model composer-2.5-fast; resume via --resume.", "Cursor command artifacts install through the same local plugin bundle so Prism uses Cursor's native command discovery instead of direct command files.", "Cursor Agent Skills stay install-phase direct under .cursor/skills and ~/.cursor/skills. Concrete sop skills bundle into the generated plugin.", "Per-agent skill permission visibility remains unsupported. Canonical tools stay CLI-only (`prism tools invoke`); no mcp.json patch is emitted."];
     };
     readonly "factory-droid": {
         readonly harness: "factory-droid";
@@ -473,7 +481,7 @@ export declare const LOWERER_CAPABILITIES: {
             readonly skills: {
                 readonly kind: "native-plugin-bundle";
                 readonly path: "<generated-package>/skills/";
-                readonly summary: "Compile bundles targeted skills and concrete orbit skills into the generated Pi package.";
+                readonly summary: "Compile bundles targeted skills and concrete sop skills into the generated Pi package.";
             };
             readonly generatedTools: {
                 readonly kind: "native-plugin-api";
@@ -567,7 +575,7 @@ export declare const LOWERER_CAPABILITIES: {
             readonly skills: {
                 readonly kind: "native-plugin-bundle";
                 readonly path: "<generated-plugin>/skills/";
-                readonly summary: "Compile bundles targeted skills and orbit skills.";
+                readonly summary: "Compile bundles targeted skills and concrete sop skills.";
             };
             readonly generatedTools: {
                 readonly kind: "direct-file";
@@ -617,11 +625,7 @@ export declare const LOWERER_CAPABILITIES: {
                 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 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 agentConfig: LowererSurfaceCapability;
         };
         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."];
     };

package/types/prism-home.d.ts

@@ -0,0 +1,35 @@
+import { Schema } from "effect";
+export declare const PRISM_CONFIG_SCHEMA_VERSION = 1;
+export declare const DEFAULT_BACKUP_RETENTION_PER_TARGET = 3;
+export declare const BackupModeSchema: Schema.Literal<["always", "never"]>;
+export type BackupMode = typeof BackupModeSchema.Type;
+export interface PrismBackupConfig {
+    readonly mode: BackupMode;
+    readonly retentionPerTarget: number;
+}
+export interface PrismConfig {
+    readonly version: typeof PRISM_CONFIG_SCHEMA_VERSION;
+    readonly backup: PrismBackupConfig;
+}
+/**
+ * Resolve the Prism home directory from an override or the environment.
+ *
+ * WS2+: new code must NOT call this from library modules — consume the
+ * `PrismHome` Context.Tag from src/services/prism-env.ts instead; the env
+ * read happens exactly once at the CLI edge layer.
+ */
+export declare const resolvePrismHome: (override?: string) => string;
+export declare const prismConfigPath: (prismHome?: string) => string;
+export declare const prismStateDir: (prismHome?: string) => string;
+export declare const prismBackupDir: (prismHome?: string) => string;
+/**
+ * Machine home root for authored workflow sources: `~/.prism/workflows/`.
+ * Workflows are ephemeral orchestration instruments that reference their
+ * target repos by absolute path, so they belong in the home root, never
+ * inside (or `git add`-ed into) the project they operate on — see the
+ * "Where workflow files live" section of the prism workflow-authoring skill.
+ * `prism workflow scaffold` writes here by default (PQ-176).
+ */
+export declare const prismWorkflowsSourceDir: (prismHome?: string) => string;
+export declare const defaultPrismConfig: () => PrismConfig;
+export declare const readPrismConfig: (prismHome?: string) => Promise<PrismConfig>;

package/types/project-key.d.ts

@@ -44,5 +44,5 @@ export declare const projectStateDir: (prismHome: string, key: string) => string
 export declare const projectCompileManifestPath: (prismHome: string, key: string) => string;
 /** ~/.prism/state/projects/<key>/generated — Prism-owned generated refs dir. */
 export declare const projectGeneratedRefsDir: (prismHome: string, key: string) => string;
-/** ~/.prism/state/projects/<key>/generated/agents.ts — the agents refs file. */
-export declare const projectGeneratedAgentsPath: (prismHome: string, key: string) => string;
+/** ~/.prism/state/projects/<key>/generated/sops.ts — the sop refs file (surface sentinel). */
+export declare const projectGeneratedSopsPath: (prismHome: string, key: string) => string;

package/types/types.d.ts

@@ -26,7 +26,7 @@ export interface HarnessConfig {
 }
 export declare const PLUGIN_ARTIFACT_TYPES: readonly ["rules", "commands", "agents", "skills"];
 export type PluginArtifactType = (typeof PLUGIN_ARTIFACT_TYPES)[number];
-export declare const COMPILE_ARTIFACT_TYPES: readonly ["orbits", "tools", "toolspaces", "modelspaces", "skillspaces", "hooks"];
+export declare const COMPILE_ARTIFACT_TYPES: readonly ["sops", "tools", "modelspaces", "skillspaces", "hooks"];
 export type CompileArtifactType = (typeof COMPILE_ARTIFACT_TYPES)[number];
 export declare const TARGET_PRESET_IDS: readonly ["coding-harness", "claw-harness"];
 export type TargetPresetId = (typeof TARGET_PRESET_IDS)[number];
@@ -44,7 +44,6 @@ export interface PluginManifest {
     deps?: Record<string, string>;
     runtime?: PluginRuntimeConfig;
     projects?: Record<string, ProjectConfig>;
-    inlineSkills?: string[];
 }
 export interface ProjectConfig {
     pattern?: string;

package/types/workflow-errors.d.ts

@@ -5,6 +5,13 @@ export declare class WorkflowTaskDecodeError extends Error {
     readonly name = "WorkflowTaskDecodeError";
     constructor(taskId: string, cause: unknown);
 }
+/** A `ctx.task({ input })` value failed the bound SOP phase's input contract. */
+export declare class WorkflowTaskInputError extends Error {
+    readonly phase: string;
+    readonly cause: unknown;
+    readonly name = "WorkflowTaskInputError";
+    constructor(phase: string, cause: unknown);
+}
 export declare class WorkflowRunStoppedError extends Error {
     readonly runId: string;
     readonly name = "WorkflowRunStoppedError";
@@ -25,4 +32,4 @@ export declare class WorkflowUnsupportedHarnessError extends Error {
     readonly name = "WorkflowUnsupportedHarnessError";
     constructor(harness: string, validHarnesses: ReadonlyArray<string>);
 }
-export type WorkflowRuntimeError = WorkflowBunRuntimeUnavailableError | WorkflowUnsupportedHarnessError | WorkflowTaskDecodeError | WorkflowTaskEscalatedError | WorkflowRunStoppedError | Error;
+export type WorkflowRuntimeError = WorkflowBunRuntimeUnavailableError | WorkflowUnsupportedHarnessError | WorkflowTaskDecodeError | WorkflowTaskInputError | WorkflowTaskEscalatedError | WorkflowRunStoppedError | Error;

package/types/workflow-identity.d.ts

@@ -16,7 +16,6 @@ export interface WorkflowTaskIdentity {
     readonly taskId: string;
     readonly cacheKey: string;
     readonly promptHash: string;
-    readonly agentManifestHash: string;
 }
 export interface WorkflowJudgeIdentity {
     readonly workflow: string;
@@ -33,14 +32,6 @@ export interface WorkflowRunTaskSnapshot {
     readonly prompt: string;
     readonly cacheKey: string;
     readonly promptHash: string;
-    readonly agentManifestHash: string;
-    readonly agent: {
-        readonly plugin: string;
-        readonly name: string;
-        readonly description: string;
-        readonly sourceHash: string;
-        readonly manifestHash: string;
-    };
     readonly worker?: {
         readonly worker?: string;
         readonly model?: string;

package/types/workflow-runner.d.ts

@@ -8,10 +8,6 @@ export interface WorkflowTaskExecution {
 export type WorkflowRunTaskResultStatus = "completed" | "failed" | "escalated";
 export interface WorkflowRunTaskResult {
     readonly id: string;
-    readonly agent: {
-        readonly plugin: string;
-        readonly name: string;
-    };
     readonly output: unknown;
     readonly cached: boolean;
     readonly status: WorkflowRunTaskResultStatus;

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", "devin", "grok-cli", "hermes", "kimi-code", "opencode-cli", "omp-cli"]>;
+export declare const WorkflowContinuationAdapterIdSchema: Schema.Literal<["amp-code", "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", "devin", "grok", "hermes", "kimi-code", "opencode", "omp"]>;
+export declare const WorkflowContinuationWorkerIdSchema: Schema.Literal<["amp-code", "antigravity-cli", "claude-code", "codex-cli", "cursor", "devin", "grok", "hermes", "kimi-code", "opencode", "omp"]>;
 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", "devin", "grok-cli", "hermes", "kimi-code", "opencode-cli", "omp-cli"]>;
+    adapter: Schema.Literal<["amp-code", "antigravity-cli", "claude-code", "codex-cli", "cursor", "devin", "grok-cli", "hermes", "kimi-code", "opencode-cli", "omp-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", "devin", "grok-cli", "hermes", "kimi-code", "opencode-cli", "omp-cli"]>;
+    adapter: Schema.Literal<["amp-code", "antigravity-cli", "claude-code", "codex-cli", "cursor", "devin", "grok-cli", "hermes", "kimi-code", "opencode-cli", "omp-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", "devin", "grok-cli", "hermes", "kimi-code", "opencode-cli", "omp-cli"]>;
+    adapter: Schema.Literal<["amp-code", "antigravity-cli", "claude-code", "codex-cli", "cursor", "devin", "grok-cli", "hermes", "kimi-code", "opencode-cli", "omp-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 cursor: "cursor";
     readonly devin: "devin";
     readonly grok: "grok-cli";
     readonly hermes: "hermes";
@@ -79,6 +80,15 @@ export declare const workflowHarnessContinuationSupport: {
         readonly continueCommand: "codex exec resume <sessionId> <prompt>";
         readonly capture: "session_meta payload id, rollout JSONL, app-server metadata, or session index recovery";
     };
+    readonly cursor: {
+        readonly adapter: "cursor";
+        readonly workflowWorker: true;
+        readonly stableSessionIds: true;
+        readonly exactSameSessionContinuation: true;
+        readonly sessionIdField: "sessionId";
+        readonly continueCommand: "agent --resume <sessionId> --print <prompt>";
+        readonly capture: "stream-json session_id";
+    };
     readonly "grok-cli": {
         readonly adapter: "grok-cli";
         readonly workflowWorker: true;