@weaveio/weave-adapter-opencode 0.0.0-preview-20260708084849

package/dist/runtime-command-projection.d.ts

@@ -0,0 +1,365 @@
+/**
+ * Runtime Command Projection — OpenCode adapter-owned command handlers and renderers.
+ *
+ * This module is the OpenCode adapter's projection layer for the six runtime
+ * command operations defined in the shared engine:
+ *
+ * | Command              | Engine operation      | OpenCode label            |
+ * |----------------------|-----------------------|---------------------------|
+ * | Start plan           | `startPlan`           | `/weave:start`            |
+ * | Run named workflow   | `runNamedWorkflow`    | `/weave:run`              |
+ * | Inspect status       | `inspectStatus`       | `/weave:status`           |
+ * | Abort execution      | `abortExecution`      | `/weave:abort`            |
+ * | Advance step         | `advanceStep`         | `/weave:advance`          |
+ * | Runtime health       | `runtimeHealth`       | `/weave:health`           |
+ *
+ * ## Boundary rules
+ *
+ * - Argument parsing, command labels, and OpenCode-specific messages are
+ *   adapter-owned and live here.
+ * - Lifecycle state-transition logic is **never duplicated** — all delegated
+ *   to the matching engine operation.
+ * - Native slash/TUI affordances that are not yet implemented in this slice
+ *   are documented as degraded equivalents (see `DEGRADED_AFFORDANCES`).
+ * - `/start-work` is out of scope for this module.
+ *
+ * ## Rendered result shapes
+ *
+ * Each handler returns a `ProjectionResult<T>` — a discriminated union of
+ * `success`, `failure`, and `degraded` outcomes. Adapters format these for
+ * slash commands, plugin tools, UI actions, or scripts without duplicating
+ * lifecycle logic.
+ *
+ * @see packages/engine/src/runtime-command-operations/types.ts — engine types
+ * @see packages/adapters/opencode/src/start-plan-execution.ts — /weave:start delivery path
+ * @see packages/adapters/opencode/src/run-workflow.ts — named-workflow execution
+ * @see docs/adapter-boundary.md
+ * @see docs/specs/30-spec-minimal-runtime-command-lifecycle/30-spec-minimal-runtime-command-lifecycle.md
+ */
+import type { AdapterHealthReport, AdvanceStepInput, CommandOperationError, ExecutionAbortedData, ExecutionStartedData, ExecutionStatusData, PlanStateProvider, RuntimeHealthData, RuntimeStore, StepAdvancedData } from "@weaveio/weave-engine";
+import type { OpenCodeAdapter } from "./adapter.js";
+/**
+ * OpenCode slash-command labels for each projected runtime command.
+ *
+ * These are adapter-owned identifiers. Core packages must never reference them.
+ * `/start-work` is out of scope for this module — see `start-plan-execution.ts`.
+ */
+export declare const WEAVE_COMMAND_LABELS: {
+    readonly startPlan: "/weave:start";
+    readonly runWorkflow: "/weave:run";
+    readonly status: "/weave:status";
+    readonly abort: "/weave:abort";
+    readonly advance: "/weave:advance";
+    readonly health: "/weave:health";
+};
+/**
+ * Native slash/TUI affordances that are not yet implemented in this slice.
+ *
+ * These are documented as degraded equivalents. Adapters that register
+ * OpenCode slash commands should surface these notes to users when the
+ * native affordance is unavailable.
+ */
+export declare const DEGRADED_AFFORDANCES: readonly {
+    readonly command: string;
+    readonly reason: string;
+    readonly equivalent: string;
+}[];
+/**
+ * A successful projection result carrying renderer-ready data.
+ */
+export interface ProjectionSuccess<T> {
+    readonly outcome: "success";
+    readonly command: string;
+    readonly data: T;
+    /** Human-readable summary for OpenCode slash-command output. */
+    readonly message: string;
+}
+/**
+ * A failed projection result carrying a typed engine error.
+ */
+export interface ProjectionFailure {
+    readonly outcome: "failure";
+    readonly command: string;
+    readonly error: CommandOperationError;
+    /** Human-readable error message for OpenCode slash-command output. */
+    readonly message: string;
+}
+/**
+ * A degraded projection result — the operation partially succeeded or ran
+ * with reduced capability.
+ */
+export interface ProjectionDegraded<T> {
+    readonly outcome: "degraded";
+    readonly command: string;
+    readonly data?: T;
+    /** Human-readable degradation reason for OpenCode slash-command output. */
+    readonly message: string;
+    /** Actionable hint for the user. */
+    readonly hint?: string;
+}
+/**
+ * Discriminated union of all projection result variants.
+ */
+export type ProjectionResult<T> = ProjectionSuccess<T> | ProjectionFailure | ProjectionDegraded<T>;
+/**
+ * Input for the projected start-plan command.
+ *
+ * Adapter-owned: argument parsing, default values, and OpenCode-specific
+ * fields are resolved here before delegating to the engine's `startPlan`.
+ */
+export interface StartPlanProjectionInput {
+    /** Name of the plan file to start. */
+    readonly planName: string;
+    /** Name of the workflow to use for plan execution. */
+    readonly workflowName: string;
+    /** Human-readable goal for this execution instance. */
+    readonly goal: string;
+    /** URL-safe slug for this execution instance. */
+    readonly slug: string;
+    /** Owner identifier for the execution lease. */
+    readonly ownerId: string;
+    /** Runtime store for persisting the workflow instance and lease. */
+    readonly store: RuntimeStore;
+    /** Provider for plan file existence checks. */
+    readonly planStateProvider: PlanStateProvider;
+    /** Workflow registry — maps workflow names to workflow configs. */
+    readonly workflows: Record<string, unknown>;
+    /** OpenCode adapter instance — `spawnSubagent` is called for each DispatchAgentEffect. */
+    readonly adapter: OpenCodeAdapter;
+    /** Optional ISO-8601 timestamp override (for testing). */
+    readonly now?: string;
+}
+/**
+ * Input for the projected run-named-workflow command.
+ *
+ * Adapter-owned: argument parsing, default values, and OpenCode-specific
+ * fields are resolved here before delegating to the engine's `runNamedWorkflow`.
+ */
+export interface RunWorkflowProjectionInput {
+    /** Name of the workflow to run. */
+    readonly workflowName: string;
+    /** Human-readable goal for this execution instance. */
+    readonly goal: string;
+    /** URL-safe slug for this execution instance. */
+    readonly slug: string;
+    /** Owner identifier for the execution lease. */
+    readonly ownerId: string;
+    /** Runtime store for persisting the workflow instance and lease. */
+    readonly store: RuntimeStore;
+    /** Workflow registry — maps workflow names to workflow configs. */
+    readonly workflows: Record<string, unknown>;
+    /** OpenCode adapter instance — `spawnSubagent` is called for each DispatchAgentEffect. */
+    readonly adapter: OpenCodeAdapter;
+    /** Optional plan state provider for plan_created/plan_complete steps. */
+    readonly planStateProvider?: PlanStateProvider;
+    /** Optional ISO-8601 timestamp override (for testing). */
+    readonly now?: string;
+}
+/**
+ * Input for the projected inspect-status command.
+ */
+export interface InspectStatusProjectionInput {
+    /** Workflow instance to inspect. */
+    readonly workflowInstanceId: string;
+    /** Runtime store for reading the workflow instance. */
+    readonly store: RuntimeStore;
+}
+/**
+ * Input for the projected abort-execution command.
+ */
+export interface AbortExecutionProjectionInput {
+    /** Workflow instance to abort. */
+    readonly workflowInstanceId: string;
+    /** Active lease ID for the execution. */
+    readonly leaseId: string;
+    /** Abort signal: `"cancel"` terminates; `"pause"` suspends. */
+    readonly signal: "cancel" | "pause";
+    /** Runtime store for reading/writing the workflow instance. */
+    readonly store: RuntimeStore;
+}
+/**
+ * Input for the projected advance-step command.
+ */
+export interface AdvanceStepProjectionInput {
+    /** Workflow instance containing the blocked step. */
+    readonly workflowInstanceId: string;
+    /** Active lease ID for the execution. */
+    readonly leaseId: string;
+    /** Name of the step to advance. */
+    readonly stepName: string;
+    /** Completion signal describing how the step finished. */
+    readonly completionSignal: AdvanceStepInput["completionSignal"];
+    /** Runtime store for reading/writing the workflow instance. */
+    readonly store: RuntimeStore;
+    /** Optional plan state provider for plan_created/plan_complete steps. */
+    readonly planStateProvider?: PlanStateProvider;
+    /** Optional workflow execution context for step completion routing. */
+    readonly context?: AdvanceStepInput["context"];
+}
+/**
+ * Input for the projected runtime-health command.
+ *
+ * Adapters build the `AdapterHealthReport` before calling this handler.
+ * The engine never performs harness-specific probes.
+ */
+export interface RuntimeHealthProjectionInput {
+    /** Adapter-supplied health report from the capability contract. */
+    readonly healthReport: AdapterHealthReport;
+    /** Explicit list of operations the adapter considers degraded. */
+    readonly degradedOperations?: readonly string[];
+    /** Explicit list of operations the adapter considers unsupported. */
+    readonly unsupportedOperations?: readonly string[];
+}
+/**
+ * OpenCode adapter-owned projection of the six runtime command operations.
+ *
+ * Each method:
+ * 1. Parses/validates adapter-owned arguments.
+ * 2. Delegates to the matching shared engine operation.
+ * 3. Renders a typed `ProjectionResult<T>` — success, failure, or degraded.
+ *
+ * No lifecycle state-transition logic is duplicated here. All lifecycle
+ * semantics are owned by the engine operations.
+ *
+ * ## Usage
+ *
+ * ```ts
+ * const projection = new RuntimeCommandProjection();
+ *
+ * const result = await projection.handleStartPlan({
+ *   planName: "feature-auth",
+ *   workflowName: "tapestry-execution",
+ *   goal: "Implement authentication",
+ *   slug: "implement-authentication",
+ *   ownerId: "weave:start",
+ *   store,
+ *   planStateProvider: adapter.planStateProvider,
+ *   workflows: config.workflows,
+ *   adapter,
+ * });
+ *
+ * result.match(
+ *   (r) => { if (r.outcome === "success") console.log(r.message); },
+ *   () => {}, // never — ProjectionResult is always ok
+ * );
+ * ```
+ */
+export declare class RuntimeCommandProjection {
+    /**
+     * Handle the `/weave:start` command — start execution of a named plan.
+     *
+     * Delegates to the engine's `startPlan` operation. Supplies the adapter-owned
+     * `projectEffect` callback that calls `adapter.spawnSubagent` for each
+     * `DispatchAgentEffect`. Returns a typed `ProjectionResult<ExecutionStartedData>`.
+     *
+     * No lifecycle state-transition logic is duplicated here.
+     *
+     * @param input - Start-plan projection parameters.
+     * @returns `ProjectionResult<ExecutionStartedData>` — always resolves (never rejects).
+     */
+    handleStartPlan(input: StartPlanProjectionInput): Promise<ProjectionResult<ExecutionStartedData>>;
+    /**
+     * Handle the `/weave:run` command — explicitly run a named workflow.
+     *
+     * Delegates to the engine's `runNamedWorkflow` operation. Supplies the
+     * adapter-owned `projectEffect` callback. Returns a typed
+     * `ProjectionResult<ExecutionStartedData>`.
+     *
+     * Named workflow execution is explicitly separate from ordinary plan
+     * execution. `/start-work` is out of scope for this handler.
+     *
+     * No lifecycle state-transition logic is duplicated here.
+     *
+     * @param input - Run-workflow projection parameters.
+     * @returns `ProjectionResult<ExecutionStartedData>` — always resolves.
+     */
+    handleRunWorkflow(input: RunWorkflowProjectionInput): Promise<ProjectionResult<ExecutionStartedData>>;
+    /**
+     * Handle the `/weave:status` command — read-only inspection of execution state.
+     *
+     * Delegates to the engine's `inspectStatus` operation. This is a read-only
+     * operation — it never creates instances, acquires leases, or emits effects.
+     *
+     * No lifecycle state-transition logic is duplicated here.
+     *
+     * @param input - Inspect-status projection parameters.
+     * @returns `ProjectionResult<ExecutionStatusData>` — always resolves.
+     */
+    handleInspectStatus(input: InspectStatusProjectionInput): Promise<ProjectionResult<ExecutionStatusData>>;
+    /**
+     * Handle the `/weave:abort` command — cancel or pause an active execution.
+     *
+     * Delegates to the engine's `abortExecution` operation. Returns a typed
+     * `ProjectionResult<ExecutionAbortedData>`.
+     *
+     * **Degraded affordance**: the native TUI abort button is not yet wired to
+     * this handler. Users can invoke it via plugin tool or script.
+     *
+     * No lifecycle state-transition logic is duplicated here.
+     *
+     * @param input - Abort-execution projection parameters.
+     * @returns `ProjectionResult<ExecutionAbortedData>` — always resolves.
+     */
+    handleAbortExecution(input: AbortExecutionProjectionInput): Promise<ProjectionResult<ExecutionAbortedData>>;
+    /**
+     * Handle the `/weave:advance` command — advance or complete a blocked step.
+     *
+     * Delegates to the engine's `advanceStep` operation. Returns a typed
+     * `ProjectionResult<StepAdvancedData>`.
+     *
+     * **Degraded affordance**: the native TUI step-advance UI is not yet wired
+     * to this handler. Users can invoke it via plugin tool or script.
+     *
+     * No lifecycle state-transition logic is duplicated here.
+     *
+     * @param input - Advance-step projection parameters.
+     * @returns `ProjectionResult<StepAdvancedData>` — always resolves.
+     */
+    handleAdvanceStep(input: AdvanceStepProjectionInput): Promise<ProjectionResult<StepAdvancedData>>;
+    /**
+     * Handle the `/weave:health` command — report adapter/runtime readiness.
+     *
+     * Delegates to the engine's `runtimeHealth` operation. This is a pure
+     * operation — it performs no harness I/O. Adapters build the
+     * `AdapterHealthReport` before calling this handler.
+     *
+     * Returns a typed `ProjectionResult<RuntimeHealthData>`. The result is
+     * always `success` (the engine's `runtimeHealth` never fails), but the
+     * data may indicate degraded or unsupported operations.
+     *
+     * No lifecycle state-transition logic is duplicated here.
+     *
+     * @param input - Runtime-health projection parameters.
+     * @returns `ProjectionResult<RuntimeHealthData>` — always resolves as success.
+     */
+    handleRuntimeHealth(input: RuntimeHealthProjectionInput): Promise<ProjectionResult<RuntimeHealthData>>;
+}
+/**
+ * Build a minimal `AdapterHealthReport` for the OpenCode adapter.
+ *
+ * This is a convenience helper for tests and plugin entry points that need
+ * to construct a health report without duplicating the capability contract
+ * boilerplate. Production callers should build a full capability contract
+ * using `buildAdapterHealthReport` from `@weaveio/weave-engine`.
+ *
+ * The report declares `command-entrypoints` as `emulated` (OpenCode exposes
+ * slash commands as the explicit delivery path) and all other required
+ * capabilities as `native` or `emulated` based on the adapter's known
+ * implementation state.
+ *
+ * @param overrides - Optional capability overrides for testing.
+ * @returns A normalized `AdapterHealthReport`.
+ */
+export declare function buildOpenCodeHealthReport(overrides?: {
+    readonly commandEntrypointsReadiness?: "native" | "emulated" | "degraded" | "unsupported";
+    readonly degradedOperations?: readonly string[];
+    readonly unsupportedOperations?: readonly string[];
+}): AdapterHealthReport;
+/**
+ * Create a default `InMemoryRuntimeStore` for use in projection handlers.
+ *
+ * Convenience re-export for callers that need a store without importing
+ * directly from `@weaveio/weave-engine`.
+ */
+export { createInMemoryRuntimeStore as createDefaultStore } from "@weaveio/weave-engine";
+//# sourceMappingURL=runtime-command-projection.d.ts.map

package/dist/runtime-command-projection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-command-projection.d.ts","sourceRoot":"","sources":["../src/runtime-command-projection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,OAAO,KAAK,EAEV,mBAAmB,EACnB,gBAAgB,EAChB,qBAAqB,EACrB,oBAAoB,EACpB,oBAAoB,EACpB,mBAAmB,EACnB,iBAAiB,EACjB,iBAAiB,EACjB,YAAY,EACZ,gBAAgB,EACjB,MAAM,uBAAuB,CAAC;AAY/B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AASpD;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB;;;;;;;CAOU,CAAC;AAM5C;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,EAAE,SAAS;IAC1C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B,EAWS,CAAC;AAMX;;GAEG;AACH,MAAM,WAAW,iBAAiB,CAAC,CAAC;IAClC,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;IACjB,gEAAgE;IAChE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,qBAAqB,CAAC;IACtC,sEAAsE;IACtE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;GAGG;AACH,MAAM,WAAW,kBAAkB,CAAC,CAAC;IACnC,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAClB,2EAA2E;IAC3E,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,oCAAoC;IACpC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAC1B,iBAAiB,CAAC,CAAC,CAAC,GACpB,iBAAiB,GACjB,kBAAkB,CAAC,CAAC,CAAC,CAAC;AAM1B;;;;;GAKG;AACH,MAAM,WAAW,wBAAwB;IACvC,sCAAsC;IACtC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,sDAAsD;IACtD,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,uDAAuD;IACvD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,iDAAiD;IACjD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,gDAAgD;IAChD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,oEAAoE;IACpE,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,+CAA+C;IAC/C,QAAQ,CAAC,iBAAiB,EAAE,iBAAiB,CAAC;IAC9C,mEAAmE;IACnE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC5C,0FAA0F;IAC1F,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAClC,0DAA0D;IAC1D,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;GAKG;AACH,MAAM,WAAW,0BAA0B;IACzC,mCAAmC;IACnC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,uDAAuD;IACvD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,iDAAiD;IACjD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,gDAAgD;IAChD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,oEAAoE;IACpE,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,mEAAmE;IACnE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC5C,0FAA0F;IAC1F,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAClC,yEAAyE;IACzE,QAAQ,CAAC,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;IAC/C,0DAA0D;IAC1D,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,4BAA4B;IAC3C,oCAAoC;IACpC,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,uDAAuD;IACvD,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;CAC9B;AAED;;GAEG;AACH,MAAM,WAAW,6BAA6B;IAC5C,kCAAkC;IAClC,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,yCAAyC;IACzC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,+DAA+D;IAC/D,QAAQ,CAAC,MAAM,EAAE,QAAQ,GAAG,OAAO,CAAC;IACpC,+DAA+D;IAC/D,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;CAC9B;AAED;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACzC,qDAAqD;IACrD,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,yCAAyC;IACzC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,mCAAmC;IACnC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,0DAA0D;IAC1D,QAAQ,CAAC,gBAAgB,EAAE,gBAAgB,CAAC,kBAAkB,CAAC,CAAC;IAChE,+DAA+D;IAC/D,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,yEAAyE;IACzE,QAAQ,CAAC,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;IAC/C,uEAAuE;IACvE,QAAQ,CAAC,OAAO,CAAC,EAAE,gBAAgB,CAAC,SAAS,CAAC,CAAC;CAChD;AAED;;;;;GAKG;AACH,MAAM,WAAW,4BAA4B;IAC3C,mEAAmE;IACnE,QAAQ,CAAC,YAAY,EAAE,mBAAmB,CAAC;IAC3C,kEAAkE;IAClE,QAAQ,CAAC,kBAAkB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAChD,qEAAqE;IACrE,QAAQ,CAAC,qBAAqB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACpD;AA2CD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,qBAAa,wBAAwB;IAKnC;;;;;;;;;;;OAWG;IACG,eAAe,CACnB,KAAK,EAAE,wBAAwB,GAC9B,OAAO,CAAC,gBAAgB,CAAC,oBAAoB,CAAC,CAAC;IA6ClD;;;;;;;;;;;;;;OAcG;IACG,iBAAiB,CACrB,KAAK,EAAE,0BAA0B,GAChC,OAAO,CAAC,gBAAgB,CAAC,oBAAoB,CAAC,CAAC;IA4ClD;;;;;;;;;;OAUG;IACG,mBAAmB,CACvB,KAAK,EAAE,4BAA4B,GAClC,OAAO,CAAC,gBAAgB,CAAC,mBAAmB,CAAC,CAAC;IAmCjD;;;;;;;;;;;;;OAaG;IACG,oBAAoB,CACxB,KAAK,EAAE,6BAA6B,GACnC,OAAO,CAAC,gBAAgB,CAAC,oBAAoB,CAAC,CAAC;IAwClD;;;;;;;;;;;;;OAaG;IACG,iBAAiB,CACrB,KAAK,EAAE,0BAA0B,GAChC,OAAO,CAAC,gBAAgB,CAAC,gBAAgB,CAAC,CAAC;IA4C9C;;;;;;;;;;;;;;;OAeG;IACG,mBAAmB,CACvB,KAAK,EAAE,4BAA4B,GAClC,OAAO,CAAC,gBAAgB,CAAC,iBAAiB,CAAC,CAAC;CAgDhD;AAMD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,yBAAyB,CAAC,SAAS,CAAC,EAAE;IACpD,QAAQ,CAAC,2BAA2B,CAAC,EACjC,QAAQ,GACR,UAAU,GACV,UAAU,GACV,aAAa,CAAC;IAClB,QAAQ,CAAC,kBAAkB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAChD,QAAQ,CAAC,qBAAqB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACpD,GAAG,mBAAmB,CAqFtB;AAMD;;;;;GAKG;AACH,OAAO,EAAE,0BAA0B,IAAI,kBAAkB,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/sdk-types.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Stable re-exports of `@opencode-ai/sdk` types used by the OpenCode adapter.
+ *
+ * This is the ONLY file in the adapter allowed to import directly from
+ * `@opencode-ai/sdk`. All other adapter modules must import from `./sdk-types`
+ * to insulate the rest of the adapter from SDK version churn.
+ *
+ * Only types that the adapter actively uses are re-exported here. Unused SDK
+ * types are intentionally omitted to keep the surface minimal.
+ */
+export type { 
+/**
+ * OpenCode agent descriptor as returned by the API — used when reading the
+ * current agent list from a running OpenCode instance.
+ */
+Agent as OpenCodeAgent, 
+/**
+ * OpenCode agent configuration shape — used when materialising a Weave
+ * `AgentDescriptor` into an OpenCode agent entry.
+ */
+AgentConfig as OpenCodeAgentConfig, 
+/**
+ * Top-level OpenCode config — used when reading or patching the running
+ * OpenCode configuration via the SDK client.
+ */
+Config as OpenCodeConfig, 
+/**
+ * OpenCode model descriptor — used for available-model lookup and
+ * model-intent resolution.
+ */
+Model as OpenCodeModel, 
+/**
+ * The generated SDK client class — used to communicate with a running
+ * OpenCode server instance.
+ */
+OpencodeClient, 
+/**
+ * Client configuration options — used when constructing an `OpencodeClient`.
+ */
+OpencodeClientConfig, 
+/**
+ * OpenCode provider descriptor — used when enumerating available providers
+ * and their models.
+ */
+Provider as OpenCodeProvider, 
+/**
+ * OpenCode session descriptor — used when querying active sessions.
+ */
+Session as OpenCodeSession, } from "@opencode-ai/sdk";
+export { 
+/**
+ * Factory function that creates a pre-configured `OpencodeClient` pointed at
+ * the running OpenCode server. Accepts an optional `directory` override.
+ */
+createOpencodeClient, } from "@opencode-ai/sdk";
+//# sourceMappingURL=sdk-types.d.ts.map

package/dist/sdk-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdk-types.d.ts","sourceRoot":"","sources":["../src/sdk-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,YAAY;AACV;;;GAGG;AACH,KAAK,IAAI,aAAa;AACtB;;;GAGG;AACH,WAAW,IAAI,mBAAmB;AAClC;;;GAGG;AACH,MAAM,IAAI,cAAc;AACxB;;;GAGG;AACH,KAAK,IAAI,aAAa;AACtB;;;GAGG;AACH,cAAc;AACd;;GAEG;AACH,oBAAoB;AACpB;;;GAGG;AACH,QAAQ,IAAI,gBAAgB;AAC5B;;GAEG;AACH,OAAO,IAAI,eAAe,GAC3B,MAAM,kBAAkB,CAAC;AAE1B,OAAO;AACL;;;GAGG;AACH,oBAAoB,GACrB,MAAM,kBAAkB,CAAC"}

package/dist/skill-discovery.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Adapter-local skill validation for the OpenCode adapter.
+ *
+ * This module provides helpers for working with harness-provided skill data.
+ * It does NOT perform filesystem scanning — skill discovery is owned by the
+ * OpenCode harness (SDK/runtime), which tells the adapter which skills are
+ * available. The adapter's role is to:
+ *
+ * 1. Accept the harness-provided `SkillInfo[]` list (injected at construction
+ *    time or supplied by the SDK at runtime).
+ * 2. Validate declared skill names against that list.
+ * 3. Surface missing declared skills as hard errors so the engine's
+ *    `resolveSkillsForAgent()` can emit `MissingSkill` errors.
+ *
+ * ## Adapter / Harness Boundary
+ *
+ * - **Harness-owned**: which skills exist, where their files live, how they
+ *   are loaded and mounted into an agent's context. The OpenCode SDK/runtime
+ *   provides this information.
+ * - **Adapter-owned**: receiving the harness-provided list, forwarding it to
+ *   the engine, and validating declared skill names against it.
+ * - **Engine-owned**: matching declared skill names against `SkillInfo.name`
+ *   values and emitting `MissingSkill` errors for unresolved names.
+ *
+ * ## Hard-error semantics
+ *
+ * Missing declared skills are hard errors (not silent skips). When an agent's
+ * `skills [...]` declaration references a skill that is not in the
+ * harness-provided list, `validateDeclaredSkills()` returns
+ * `err(MissingSkillsError)` with the missing names. Callers must not suppress
+ * those errors.
+ *
+ * Boundary rule: this module must not import from `@opencode-ai/sdk` directly.
+ * All SDK type imports flow through `./sdk-types`.
+ */
+import type { SkillInfo } from "@weaveio/weave-engine";
+import { type Result } from "neverthrow";
+/**
+ * Discriminated error returned by `validateDeclaredSkills()` when one or more
+ * declared skill names are absent from the harness-provided available list.
+ */
+export interface MissingSkillsError {
+    readonly type: "MissingSkillsError";
+    /** Names of the skills that were declared but not found in the available list. */
+    readonly missingSkills: string[];
+}
+/**
+ * Build a `SkillInfo[]` list from an explicit list of skill names.
+ *
+ * Use this when the harness SDK provides skill names as strings and you need
+ * to construct the `SkillInfo[]` list expected by the engine.
+ *
+ * @param names - Skill names provided by the harness.
+ * @returns `SkillInfo[]` with no adapter metadata.
+ */
+export declare function buildSkillInfoList(names: string[]): SkillInfo[];
+/**
+ * Validate that all declared skill names are present in the harness-provided
+ * available list.
+ *
+ * Returns `ok(void)` when all declared skills are available, or
+ * `err(MissingSkillsError)` with the names of missing skills.
+ *
+ * This is a convenience helper for adapters that want to validate skill
+ * availability before calling the engine's `resolveSkillsForAgent()`.
+ *
+ * @param declaredSkills - Skill names declared by the agent.
+ * @param availableSkills - Skills provided by the harness to the adapter.
+ * @param disabledSkills - Skill names that are globally disabled (skipped).
+ * @returns `ok(void)` when all non-disabled declared skills are available.
+ */
+export declare function validateDeclaredSkills(declaredSkills: string[], availableSkills: SkillInfo[], disabledSkills?: string[]): Result<void, MissingSkillsError>;
+//# sourceMappingURL=skill-discovery.d.ts.map

package/dist/skill-discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill-discovery.d.ts","sourceRoot":"","sources":["../src/skill-discovery.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAW,KAAK,MAAM,EAAE,MAAM,YAAY,CAAC;AAMlD;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAAC;IACpC,kFAAkF;IAClF,QAAQ,CAAC,aAAa,EAAE,MAAM,EAAE,CAAC;CAClC;AAMD;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,SAAS,EAAE,CAE/D;AAMD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CACpC,cAAc,EAAE,MAAM,EAAE,EACxB,eAAe,EAAE,SAAS,EAAE,EAC5B,cAAc,GAAE,MAAM,EAAO,GAC5B,MAAM,CAAC,IAAI,EAAE,kBAAkB,CAAC,CAelC"}

package/dist/start-plan-execution.d.ts

@@ -0,0 +1,164 @@
+/**
+ * start-plan-execution — adapter-owned projection of the engine's start-plan operation.
+ *
+ * This module is the OpenCode adapter's projection of the reusable `startPlan`
+ * engine operation. It supplies the adapter-owned `projectEffect` callback
+ * (calling `adapter.spawnSubagent`) and maps the engine's typed
+ * `CommandOperationError` result back to the adapter-owned
+ * `StartPlanExecutionError` discriminated union.
+ *
+ * ## Boundary rule
+ *
+ * This module is adapter-owned. It must not import from `@weaveio/weave-core` directly
+ * (config types are accepted as parameters, not fetched). Command naming is
+ * adapter-owned — the engine never references `WEAVE_START_COMMAND` or
+ * `WEAVE_START_LEGACY_COMMAND`.
+ *
+ * ## Command name preference
+ *
+ * - `/weave:start` — preferred command surface when the harness supports namespaced
+ *   commands (e.g. OpenCode's `/namespace:command` syntax).
+ * - `/start-work` — legacy compatibility alias; adapters may register this as a
+ *   secondary entry point for backwards compatibility.
+ *
+ * See `WEAVE_START_COMMAND` and `WEAVE_START_LEGACY_COMMAND` constants below.
+ */
+import type { PlanStateProvider, RuntimeStore } from "@weaveio/weave-engine";
+import { type ResultAsync } from "neverthrow";
+import type { OpenCodeAdapter } from "./adapter.js";
+import type { RunWorkflowError, RunWorkflowInput, RunWorkflowResult } from "./run-workflow.js";
+/**
+ * Preferred command name for the explicit plan-execution delivery path.
+ *
+ * When the harness supports namespaced commands (e.g. OpenCode's
+ * `/namespace:command` syntax), register this as the primary entry point.
+ *
+ * This constant is adapter-owned. Core packages must never reference it.
+ */
+export declare const WEAVE_START_COMMAND: "/weave:start";
+/**
+ * Legacy compatibility command name for the explicit plan-execution delivery path.
+ *
+ * Adapters may register this as a secondary entry point for backwards
+ * compatibility with users who have muscle memory for the older command surface.
+ *
+ * Prefer `WEAVE_START_COMMAND` for new integrations.
+ */
+export declare const WEAVE_START_LEGACY_COMMAND: "/start-work";
+/**
+ * Default workflow name used by `startPlanExecution` when no explicit
+ * `workflowName` is provided.
+ *
+ * `tapestry-execution` is the builtin workflow for executing an existing named
+ * plan end-to-end. It is the correct default for the `/weave:start` delivery
+ * path because that path is invoked when a plan already exists.
+ */
+export declare const DEFAULT_EXECUTION_WORKFLOW: "tapestry-execution";
+/**
+ * Discriminated union of errors that `startPlanExecution` can return.
+ *
+ * - `PlanNotFound` — the plan does not exist according to the `PlanStateProvider`.
+ * - `InvalidPlanName` — the plan name failed the safe-name check in the
+ *   `PlanStateProvider` (contains `/`, `..`, `\0`, or other unsafe characters).
+ * - `ProviderUnavailable` — the `PlanStateProvider` could not be queried (I/O
+ *   error or the provider was not supplied).
+ * - `WorkflowError` — the underlying `startPlan` call returned an error.
+ */
+export type StartPlanExecutionError = {
+    readonly type: "PlanNotFound";
+    readonly planName: string;
+} | {
+    readonly type: "InvalidPlanName";
+    readonly planName: string;
+} | {
+    readonly type: "ProviderUnavailable";
+    readonly cause: Error | {
+        readonly message: string;
+    };
+} | {
+    readonly type: "WorkflowError";
+    readonly cause: RunWorkflowError;
+};
+/**
+ * Input for `startPlanExecution`.
+ */
+export interface StartPlanExecutionInput {
+    /**
+     * Name of the plan to execute.
+     *
+     * Must match a plan file at `.weave/plans/<planName>.md` (or wherever the
+     * `PlanStateProvider` implementation resolves plan files).
+     */
+    readonly planName: string;
+    /**
+     * Full WeaveConfig containing workflow definitions.
+     *
+     * Must include the workflow referenced by `workflowName` (defaults to
+     * `tapestry-execution`).
+     *
+     * Typed as `RunWorkflowInput["config"]` to avoid a direct `@weaveio/weave-core`
+     * import — the adapter boundary requires that core types flow through
+     * adapter-owned modules, not be imported directly.
+     */
+    readonly config: RunWorkflowInput["config"];
+    /**
+     * Provider for querying plan file state.
+     *
+     * Used to validate that the plan exists before calling `startPlan`.
+     * When omitted, `startPlanExecution` returns a `ProviderUnavailable` error
+     * without touching the store.
+     *
+     * Typically `adapter.planStateProvider` (set during `adapter.init()`).
+     */
+    readonly planStateProvider: PlanStateProvider | undefined;
+    /**
+     * OpenCode adapter instance — `spawnSubagent` is called for each
+     * `DispatchAgentEffect` emitted by the workflow execution loop.
+     */
+    readonly adapter: OpenCodeAdapter;
+    /**
+     * Human-readable goal for this execution instance.
+     *
+     * Passed through to `startPlan` as `goal`. Defaults to
+     * `"Execute plan: <planName>"` when omitted.
+     */
+    readonly goal?: string;
+    /**
+     * Workflow name to execute.
+     *
+     * Defaults to `DEFAULT_EXECUTION_WORKFLOW` (`"tapestry-execution"`).
+     */
+    readonly workflowName?: string;
+    /**
+     * Runtime Store instance.
+     *
+     * Passed through to `startPlan`. Callers that need status/control to inspect
+     * the execution later must supply a shared store instance here. Defaults to
+     * a fresh `InMemoryRuntimeStore` when omitted.
+     */
+    readonly store?: RuntimeStore;
+}
+/**
+ * Adapter-owned projection of the engine's `startPlan` command operation.
+ *
+ * Validates that the named plan exists via `PlanStateProvider.planExists()`
+ * before delegating to the engine's `startPlan` operation. Fails without
+ * creating a `WorkflowInstance` when the plan is missing or the provider is
+ * unavailable.
+ *
+ * ## Execution flow
+ *
+ * 1. Guard: if `planStateProvider` is `undefined`, return `ProviderUnavailable`.
+ * 2. Delegate to `startPlan` (engine-owned) with:
+ *    - `planStateProvider` for plan existence validation (engine validates before
+ *      touching the store).
+ *    - `projectEffect` callback that calls `adapter.spawnSubagent` for each
+ *      `DispatchAgentEffect` emitted by the workflow runner.
+ * 3. Map `CommandOperationError` → `StartPlanExecutionError`.
+ * 4. Map `ExecutionStartedData` → `RunWorkflowResult`.
+ *
+ * @param input - Execution parameters.
+ * @returns `ok(RunWorkflowResult)` on success, or `err(StartPlanExecutionError)`.
+ */
+export declare function startPlanExecution(input: StartPlanExecutionInput): ResultAsync<RunWorkflowResult, StartPlanExecutionError>;
+//# sourceMappingURL=start-plan-execution.d.ts.map