wotann 0.5.75 → 0.5.80

package/README.md

@@ -162,6 +162,8 @@ $ wotann link
 
 25 providers via one router with automatic fallback chaining: `preferred → other paid → Gemini → Ollama → free`. **The model is never silently degraded** — if your chosen Opus is rate-limited, WOTANN tries Opus via another provider first; only when all paid paths exhaust does it fall back to Gemini/local.
 
+Runtime providers can be added without editing source: drop a strict `provider.json` under `.wotann/providers/<name>/` with an OpenAI-compatible `baseUrl`, model list, capabilities, and an `auth.envKey`. WOTANN validates the manifest, refuses token-bearing manifests, and routes it through the same provider registry as built-ins.
+
 ```
 Anthropic API    Anthropic Subscription   OpenAI    Codex (ChatGPT OAuth)
 GitHub Copilot   Ollama                   Gemini    HuggingFace
@@ -172,7 +174,7 @@ Fireworks        SambaNova                Groq      Cerebras
 
 ### The harness amplifies — even on a 3B local model
 
-`capability-augmenter` injects tool-calling, vision (via OCR + a11y tree), and extended thinking ("step by step" prompts) into providers that lack native support. Combined with hash-anchored editing, line-bucketed loop detection, and 43 forced-verification middleware layers in the PIPELINE, a **Qwen2.5-Coder:7B running locally gets the same forced verification, frustration detection, doom-loop guards, and memory system as Claude Opus**.
+`capability-augmenter` injects tool-calling, vision (via OCR + a11y tree), and extended thinking ("step by step" prompts) into providers that lack native support. Combined with hash-anchored editing, line-bucketed loop detection, and 41 forced-verification middleware layers in the PIPELINE, a **Qwen2.5-Coder:7B running locally gets the same forced verification, frustration detection, doom-loop guards, and memory system as Claude Opus**.
 
 ### Multi-surface, one agent, one memory
 
@@ -202,7 +204,7 @@ Runs **Ralph mode** (verify-fix loop) + **self-healing** (provider fallback) + *
 - **Guardian** post-response LLM-as-judge review (`WOTANN_GUARDIAN=1`)
 - **Self-consistency voting** — N parallel samples with confidence score
 - **Council deliberation** — 3-stage multi-provider peer review + chairman synthesis
-- **Unified knowledge fabric** — single search API across memory / context-tree / graph-RAG / vector / FTS5
+- **Unified knowledge fabric** — single search API across memory / context-tree / graph-RAG / vector / FTS5, with `wotann memory embeddings warmup` for local BGE embeddings that keep semantic memory usable offline after the model is cached
 - **Context replay** — priority-weighted reassembly under an explicit token budget
 - **Dream pipeline** — nightly consolidation 02:00-04:00, extracts skills from successful runs
 
@@ -226,7 +228,7 @@ Runs **Ralph mode** (verify-fix loop) + **self-healing** (provider fallback) + *
 ┌─────────────────────────────────────────────────────────────────────┐
 │  WotannRuntime (composition root)                                   │
 │  ┌─────────────┐ ┌─────────────┐ ┌────────────┐ ┌────────────────┐  │
-│  │ 43-layer    │ │ 129 intel   │ │ 88 orch    │ │ 22-event hooks │  │
+│  │ 41-layer    │ │ 85 intel    │ │ 79 orch    │ │ 31-event hooks │  │
 │  │ middleware  │ │ modules     │ │ modules    │ │ + DoomLoop     │  │
 │  └─────────────┘ └─────────────┘ └────────────┘ └────────────────┘  │
 │  ┌─────────────┐ ┌─────────────┐ ┌────────────┐ ┌────────────────┐  │
@@ -247,16 +249,16 @@ See [`docs/CAPABILITY_ADAPTATION_MATRIX.md`](docs/CAPABILITY_ADAPTATION_MATRIX.m
 
 |   |   |
 |---|---|
-| **Source** | 2,316 TypeScript files (1,234 `src` · 1,082 `tests`) |
+| **Source** | 2,551 TypeScript files in the current tree (1,380 `src` · 1,171 `tests`) |
 | **Middleware** | 41 PIPELINE layers (in `src/middleware/pipeline.ts`) |
 | **Providers** | 25 entries in `PROVIDER_DEFAULTS` (7 distinct adapter backends + capability augmentation) |
-| **Channels** | 35 messaging-adapter modules |
+| **Channels** | 41 modules in `src/channels/` |
 | **Surfaces** | 7 (CLI · TUI · Desktop · iOS · Watch · CarPlay · Channels) |
 | **Memory layers** | 8 (FTS5 · vector · graph-RAG · episodic · semantic · temporal · working · archival) |
-| **Intelligence modules** | 129 in `src/intelligence/` (auto-reviewer · verification-cascade · DAP · karpathy-principles · …) |
-| **Orchestration patterns** | 88 modules in `src/orchestration/` (coordinator · waves · PWR · Ralph · council · squads · canary · …) |
-| **Skills** | 126 curated markdown skills in `skills/` (+182 vendored imports; 18 `BUILT_IN` code-embedded guards) |
-| **Hook events** | 22 (10 producer-wired · 12 advisory) with 23 BUILT_IN guards |
+| **Intelligence modules** | 85 in `src/intelligence/` (auto-reviewer · verification-cascade · DAP · karpathy-principles · …) |
+| **Orchestration patterns** | 79 modules in `src/orchestration/` (coordinator · waves · PWR · Ralph · council · squads · canary · …) |
+| **Skills** | 138 `SKILL.md` entries under `skills/` + 18 `BUILT_IN` code-embedded guards |
+| **Hook events** | 31 (28 producer-wired · 3 advisory) with 23 BUILT_IN guards |
 
 ---
 
@@ -266,13 +268,13 @@ See [`docs/CAPABILITY_ADAPTATION_MATRIX.md`](docs/CAPABILITY_ADAPTATION_MATRIX.m
 src/
 ├── core/             Composition root (WotannRuntime) · agent bridge · types
 ├── providers/        25 entries in PROVIDER_DEFAULTS · router · rate limiter · format translator
-├── middleware/       43-layer PIPELINE in `pipeline.ts` + TTSR streaming
-├── intelligence/     129 modules that meaningfully affect model behavior
-├── orchestration/    88 modules — coordinator · waves · PWR · Ralph · council · squads · canary · ...
-├── memory/           SQLite + FTS5 · 8 layers · vector · graph-RAG · episodic
+├── middleware/       41-layer PIPELINE in `pipeline.ts` + TTSR streaming
+├── intelligence/     85 modules that meaningfully affect model behavior
+├── orchestration/    79 modules — coordinator · waves · PWR · Ralph · council · squads · canary · ...
+├── memory/           80 modules · SQLite + FTS5 · 8 layers · vector · graph-RAG · episodic
 ├── context/          5 compaction strategies · Ollama KV cache compression
 ├── prompt/           Engine · 18 prompt modules · instruction provenance
-├── hooks/            21 events (10 producer-wired · 11 advisory) · 23 guards · DoomLoop
+├── hooks/            31 events (28 producer-wired · 3 advisory) · 23 guards · DoomLoop
 ├── computer-use/     4-layer perception + action stack (text-mediated for any model)
 ├── channels/         25+ adapters + DM pairing + node registry
 ├── voice/            Push-to-talk · STT/TTS · WhisperKit · Edge TTS · faster-whisper
@@ -290,7 +292,7 @@ desktop-app/          Tauri 2 desktop (React + Rust) · ⌘K command palette
 ios/                  SwiftUI app (5 targets — main · Intents · Widgets · Watch · Share)
 docs/                 Architecture references (auth · surface parity · capability adaptation · build)
 design-brief/         Design system: tokens · brand identity · surface guidelines · reference shots
-skills/               126 curated markdown skills (progressive disclosure; +182 vendored imports, 18 BUILT_IN)
+skills/               138 SKILL.md entries (progressive disclosure; 18 BUILT_IN guards)
 ```
 
 ---

package/dist/acp/manifest.d.ts

@@ -157,4 +157,3 @@ export interface BuildManifestOptions {
  * @throws BuildManifestError if package.json is missing or malformed.
  */
 export declare function buildManifest(options: BuildManifestOptions): AcpRegistryManifest;
-//# sourceMappingURL=manifest.d.ts.map

package/dist/acp/manifest.js

@@ -182,4 +182,3 @@ function extractRepository(pkg) {
     }
     return undefined;
 }
-//# sourceMappingURL=manifest.js.map

package/dist/acp/protocol.d.ts

@@ -206,6 +206,57 @@ export interface AcpNewSessionResult {
     readonly sessionId: string;
     readonly _meta?: Record<string, unknown>;
 }
+export interface AcpLoadSessionParams {
+    readonly sessionId: string;
+}
+export interface AcpLoadSessionResult {
+    readonly sessionId: string;
+    readonly loaded: boolean;
+    readonly _meta?: Record<string, unknown>;
+}
+export interface AcpSessionSummary {
+    readonly sessionId: string;
+    readonly cwd: string;
+    readonly createdAt: number;
+    readonly updatedAt: number;
+    readonly closed: boolean;
+    readonly messageCount: number;
+    readonly childSessionIds: readonly string[];
+    readonly parentSessionId?: string;
+    readonly providerHint?: string;
+    readonly modelHint?: string;
+}
+export interface WotannSessionListParams {
+    readonly includeClosed?: boolean;
+    readonly parentSessionId?: string;
+}
+export interface WotannSessionListResult {
+    readonly sessions: readonly AcpSessionSummary[];
+}
+export interface WotannSessionCloseParams {
+    readonly sessionId: string;
+}
+export interface WotannSessionCloseResult {
+    readonly sessionId: string;
+    readonly closed: boolean;
+}
+export interface WotannSessionInspectParams {
+    readonly sessionId: string;
+}
+export interface WotannSessionInspectResult {
+    readonly session: AcpSessionSummary | null;
+}
+export interface WotannSessionMessageParams {
+    readonly fromSessionId: string;
+    readonly targetSessionId: string;
+    readonly prompt: readonly AcpContentBlock[];
+}
+export interface WotannSessionMessageResult {
+    readonly targetSessionId: string;
+    readonly stopReason: AcpStopReason;
+    readonly content: string;
+    readonly refused?: string;
+}
 /**
  * ContentBlock — a tagged union matching ACP v1. WOTANN currently
  * produces `text` and consumes `text` + `resource_link`; the other
@@ -302,6 +353,7 @@ export declare const ACP_METHODS: {
     readonly Initialize: "initialize";
     readonly Authenticate: "authenticate";
     readonly SessionNew: "session/new";
+    readonly SessionLoad: "session/load";
     readonly SessionPrompt: "session/prompt";
     readonly SessionCancel: "session/cancel";
     readonly SessionUpdate: "session/update";
@@ -315,6 +367,10 @@ export declare const ACP_METHODS: {
     readonly ThreadRollback: "thread/rollback";
     readonly ThreadList: "thread/list";
     readonly ThreadSwitch: "thread/switch";
+    readonly WotannSessionList: "wotann/session.list";
+    readonly WotannSessionClose: "wotann/session.close";
+    readonly WotannSessionInspect: "wotann/session.inspect";
+    readonly WotannSessionMessage: "wotann/session.message";
 };
 /**
  * ACP-shaped tool definition. Mirrors the MCP + Zed shape so the same
@@ -530,4 +586,3 @@ export declare function flattenPromptText(blocks: readonly AcpContentBlock[]): s
  * use this to decide which version to report back.
  */
 export declare function negotiateProtocolVersion(clientVersion: unknown): AcpProtocolVersion;
-//# sourceMappingURL=protocol.d.ts.map

package/dist/acp/protocol.js

@@ -62,6 +62,7 @@ export const ACP_METHODS = {
     Initialize: "initialize",
     Authenticate: "authenticate",
     SessionNew: "session/new",
+    SessionLoad: "session/load",
     SessionPrompt: "session/prompt",
     SessionCancel: "session/cancel", // notification
     SessionUpdate: "session/update", // notification (agent→client)
@@ -82,6 +83,12 @@ export const ACP_METHODS = {
     ThreadRollback: "thread/rollback",
     ThreadList: "thread/list",
     ThreadSwitch: "thread/switch",
+    // WOTANN namespaced ACP extensions. Kept out of the standard session/*
+    // namespace so future ACP revisions can add methods without collision.
+    WotannSessionList: "wotann/session.list",
+    WotannSessionClose: "wotann/session.close",
+    WotannSessionInspect: "wotann/session.inspect",
+    WotannSessionMessage: "wotann/session.message",
 };
 /**
  * Decode a JSON-RPC frame. Returns an `error` JsonRpcResponse shape
@@ -217,4 +224,3 @@ export function negotiateProtocolVersion(clientVersion) {
         return ACP_PROTOCOL_VERSION;
     return clientVersion;
 }
-//# sourceMappingURL=protocol.js.map

package/dist/acp/registry.d.ts

@@ -87,4 +87,3 @@ export declare function registerWithZed(manifest: AcpRegistryManifest, options:
  * filesystem is write-blocked).
  */
 export declare function writeManifestToDisk(manifest: AcpRegistryManifest, path: string): string;
-//# sourceMappingURL=registry.d.ts.map

package/dist/acp/registry.js

@@ -294,4 +294,3 @@ export function writeManifestToDisk(manifest, path) {
     writeFileSync(path, JSON.stringify(manifest, null, 2) + "\n", "utf-8");
     return path;
 }
-//# sourceMappingURL=registry.js.map

package/dist/acp/runtime-handlers.d.ts

@@ -55,4 +55,3 @@ export interface RuntimeAcpHandlersOptions {
  * generator loop exits at the next yielded chunk.
  */
 export declare function createRuntimeAcpHandlers(options: RuntimeAcpHandlersOptions): AcpHandlers;
-//# sourceMappingURL=runtime-handlers.d.ts.map

package/dist/acp/runtime-handlers.js

@@ -42,6 +42,13 @@ const DEFAULT_CAPABILITIES = {
         // Advertise WOTANN-specific thread ops to hosts that speak the
         // extended surface (Workshop, Goose fork of ACP, etc.).
         "wotann/thread-ops": ["thread/fork", "thread/rollback", "thread/list", "thread/switch"],
+        "wotann/session-ops": [
+            "session/load",
+            "wotann/session.list",
+            "wotann/session.close",
+            "wotann/session.inspect",
+            "wotann/session.message",
+        ],
     },
 };
 /**
@@ -73,11 +80,20 @@ export function createRuntimeAcpHandlers(options) {
         async sessionNew(params) {
             counter += 1;
             const sessionId = `${SESSION_PREFIX}${counter}`;
+            const now = Date.now();
+            const parentSessionId = params._meta && typeof params._meta["wotann/parentSessionId"] === "string"
+                ? params._meta["wotann/parentSessionId"]
+                : undefined;
             const record = {
                 sessionId,
                 cwd: params.cwd,
                 ...(params.providerHint !== undefined ? { providerHint: params.providerHint } : {}),
                 ...(params.modelHint !== undefined ? { modelHint: params.modelHint } : {}),
+                ...(parentSessionId !== undefined ? { parentSessionId } : {}),
+                createdAt: now,
+                updatedAt: now,
+                messageCount: 0,
+                closed: false,
                 cancelled: false,
                 toolCallCounter: 0,
             };
@@ -88,12 +104,21 @@ export function createRuntimeAcpHandlers(options) {
             // the handler stays focused on the prompt turn.
             return { sessionId };
         },
+        async sessionLoad(params) {
+            const record = sessions.get(params.sessionId);
+            if (!record || record.closed) {
+                return { sessionId: params.sessionId, loaded: false };
+            }
+            record.updatedAt = Date.now();
+            return { sessionId: record.sessionId, loaded: true };
+        },
         async sessionPrompt(params, onUpdate) {
             const record = sessions.get(params.sessionId);
-            if (!record) {
+            if (!record || record.closed) {
                 return { stopReason: "error" };
             }
             record.cancelled = false;
+            record.updatedAt = Date.now();
             const promptText = flattenPromptText(params.prompt);
             const queryOptions = {
                 prompt: promptText,
@@ -157,13 +182,121 @@ export function createRuntimeAcpHandlers(options) {
                 const content = { type: "text", text: `[error] ${msg}` };
                 send({ sessionUpdate: "agent_message_chunk", content });
             }
+            record.updatedAt = Date.now();
+            record.messageCount += 1;
             return { stopReason };
         },
         async sessionCancel(params) {
             const record = sessions.get(params.sessionId);
-            if (record)
+            if (record) {
                 record.cancelled = true;
+                record.updatedAt = Date.now();
+            }
+        },
+        async wotannSessionList(params) {
+            const summaries = Array.from(sessions.values())
+                .filter((record) => params.includeClosed || !record.closed)
+                .filter((record) => params.parentSessionId === undefined ? true : record.parentSessionId === params.parentSessionId)
+                .map((record) => summarizeSession(record, sessions));
+            return { sessions: summaries };
+        },
+        async wotannSessionClose(params) {
+            const record = sessions.get(params.sessionId);
+            if (!record) {
+                return { sessionId: params.sessionId, closed: false };
+            }
+            record.cancelled = true;
+            record.closed = true;
+            record.updatedAt = Date.now();
+            return { sessionId: params.sessionId, closed: true };
+        },
+        async wotannSessionInspect(params) {
+            const record = sessions.get(params.sessionId);
+            return { session: record ? summarizeSession(record, sessions) : null };
+        },
+        async wotannSessionMessage(params) {
+            const from = sessions.get(params.fromSessionId);
+            const target = sessions.get(params.targetSessionId);
+            if (!from || from.closed) {
+                return {
+                    targetSessionId: params.targetSessionId,
+                    stopReason: "error",
+                    content: "",
+                    refused: "from session is missing or closed",
+                };
+            }
+            if (!target || target.closed) {
+                return {
+                    targetSessionId: params.targetSessionId,
+                    stopReason: "error",
+                    content: "",
+                    refused: "target session is missing or closed",
+                };
+            }
+            if (!isAncestorSession(from.sessionId, target, sessions)) {
+                return {
+                    targetSessionId: target.sessionId,
+                    stopReason: "error",
+                    content: "",
+                    refused: "only ancestor sessions can message descendant sessions",
+                };
+            }
+            target.updatedAt = Date.now();
+            let stopReason = "end_turn";
+            let content = "";
+            try {
+                for await (const chunk of options.runtime.query({
+                    prompt: flattenPromptText(params.prompt),
+                    ...(target.providerHint
+                        ? { provider: target.providerHint }
+                        : {}),
+                    ...(target.modelHint ? { model: target.modelHint } : {}),
+                })) {
+                    if (chunk.type === "text")
+                        content += chunk.content;
+                    if (chunk.type === "error") {
+                        stopReason = "error";
+                        content += chunk.content;
+                    }
+                }
+            }
+            catch (err) {
+                stopReason = "error";
+                content += err instanceof Error ? err.message : String(err);
+            }
+            target.updatedAt = Date.now();
+            target.messageCount += 1;
+            return { targetSessionId: target.sessionId, stopReason, content };
         },
     };
 }
-//# sourceMappingURL=runtime-handlers.js.map
+function summarizeSession(record, sessions) {
+    const childSessionIds = Array.from(sessions.values())
+        .filter((candidate) => candidate.parentSessionId === record.sessionId)
+        .map((candidate) => candidate.sessionId);
+    return {
+        sessionId: record.sessionId,
+        cwd: record.cwd,
+        createdAt: record.createdAt,
+        updatedAt: record.updatedAt,
+        closed: record.closed,
+        messageCount: record.messageCount,
+        childSessionIds,
+        ...(record.parentSessionId ? { parentSessionId: record.parentSessionId } : {}),
+        ...(record.providerHint ? { providerHint: record.providerHint } : {}),
+        ...(record.modelHint ? { modelHint: record.modelHint } : {}),
+    };
+}
+function isAncestorSession(ancestorSessionId, target, sessions) {
+    let current = target;
+    let depth = 0;
+    while (current.parentSessionId && depth < 8) {
+        if (current.parentSessionId === ancestorSessionId)
+            return true;
+        current = sessions.get(current.parentSessionId);
+        if (!current)
+            return false;
+        depth += 1;
+    }
+    return false;
+}

package/dist/acp/server.d.ts

@@ -23,11 +23,12 @@
  *   - WOTANN `thread/*`             — additive request routes for
  *     conversation-branch control; not part of upstream ACP.
  */
-import { ACP_PROTOCOL_VERSION, type AcpCancelParams, type AcpFsErrorResult, type AcpFsListParams, type AcpFsListResult, type AcpFsReadParams, type AcpFsReadResult, type AcpFsWriteParams, type AcpFsWriteResult, type AcpInitializeParams, type AcpInitializeResult, type AcpNewSessionParams, type AcpNewSessionResult, type AcpPermissionsRequestParams, type AcpPermissionsRequestResult, type AcpPromptParams, type AcpPromptResult, type AcpSessionUpdateNotification, type AcpImplementation, type AcpToolsListParams, type AcpToolsListResult, type AcpToolsInvokeParams, type AcpToolsInvokeResult, type JsonRpcNotification, type JsonRpcResponse } from "./protocol.js";
+import { ACP_PROTOCOL_VERSION, type AcpCancelParams, type AcpFsErrorResult, type AcpFsListParams, type AcpFsListResult, type AcpFsReadParams, type AcpFsReadResult, type AcpFsWriteParams, type AcpFsWriteResult, type AcpInitializeParams, type AcpInitializeResult, type AcpLoadSessionParams, type AcpLoadSessionResult, type AcpNewSessionParams, type AcpNewSessionResult, type AcpPermissionsRequestParams, type AcpPermissionsRequestResult, type AcpPromptParams, type AcpPromptResult, type AcpSessionUpdateNotification, type AcpImplementation, type AcpToolsListParams, type AcpToolsListResult, type AcpToolsInvokeParams, type AcpToolsInvokeResult, type WotannSessionCloseParams, type WotannSessionCloseResult, type WotannSessionInspectParams, type WotannSessionInspectResult, type WotannSessionListParams, type WotannSessionListResult, type WotannSessionMessageParams, type WotannSessionMessageResult, type JsonRpcNotification, type JsonRpcResponse } from "./protocol.js";
 import { type ThreadHandlerDeps } from "./thread-handlers.js";
 export interface AcpHandlers {
     initialize(params: AcpInitializeParams): Promise<AcpInitializeResult>;
     sessionNew(params: AcpNewSessionParams): Promise<AcpNewSessionResult>;
+    sessionLoad?(params: AcpLoadSessionParams): Promise<AcpLoadSessionResult>;
     /**
      * Prompt is intentionally a streaming method. The dispatcher pumps
      * `onUpdate` into `session/update` notifications; the handler
@@ -36,6 +37,10 @@ export interface AcpHandlers {
      */
     sessionPrompt(params: AcpPromptParams, onUpdate: (n: AcpSessionUpdateNotification) => void): Promise<AcpPromptResult>;
     sessionCancel(params: AcpCancelParams): Promise<void>;
+    wotannSessionList?(params: WotannSessionListParams): Promise<WotannSessionListResult>;
+    wotannSessionClose?(params: WotannSessionCloseParams): Promise<WotannSessionCloseResult>;
+    wotannSessionInspect?(params: WotannSessionInspectParams): Promise<WotannSessionInspectResult>;
+    wotannSessionMessage?(params: WotannSessionMessageParams): Promise<WotannSessionMessageResult>;
     /**
      * Zed 0.3 parity — return the runtime's tool registry shaped as ACP
      * ToolDefinitions. Optional; hosts that don't implement tools fall
@@ -121,6 +126,7 @@ export declare class AcpServer {
     private handleRequest;
     private onInitialize;
     private onSessionNew;
+    private onSessionLoad;
     private onSessionPrompt;
     private onSessionCancelAsRequest;
     private onToolsList;
@@ -129,6 +135,10 @@ export declare class AcpServer {
     private onFsRead;
     private onFsWrite;
     private onFsList;
+    private onWotannSessionList;
+    private onWotannSessionClose;
+    private onWotannSessionInspect;
+    private onWotannSessionMessage;
     private notInitialized;
 }
 export interface RecordingBus {
@@ -181,4 +191,3 @@ export interface AcpFsHandlerDeps {
  * InternalError.
  */
 export declare function createFsHandlers(deps: AcpFsHandlerDeps): Pick<AcpHandlers, "permissionsRequest" | "fsRead" | "fsWrite" | "fsList">;
-//# sourceMappingURL=server.d.ts.map

package/dist/acp/server.js

@@ -96,6 +96,8 @@ export class AcpServer {
                     return await this.onInitialize(req);
                 case ACP_METHODS.SessionNew:
                     return await this.onSessionNew(req);
+                case ACP_METHODS.SessionLoad:
+                    return await this.onSessionLoad(req);
                 case ACP_METHODS.SessionPrompt:
                     return await this.onSessionPrompt(req);
                 case ACP_METHODS.SessionCancel:
@@ -115,6 +117,14 @@ export class AcpServer {
                     return await this.onFsWrite(req);
                 case ACP_METHODS.FsList:
                     return await this.onFsList(req);
+                case ACP_METHODS.WotannSessionList:
+                    return await this.onWotannSessionList(req);
+                case ACP_METHODS.WotannSessionClose:
+                    return await this.onWotannSessionClose(req);
+                case ACP_METHODS.WotannSessionInspect:
+                    return await this.onWotannSessionInspect(req);
+                case ACP_METHODS.WotannSessionMessage:
+                    return await this.onWotannSessionMessage(req);
                 default:
                     return makeError(req.id, JSON_RPC_ERROR_CODES.MethodNotFound, `Unknown method: ${req.method}`);
             }
@@ -154,6 +164,19 @@ export class AcpServer {
         const result = await this.handlers.sessionNew(params);
         return makeResponse(req.id, result);
     }
+    async onSessionLoad(req) {
+        if (!this.initialized)
+            return this.notInitialized(req.id);
+        if (!this.handlers.sessionLoad) {
+            return makeError(req.id, JSON_RPC_ERROR_CODES.MethodNotFound, "session/load: handler not implemented by this agent");
+        }
+        const params = req.params;
+        if (!params?.sessionId || typeof params.sessionId !== "string") {
+            return makeError(req.id, JSON_RPC_ERROR_CODES.InvalidParams, "session/load: missing sessionId");
+        }
+        const result = await this.handlers.sessionLoad(params);
+        return makeResponse(req.id, result);
+    }
     async onSessionPrompt(req) {
         if (!this.initialized)
             return this.notInitialized(req.id);
@@ -309,6 +332,77 @@ export class AcpServer {
         const result = await this.handlers.fsList(params);
         return makeResponse(req.id, result);
     }
+    async onWotannSessionList(req) {
+        if (!this.initialized)
+            return this.notInitialized(req.id);
+        if (!this.handlers.wotannSessionList) {
+            return makeError(req.id, JSON_RPC_ERROR_CODES.MethodNotFound, "wotann/session.list: handler not implemented by this agent");
+        }
+        const raw = (req.params ?? {});
+        if (raw["includeClosed"] !== undefined && typeof raw["includeClosed"] !== "boolean") {
+            return makeError(req.id, JSON_RPC_ERROR_CODES.InvalidParams, "wotann/session.list: includeClosed must be boolean when provided");
+        }
+        if (raw["parentSessionId"] !== undefined && typeof raw["parentSessionId"] !== "string") {
+            return makeError(req.id, JSON_RPC_ERROR_CODES.InvalidParams, "wotann/session.list: parentSessionId must be string when provided");
+        }
+        const params = {
+            ...(typeof raw["includeClosed"] === "boolean" ? { includeClosed: raw["includeClosed"] } : {}),
+            ...(typeof raw["parentSessionId"] === "string"
+                ? { parentSessionId: raw["parentSessionId"] }
+                : {}),
+        };
+        const result = await this.handlers.wotannSessionList(params);
+        return makeResponse(req.id, result);
+    }
+    async onWotannSessionClose(req) {
+        if (!this.initialized)
+            return this.notInitialized(req.id);
+        if (!this.handlers.wotannSessionClose) {
+            return makeError(req.id, JSON_RPC_ERROR_CODES.MethodNotFound, "wotann/session.close: handler not implemented by this agent");
+        }
+        const raw = (req.params ?? {});
+        if (typeof raw["sessionId"] !== "string" || raw["sessionId"].length === 0) {
+            return makeError(req.id, JSON_RPC_ERROR_CODES.InvalidParams, "wotann/session.close: missing sessionId");
+        }
+        const result = await this.handlers.wotannSessionClose({ sessionId: raw["sessionId"] });
+        return makeResponse(req.id, result);
+    }
+    async onWotannSessionInspect(req) {
+        if (!this.initialized)
+            return this.notInitialized(req.id);
+        if (!this.handlers.wotannSessionInspect) {
+            return makeError(req.id, JSON_RPC_ERROR_CODES.MethodNotFound, "wotann/session.inspect: handler not implemented by this agent");
+        }
+        const raw = (req.params ?? {});
+        if (typeof raw["sessionId"] !== "string" || raw["sessionId"].length === 0) {
+            return makeError(req.id, JSON_RPC_ERROR_CODES.InvalidParams, "wotann/session.inspect: missing sessionId");
+        }
+        const result = await this.handlers.wotannSessionInspect({ sessionId: raw["sessionId"] });
+        return makeResponse(req.id, result);
+    }
+    async onWotannSessionMessage(req) {
+        if (!this.initialized)
+            return this.notInitialized(req.id);
+        if (!this.handlers.wotannSessionMessage) {
+            return makeError(req.id, JSON_RPC_ERROR_CODES.MethodNotFound, "wotann/session.message: handler not implemented by this agent");
+        }
+        const raw = (req.params ?? {});
+        if (typeof raw["fromSessionId"] !== "string" || raw["fromSessionId"].length === 0) {
+            return makeError(req.id, JSON_RPC_ERROR_CODES.InvalidParams, "wotann/session.message: missing fromSessionId");
+        }
+        if (typeof raw["targetSessionId"] !== "string" || raw["targetSessionId"].length === 0) {
+            return makeError(req.id, JSON_RPC_ERROR_CODES.InvalidParams, "wotann/session.message: missing targetSessionId");
+        }
+        if (!Array.isArray(raw["prompt"])) {
+            return makeError(req.id, JSON_RPC_ERROR_CODES.InvalidParams, "wotann/session.message: prompt must be an array");
+        }
+        const result = await this.handlers.wotannSessionMessage({
+            fromSessionId: raw["fromSessionId"],
+            targetSessionId: raw["targetSessionId"],
+            prompt: raw["prompt"],
+        });
+        return makeResponse(req.id, result);
+    }
     notInitialized(id) {
         return makeError(id, JSON_RPC_ERROR_CODES.ServerNotInitialized, "initialize must be called first");
     }
@@ -550,4 +644,3 @@ export function createFsHandlers(deps) {
         },
     };
 }
-//# sourceMappingURL=server.js.map

package/dist/acp/stdio.d.ts

@@ -54,4 +54,3 @@ export declare function startAcpStdio(options: AcpStdioOptions): AcpStdioHandle;
  * for Zed, Gemini CLI, Goose hosting sanity checks.
  */
 export declare function referenceHandlers(): AcpHandlers;
-//# sourceMappingURL=stdio.d.ts.map

package/dist/acp/stdio.js

@@ -175,4 +175,3 @@ export function referenceHandlers() {
         },
     };
 }
-//# sourceMappingURL=stdio.js.map

package/dist/acp/thread-handlers.d.ts

@@ -24,4 +24,3 @@ export declare function handleThreadSwitch(params: AcpThreadSwitchParams, deps:
  * null when the method isn't a thread op.
  */
 export declare function dispatchThreadMethod(method: string, params: unknown, deps: ThreadHandlerDeps): unknown | null;
-//# sourceMappingURL=thread-handlers.d.ts.map

package/dist/acp/thread-handlers.js

@@ -91,4 +91,3 @@ export function dispatchThreadMethod(method, params, deps) {
             return null;
     }
 }
-//# sourceMappingURL=thread-handlers.js.map

package/dist/affordances/checks.d.ts

@@ -0,0 +1,21 @@
+export interface AffordanceCheckResult {
+    readonly id: string;
+    readonly title: string;
+    readonly passed: boolean;
+    readonly failures: readonly string[];
+    readonly warnings: readonly string[];
+}
+export interface AffordanceCheckSummary {
+    readonly passed: boolean;
+    readonly checks: readonly AffordanceCheckResult[];
+}
+export interface AffordanceCheckOptions {
+    readonly actualSlashCommands?: readonly string[];
+    readonly actualToolNames?: readonly string[];
+    readonly actualDesktopPaletteCommandIds?: readonly string[];
+    readonly actualDesktopShortcutIds?: readonly string[];
+    readonly actualDesktopTrayActionIds?: readonly string[];
+    readonly actualRpcMethods?: readonly string[];
+}
+export declare function runAffordanceChecks(options?: AffordanceCheckOptions): AffordanceCheckSummary;
+export declare function renderAffordanceCheckSummary(summary: AffordanceCheckSummary): string;