@skillstate/mcp 2.0.7 → 2.2.0

package/README.md

@@ -6,7 +6,7 @@
 
 [![npm version](https://img.shields.io/npm/v/@skillstate/mcp)](https://www.npmjs.com/package/@skillstate/mcp)
 [![node](https://img.shields.io/node/v/@skillstate/mcp)](https://www.npmjs.com/package/@skillstate/mcp)
-[![Tests](https://img.shields.io/badge/tests-873%20passing-brightgreen)](https://github.com/vitkuz573/skillstate)
+[![Tests](https://img.shields.io/badge/tests-1165%20passing-brightgreen)](https://github.com/vitkuz573/skillstate)
 [![License: MIT](https://img.shields.io/badge/license-MIT-blue)](https://github.com/vitkuz573/skillstate/blob/main/LICENSE)
 
 </div>
@@ -14,10 +14,11 @@
 ---
 
 `@skillstate/mcp` exposes the skillstate runtime ([`@skillstate/core`](../core))
-as a **Model Context Protocol** server over stdio (JSON-RPC 2.0). It reuses the
-paper-exact core directly — `mergeState`, `createInitialState`,
-`validatePatchDeep`, `migrate`, `redactSecrets` — so any MCP client can read,
-patch, merge, and reset the execution state as tools.
+as a **Model Context Protocol** server (protocol revision `2026-07-28`) over
+stdio (JSON-RPC 2.0, newline-delimited). It reuses the paper-exact core
+directly — `mergeState`, `createInitialState`, `validatePatchDeep`, `migrate`,
+`redactSecrets` — so any MCP client can read, patch, checkpoint, and roll back
+the execution state as tools and resources.
 
 > **@non-paper** — the server is additive; no MCP exists in arXiv 2608.26263v3.
 > Unlike the prompting adapters, MCP is runtime **access**, not prompting, so
@@ -50,7 +51,7 @@ const server = new McpServer({
   root: '.',
   name: '.skillstate.json',
 });
-const response = server.handleLine(
+const response = await server.handleLine(
   JSON.stringify({
     jsonrpc: '2.0', id: 1, method: 'tools/call',
     params: { name: 'state.get', arguments: {} },
@@ -92,17 +93,17 @@ first (see the `@skillstate/opencode` README for a sample). Verify with:
 
 ```bash
 opencode debug config   # mcp.skillstate appears in the resolved config
-echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"t","version":"0"}}}
+echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2026-07-28","capabilities":{},"clientInfo":{"name":"t","version":"0"}}}
 {"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}}' \
   | node packages/mcp/bin/mcp.js
-# -> serverInfo {"name":"skillstate","version":"1.0.0"} + 6 tools
+# -> protocolVersion "2026-07-28" + 14 tools
 ```
 
 ## API / Exports
 
-Root path `@skillstate/mcp` exports `McpAdapter`, `McpServer`, and `launch`
-(plus the types `McpServerOptions`, `LaunchArgs`, `FrameMode`, `JsonRpcRequest`,
-`McpToolResult`, and `McpConfigOptions`).
+Root path `@skillstate/mcp` exports `McpAdapter`, `McpServer`, `launch`, and
+`PROTOCOL_VERSION` (plus the types `McpServerOptions`, `LaunchArgs`,
+`JsonRpcRequest`, `McpToolResult`, `ToolAnnotations`, and `McpConfigOptions`).
 
 - `new McpAdapter()` — `name = 'mcp'`.
   - `generateMcpConfig(target, options?): string` — a deterministic,
@@ -110,30 +111,103 @@ Root path `@skillstate/mcp` exports `McpAdapter`, `McpServer`, and `launch`
     `.launcherPath`, `.env`). No state path is embedded — the server resolves
     the state from its own cwd.
   - `saveMcpConfig(target, options?): Promise<string>` — atomic write.
-- `new McpServer(options: McpServerOptions)` — `{ spec, root, name, tracker? }`.
-  - `handleLine(line): string | null` — process one already-framed JSON-RPC
-    message.
-  - `feed(chunk): string[]` — consume streamed stdin, handling both
-    newline-delimited JSON-RPC and `Content-Length`-framed messages.
+- `new McpServer(options: McpServerOptions)` — `{ spec, root, name, agent?, tracker? }`.
+  - `protocolVersion` is always `'2026-07-28'`; `initialize` answers exactly
+    that regardless of what the client requested (per the MCP spec the client
+    decides whether it can work with the server's revision).
+  - `handleLine(line): Promise<string | null>` — process one already-framed
+    JSON-RPC message.
+  - `feed(chunk): Promise<string[]>` — consume streamed stdin
+    (newline-delimited JSON-RPC; partial lines are buffered).
   - `start(input?, output?): Promise<McpServer>` / `stop()` / `get isRunning()`.
 - `launch(args?): Promise<McpServer>` — resolves the spec from args or env
   and starts a stdio server; the state always resolves from the server's cwd.
 
-**Tools:** `state.get`, `state.patch`, `state.merge` (schema-validated),
-`state.reset`, `spec.get`, `state.metrics`. **Resource:** `skillstate://state`.
-State is redacted on every read, and the server conserves its own buffering so
-transports may split frames mid-message.
+**Tools:** `state.get`, `state.patch` (the single write op — validates via
+`validatePatchDeep`, returns `{ state, changes, warnings }`), `state.validate`
+(dry-run), `state.diff` (changes since the last call, `{ full: true }` for
+before/after), `state.checkpoint` (named sidecar snapshot),
+`state.rollback` (restore from a checkpoint), `state.summary` (compact
+orientation + session info), `state.metrics`, `state.finalize` (the agent's
+"I am done" lifecycle marker), `spec.get` (with a ready-made
+valid `example_state_patch`), `spec.next` (goal/next/blockers guidance),
+plus the AGENT tools `agent.list` / `agent.read` / `agent.merge`.
+`state.merge` and `state.reset` are gone — `state.patch` validates, and
+rollback replaces reset.
+
+**Multi-agent (2.2.0).** Every state tool accepts `{ agent }` (sanitized
+`[A-Za-z0-9_-]`, ≤ 64) scoping the file to
+`<stateDir>/agents/<agentId>/<name>`; the server default comes from the
+`SKILLSTATE_AGENT_ID` env (`launch`) or the `McpServerOptions.agent`
+constructor option; the default `''` is the main agent. All writes
+(`state.patch`, `state.rollback`, `state.checkpoint`, `agent.merge`) run
+under `withStateLock` — a cross-process lockfile at `<state>.lock` with
+stale-TTL takeover — so 2-3 concurrent agent processes never interleave
+state writes. The `state.diff` baseline is persisted to
+`<stateDir>/.diff-baseline.json` (atomic, under the lock) — the
+"since your last look" semantics is now consistent across processes.
+The agent tools: `agent.list` scans `<stateDir>/agents/` and returns
+`{ agents: [{ id, statePath, exists, status, lastActivityAt, staleness,
+ageMs, summary, lastModified }] }` (light summary: keys + size, no values);
+`agent.read` returns a sub-agent's state read-only; `agent.merge` folds a
+sub-agent copy into the main state under the lock — keys only in the sub
+state are taken, nested objects merge recursively, conflicting scalars
+follow `keep: 'main'` (default) or `'sub'` (schema defaults count as
+"never set"), and the sub copy is NOT deleted — it is marked `mergedAt`
+(history) and its session sidecar flips to `status: 'merged'`.
+
+**Session lifecycle (2.3.0).** The state envelope belongs to the
+procedure; the session lifecycle lives in a separate sidecar next to
+every state file — `<stateDir>/.session-meta.json` (agent scopes:
+`agents/<id>/.session-meta.json`), written atomically under its own
+`withStateLock`:
+
+- `launch()` stamps `{ status: 'running', startedAt, agentId,
+  protocolVersion }` — a new launch overwrites any previous
+  `interrupted`/`completed` marker (a fresh run has begun).
+- Every state write (`state.patch` / `state.rollback` /
+  `state.checkpoint` / `agent.merge`) refreshes `lastActivityAt`,
+  debounced to at most one sidecar write per 5 s; a broken sidecar never
+  fails a state write.
+- `state.finalize { status: 'completed' | 'failed', result? }` is the
+  agent's own "I am done" signal — it writes `{ status, finishedAt,
+  result }` so `agent.list`/`state.summary` show a finished session
+  instead of a running/interrupted one.
+- SIGINT/SIGTERM flush `status: 'interrupted'` + re-pin the diff baseline
+  to the surviving state, then exit 130 (`installShutdown` from
+  `@skillstate/core`; terminal statuses recorded by the agent are never
+  clobbered). Embedders that own the process pass
+  `installInterruptHandler: false`.
+- Staleness (`STALE_MS` = 5 min in `@skillstate/core`):
+  `active` — fresh running session or a terminal status; `stale` —
+  `running` with no writes for 5 min (the provider died without a
+  signal); `orphan` — no (or corrupt) sidecar. `agent.list` adds `ageMs`
+  for running sessions; `state.summary` adds `status`/`lastActivityAt`/
+  `staleness` to its `session` object.
+
+**Resources (`resources/read`):** `skillstate://state` (the full
+`{ version, state }` envelope), `skillstate://spec`, and
+`skillstate://summary` (compact projection). State is redacted on every read,
+and the server conserves its own buffering so transports may split lines
+mid-message.
 
 ## Notes
 
 - **Zero dependencies.** `@skillstate/mcp` declares only
   [`@skillstate/core`](../core); it uses Node's `fs`/`path`/`stream` for the
   stdio transport and crash-safe state writes (temp sibling + fsync + rename).
-- Both newline-delimited JSON-RPC and `Content-Length`-framed (LSP-style)
-  messages are accepted; responses echo the framing that triggered them.
-- `state.merge` runs `validatePatchDeep` (defense-in-depth) before the ⊕ merge;
-  `state.patch` applies the raw ⊕ merge. `redactSecrets` fails closed so
-  secrets never leave the process through a tool result.
+- Transport is newline-delimited JSON only (the MCP stdio framing);
+  `Content-Length`-framed input is not understood and errors as `-32700`.
+- Every patch — including `state.patch` — runs `validatePatchDeep`
+  (defense-in-depth) before the ⊕ merge; an invalid patch is an `isError`
+  result carrying `error` and `field`, and nothing is written.
+  `redactSecrets` fails closed so secrets never leave the process through a
+  tool result or resource read.
+- Checkpoints live in `<stateDir>/checkpoints/<seq>-<label>.json` sidecars
+  (atomic writes) and also pin `<path>.snapshot` via `FileStore.snapshot()`;
+  the sequence numbers derive from the sidecar catalog, so they survive
+  restarts. The session `seq` reported by `state.summary` counts writes
+  applied through the server in this session.
 
 ## Related
 

package/dist/mcp-server.d.ts

@@ -1,8 +1,7 @@
 import type { Readable, Writable } from 'node:stream';
-import type { ProceduralSpec } from '@skillstate/core';
-import type { TokenTracker } from '@skillstate/core';
-/** MCP stdio framing modes the server can speak. */
-export type FrameMode = 'jsonl' | 'content-length';
+import type { ProceduralSpec, TokenTracker } from '@skillstate/core';
+/** The single MCP protocol revision this server speaks (initialize answer). */
+export declare const PROTOCOL_VERSION = "2026-07-28";
 /** A JSON-RPC request object (id may be a number, string, or null). */
 export interface JsonRpcRequest {
     jsonrpc?: string;
@@ -18,14 +17,26 @@ export interface McpToolResult {
     }>;
     isError?: boolean;
 }
+/** MCP tool annotations (the hints hosts surface in tool UIs). */
+export interface ToolAnnotations {
+    readOnlyHint: boolean;
+    destructiveHint: boolean;
+}
 /** Options for {@link McpServer}. */
 export interface McpServerOptions {
-    /** Procedural spec: drives `spec.get`, schema validation, and reset defaults. */
+    /** Procedural spec: drives `spec.get`/`spec.next`, schema validation, and state defaults. */
     spec: ProceduralSpec;
     /** State file root directory (confined by `resolveStatePath`). */
     root: string;
     /** State file name (confined by `resolveStatePath`). */
     name: string;
+    /**
+     * Default agent scope: `''` (the main agent) targets the plain state
+     * file; a non-empty id (sanitized `[A-Za-z0-9_-]`, ≤64) targets
+     * `agents/<id>/skillstate.json` inside the same bucket. Every tool call
+     * may still override the scope via `{ agent }` (and/or `{ root, name }`).
+     */
+    agent?: string;
     /** Optional token tracker for the `state.metrics` tool. */
     tracker?: TokenTracker;
 }
@@ -37,23 +48,38 @@ export interface LaunchArgs {
     root?: string;
     /** State file name override; defaults to the per-project state file name. */
     name?: string;
+    /** Default agent scope; falls back to the `SKILLSTATE_AGENT_ID` env. */
+    agent?: string;
     tracker?: TokenTracker;
     input?: Readable;
     output?: Writable;
+    /**
+     * Wire the SIGINT/SIGTERM interrupt handler that flushes
+     * `{ status: 'interrupted' }` + the diff baseline before exiting
+     * (default `true`). In-process embedders that own the process and
+     * manage their own teardown pass `false` — the handler exits the
+     * PROCESS, which is wrong for embedded servers.
+     */
+    installInterruptHandler?: boolean;
 }
 /**
  * The `skillstate` MCP server: a JSON-RPC 2.0 over stdio server exposing
- * the skillstate runtime as MCP tools.
+ * the skillstate runtime as MCP tools and resources.
  */
 export declare class McpServer {
     private readonly options;
-    /** Protocol version advertised by the server on `initialize`. */
-    readonly protocolVersion = "2024-11-05";
-    /** Advertised server capabilities (a minimal subset). */
+    /** Protocol revision advertised on `initialize` — always exactly this. */
+    readonly protocolVersion = "2026-07-28";
+    /** Advertised server capabilities. */
     readonly capabilities: {
         tools: {
             listChanged: boolean;
         };
+        resources: {};
+        logging: {};
+        prompts: {
+            listChanged: boolean;
+        };
     };
     /** Advertised server identity. */
     readonly serverInfo: {
@@ -62,72 +88,175 @@ export declare class McpServer {
     };
     private buffer;
     private running;
-    private frameMode;
+    /** Serializes `start()` stream handling so chunk order is preserved. */
+    private chain;
+    /**
+     * Diff baselines are persisted to disk (`.diff-baseline.json` next to
+     * each state file, under the cross-process lock) — the "since your last
+     * look" semantics stays, but is now CONSISTENT BETWEEN PROCESSES: the
+     * former in-memory per-server Map made two servers diff against
+     * different baselines.
+     */
+    /** Writes (patch/rollback) applied per resolved state path this session. */
+    private readonly writeSeq;
+    /** Debounce clock for `.session-meta.json` activity stamps (per meta path). */
+    private readonly lastActivityWrite;
+    /** Uninstall closure for the SIGINT/SIGTERM interrupt handler (if wired). */
+    private uninstallShutdown;
+    /** The `{ source, handler }` pair attached by `start()` (removed by `stop()`). */
+    private attached;
     constructor(options: McpServerOptions);
+    /**
+     * The state DIRECTORY the server session owns (its sidecars —
+     * `.session-meta.json`, the diff baseline — live next to the default
+     * state file; agent-scoped calls keep their per-agent directories).
+     */
+    private get sessionDir();
+    /**
+     * Stamp the session sidecar for `dir` with `lastActivityAt: now`,
+     * debounced to one write per {@link ACTIVITY_DEBOUNCE_MS} per directory
+     * (state writes stay the hot path). The meta sidecar is best-effort
+     * orchestration metadata: a failed write is swallowed — a broken
+     * sidecar never fails a state write. The write itself runs under the
+     * meta file's own `withStateLock` (never the state lock — no deadlock).
+     */
+    private touchActivity;
+    /**
+     * Wire the @non-paper shutdown seam: SIGINT/SIGTERM best-effort flush
+     * the session sidecar to `status: "interrupted"` + re-pin the diff
+     * baseline to the surviving state (the next process starts diffing from
+     * the post-crash state, not from a pre-crash baseline), then exit with
+     * the conventional 130. Terminal statuses (`completed` / `failed` /
+     * `merged`) recorded by the agent itself are never clobbered — hosts
+     * SIGTERM their servers after a clean finalize too. Idempotent; returns
+     * an uninstall closure for embedders/tests.
+     */
+    installInterruptHandler(): () => void;
+    /** Detach the SIGINT/SIGTERM handler (embedders/tests owning the process). */
+    detachInterruptHandler(): void;
     /**
      * Process a single (already-framed) JSON-RPC message line and return the
      * response string, or `null` when the message needs no reply (a
-     * notification). This is the stateless unit entry point used by the
-     * stdio transport; `feed` drives it for framed/streamed input.
+     * notification). The stateless unit entry point used by tests and the
+     * stdio transport.
      */
-    handleLine(line: string): string | null;
+    handleLine(line: string): Promise<string | null>;
     /**
-     * Feed a raw chunk of stdin and return every response produced by the
-     * complete messages it contains. Handles BOTH newline-delimited JSON-RPC
-     * and `Content-Length`-framed messages; partial frames are buffered until
-     * the rest arrives. Responses are framed like the message that triggered
-     * them.
+     * Feed a raw chunk of stdin and return every newline-delimited response
+     * produced by the complete messages it contains. Partial lines are
+     * buffered until the rest arrives. Each response ends with a newline.
      */
-    feed(chunk: string): string[];
+    feed(chunk: string): Promise<string[]>;
     /**
      * Attach the server to a stdin/stdout pair (defaults to `process`).
-     * Resolves once the server is reading; `stop()` detaches it. The server
-     * conserves its own buffered state, so real transports may hand over
-     * chunks that split mid-frame.
+     * Resolves once the server is reading; `stop()` detaches it. Chunks are
+     * processed strictly in arrival order even though handling is async.
      */
     start(input?: Readable, output?: Writable): Promise<McpServer>;
-    /** Mark the server stopped (idempotent). */
+    /**
+     * Mark the server stopped (idempotent): detaches the input listener
+     * attached by `start()` so embedded servers release their streams.
+     */
     stop(): void;
     /** Whether the server is currently reading from its input stream. */
     get isRunning(): boolean;
+    /** Append one chunk to the ordered stream pipeline. */
+    private pump;
     /** Parse raw text into a message and dispatch; `-32700` on parse error. */
     private processRaw;
     private processMessage;
     private handleRequest;
     private handleToolCall;
+    private handleResourceRead;
     private callTool;
     private stateGet;
     private statePatch;
-    private stateMerge;
-    private stateReset;
-    private specGet;
+    private stateValidate;
+    private stateDiff;
+    private stateCheckpoint;
+    private stateRollback;
+    private stateSummary;
     private stateMetrics;
+    /**
+     * `state.finalize` — the agent's own "I am done" signal. Writes the
+     * session sidecar `{ status, finishedAt, result }` under the meta lock
+     * and returns the recorded lifecycle so the orchestrator (or a later
+     * `agent.read`/`agent.list`) sees it. `result` is an optional free-text
+     * outcome; invalid statuses are rejected before anything is written.
+     */
+    private stateFinalize;
+    private specGet;
+    private specNext;
     /** Resolve the target state file path (args override the defaults). */
     private resolveStore;
+    /**
+     * The effective agent scope for a call: `{ agent }` wins, then the
+     * server default ({@link McpServerOptions.agent} — set from the
+     * `SKILLSTATE_AGENT_ID` env by {@link launch}). `''` = main agent.
+     */
+    private effectiveAgent;
+    /** Resolve `{ root, name, agent }` + the confined file path in one go. */
+    private resolveRef;
+    /** Required + sanitized `{ agent }` for the agent.* tools. */
+    private requireAgent;
+    /** State file path for a REQUIRED sub-agent id (read-only views). */
+    private agentStore;
+    /**
+     * `agent.list`: scan `<root>/agents/` and project each sub-agent state
+     * copy — id, statePath, exists, lastModified, lifecycle (status,
+     * lastActivityAt, staleness, ageMs) and a LIGHT summary (top-level keys
+     * + size only, no values). Non-directory entries and ids outside
+     * `[A-Za-z0-9_-]{1,64}` are skipped; a missing agents directory yields
+     * an empty list. The lifecycle comes from the agent dir's
+     * `.session-meta.json` sidecar: `orphan` when it is missing/corrupt,
+     * `stale` when a `running` session has not written anything for the
+     * core `STALE_MS` threshold (5 min — the provider died without a
+     * signal), `active` otherwise. A `running` agent reports its `ageMs`
+     * since the last
+     * activity so the main agent can tell "finished" from "died mid-run"
+     * at a glance.
+     */
+    private agentList;
+    /** `agent.read`: a sub-agent's state, READ-ONLY (the main agent peeks). */
+    private agentRead;
+    /**
+     * `agent.merge`: fold a sub-agent's state into the MAIN state under the
+     * cross-process lock (conflicting scalars resolved by `keep: 'main'` —
+     * the default — or `'sub'`; nested objects recurse; `null` deletes).
+     * The sub state is NOT deleted (history): it is marked with `mergedAt`.
+     * Returns `{ agent, keep, state, changes }`.
+     */
+    private agentMerge;
     /** Read + normalize the state, falling back to schema defaults. */
     private loadState;
-    /** Crash-safe synchronous write: temp sibling + fsync + rename. */
+    /** Advance the per-path session write counter. */
+    private bumpWriteSeq;
+    /**
+     * Crash-safe synchronous write of the versioned envelope
+     * `{ version, state }`: temp sibling + fsync + rename.
+     */
     private writeState;
-    private toolsList;
-    private resourcesList;
     /**
-     * Parse a `Content-Length`-framed message from the front of the buffer
-     * (the caller has already asserted the buffer begins with a valid
-     * `Content-Length:` header). Returns the body + consumed length, or
-     * `'incomplete'` if the payload has not all arrived.
+     * The DIFF BASELINE for a state file, persisted at
+     * `<stateDir>/.diff-baseline.json` (stateDir = the state file's
+     * directory — per state file, since agent scopes live in their own
+     * `agents/<id>/` directories). `null` = no baseline yet.
      */
-    private takeContentLengthFrame;
-    /** Encode a response in the given framing mode. */
-    private encodeResponse;
+    private readBaseline;
+    /** Crash-safe synchronous write of the diff baseline (atomic rename). */
+    private writeBaseline;
+    /** `.diff-baseline.json` lives next to its state file. */
+    private baselinePathFor;
+    private toolsList;
+    private resourcesList;
     private successResponse;
     private errorResponse;
     private textResult;
 }
 /**
- * Per-project state resolution for an MCP server session. Semantics are a
- * zero-dep mirror of `resolveStatePathForCwd` in `@skillstate/opencode`
- * (kept local: `@skillstate/mcp` depends only on `@skillstate/core` —
- * keep the two in sync):
+ * Per-project state resolution for an MCP server session — re-exported
+ * from `@skillstate/core` (the single source of truth shared with the
+ * OpenCode plugin and the generated hook scripts):
  *
  * - `cwd === home` — no single project → the global bucket
  *   `<home>/.skillstate/global/skillstate.json`;
@@ -135,16 +264,31 @@ export declare class McpServer {
  *
  * Pure path arithmetic (no filesystem access, `path.resolve` normalization).
  */
-export declare function resolveStatePathForCwd(cwd: string, home: string): string;
+export { resolveHostStateForCwd as resolveStatePathForCwd } from '@skillstate/core';
 /**
  * Launch an MCP server from an argument/env config (reads
  * `SKILLSTATE_SPEC_PATH` when not passed explicitly). State resolution is
  * ALWAYS per-project from the server's `process.cwd()`:
  * `<cwd>/.skillstate/skillstate.json` (the global bucket when cwd === home).
- * Hosts that launch local MCP servers with the project as cwd therefore get
- * per-project state without any baked path. Explicit `args.root`/`args.name`
- * remain available for in-process embedding. Defaults to the canonical
- * InterCode CTF spec.
+ * AGENT SCOPE: a non-empty `SKILLSTATE_AGENT_ID` env (or `args.agent`)
+ * scopes the default state file to `agents/<id>/skillstate.json` — host
+ * configs set the env per server instance when a sub-agent needs an
+ * isolated copy; the default is `''` (the main agent) and every tool call
+ * can still override via `{ agent }`. Hosts that launch local MCP servers
+ * with the project as cwd therefore get per-project state without any
+ * baked path. Explicit `args.root`/`args.name` remain available for
+ * in-process embedding. Defaults to the canonical InterCode CTF spec.
+ *
+ * SESSION LIFECYCLE (release 2.3.0): launch stamps the session sidecar
+ * `<stateDir>/.session-meta.json` with `{ status: 'running', startedAt,
+ * agentId, protocolVersion }` — overwriting any previous
+ * `interrupted`/`completed` marker (a new launch means a fresh run) — and
+ * wires the SIGINT/SIGTERM handler that flushes
+ * `{ status: 'interrupted' }` + the diff baseline before exiting. The
+ * agent is expected to call `state.finalize` at the end of its procedure.
+ * In-process embedders that do not own the process can pass
+ * `installInterruptHandler: false` (tests) or call
+ * `server.detachInterruptHandler()` afterwards.
  */
 export declare function launch(args?: LaunchArgs): Promise<McpServer>;
 //# sourceMappingURL=mcp-server.d.ts.map

package/dist/mcp-server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp-server.d.ts","sourceRoot":"","sources":["../src/mcp-server.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"mcp-server.d.ts","sourceRoot":"","sources":["../src/mcp-server.ts"],"names":[],"mappings":"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"}