driftseal 0.2.0 → 0.4.0

package/README.md

@@ -12,7 +12,7 @@ Before an agent touches the code, DriftSeal records what this round will accompl
 seal intent → do the work → prove the result → close the round
 ```
 
-**One open intent. One declared proof. One durable trail.** No service, no database, no runtime dependencies—just a Node.js CLI and plain files that travel with the repo.
+**One open intent. One declared proof. One durable trail.** No service and no database—just local Node.js tools and plain files that travel with the repo.
 
 ## The problem is not speed. It is drift.
 
@@ -46,6 +46,45 @@ npm link
 
 The package includes `skills/use-driftseal`, an agent-agnostic companion skill that drives repository work through the complete DriftSeal loop while keeping decision records selective. Install or link it using your agent runtime’s skill discovery convention, then invoke `use-driftseal` by name.
 
+## Use DriftSeal through MCP
+
+The same package includes `driftseal-mcp`, a local stdio MCP server. It exposes
+structured tools for the complete intent and decision workflow while reusing the
+same locking, WAL, atomic-write, schema, and recovery implementation as the CLI.
+The server never shells out to `driftseal` and does not parse CLI output.
+
+Fix the server to one repository when starting it:
+
+```sh
+driftseal-mcp --root /absolute/path/to/repository
+```
+
+For Codex, add the installed command as a stdio MCP server:
+
+```sh
+codex mcp add driftseal -- driftseal-mcp --root /absolute/path/to/repository
+```
+
+The root is startup configuration, not a tool input. In MCP mode DriftSeal also
+ignores inherited `DRIFTSEAL_HOME` and `DRIFTSEAL_DECISION_HOME` overrides, so a
+tool call cannot redirect writes outside the selected repository.
+
+The v1 server provides:
+
+| MCP capability | Purpose |
+| --- | --- |
+| `driftseal_status`, `driftseal_log` | Read the current intent and intent history. |
+| `driftseal_begin`, `driftseal_end` | Open and honestly close a work round. |
+| `driftseal_reclaim`, `driftseal_unreclaim` | Hide meaningless closed records behind append-only markers, or restore them. |
+| `driftseal_decision_list`, `driftseal_decision_show` | Find and read MADR records. |
+| `driftseal_decision_add`, `driftseal_decision_update` | Add selective decisions and reconcile linked ones. |
+| `driftseal://intent/current` | Read the current intent as a JSON resource. |
+| `driftseal://intents/recent` | Read the ten most recent intents as a JSON resource. |
+| `driftseal://decisions` | Read the decision catalog as a JSON resource. |
+
+The companion skill remains important: MCP supplies controlled, structured
+operations; the skill teaches the agent when to use them and how to avoid drift.
+
 ## A work round
 
 Declare the round before changing files:
@@ -75,7 +114,9 @@ Single-step commands that only build, check, or record work already done — com
 | `driftseal begin "<intent>" [-v "<verify>"] [--decision id] [--force]` | Open a work-round intent and optionally link existing decisions. |
 | `driftseal end [id] [-s status] [-n note] [-r verify-result]` | Close an intent honestly. |
 | `driftseal status` | Show the intent currently in progress. |
-| `driftseal log [-n N]` | Review intent history. |
+| `driftseal log [-n N] [--all]` | Review intent history (`--all` includes reclaimed records). |
+| `driftseal reclaim [id ...] --reason "..." [--older-than days] [--force] [--dry-run]` | Hide meaningless closed records behind append-only markers. |
+| `driftseal unreclaim <id> --reason "..."` | Restore a reclaimed record to the visible log. |
 | `driftseal decision add "<title>" -c "..." -o "..."` | Write a numbered MADR decision. |
 | `driftseal decision update <id> [-s status] -n "..."` | Reconcile a linked decision in the open intent. |
 | `driftseal decision list [-s status] [--last N \| --count]` | List or count decision records, optionally filtered by status. |
@@ -89,6 +130,22 @@ close as `completed` or `partial`. The update changes the current status when
 requested and appends a timestamped history entry tied to the intent. Intents
 without decision links keep the ordinary workflow.
 
+## Reclaiming noise records
+
+Some closed records stop mattering: a harness or sandbox failure is recorded
+honestly as `failed`, but it says nothing about the project. `driftseal
+reclaim` retires such records without rewriting history — it appends a
+`reclaim` marker (with a mandatory `--reason`) to the same append-only log,
+and reclaimed records disappear from `driftseal log` and `driftseal status`
+output while remaining in `events.jsonl` and visible with `log --all`.
+`driftseal unreclaim <id> --reason "..."` restores a record that turned out to
+matter.
+
+Without ids, batch mode reclaims only closed `failed`/`abandoned` records that
+are not linked to decisions and are older than `--older-than` days (default
+7); use `--dry-run` to preview. `completed` and `partial` records, and any
+decision-linked record, can only be reclaimed by explicit id with `--force`.
+
 ## Consistency and recovery
 
 DriftSeal serializes mutating commands with locks on the configured intent and
@@ -119,7 +176,7 @@ index.
 
 ## Storage
 
-- `.intent-log/events.jsonl` is the append-only intent log.
+- `.intent-log/events.jsonl` is the append-only intent log. All access goes through `driftseal` (CLI or MCP) — never read, edit, move, or delete it directly; use `driftseal reclaim` to retire meaningless records instead of deleting log lines.
 - `.decision-log/` contains numbered MADR decision records.
 - Set `DRIFTSEAL_HOME` or `DRIFTSEAL_DECISION_HOME` to store either log outside the current project.
 

package/README.zh-CN.md

@@ -12,7 +12,7 @@ Agentic coding 可以很快。**DriftSeal 让这种快不以失控为代价。**
 封存 intent → 执行工作 → 证明结果 → 关闭本轮
 ```
 
-**一个 open intent，一份预先声明的验证标准，一条可靠留存的工作轨迹。** 不需要 service，不需要 database，也没有 runtime dependencies；只有一个 Node.js CLI，以及跟着 repo 一起走的普通文件。
+**一个 open intent，一份预先声明的验证标准，一条可靠留存的工作轨迹。** 不需要 service，也不需要 database；只有本地 Node.js tools，以及跟着 repo 一起走的普通文件。
 
 ## 真正麻烦的不是慢，而是偏航
 
@@ -46,6 +46,45 @@ npm link
 
 npm package 内含 `skills/use-driftseal`。这是一个不绑定特定 agent runtime 的配套 skill，会按完整 DriftSeal 闭环执行仓库任务，同时克制地使用 decision record。按照所用 agent runtime 的 skill discovery 约定安装或 link，之后通过名称 `use-driftseal` 调用即可。
 
+## 通过 MCP 使用 DriftSeal
+
+同一个 package 还提供本地 stdio MCP server：`driftseal-mcp`。它为完整的
+intent 与 decision 工作流提供结构化 tools，并与 CLI 复用同一套锁、WAL、
+atomic write、schema 和 recovery 实现。server 不会启动 `driftseal` 子进程，
+也不需要解析 CLI 输出。
+
+启动时把 server 固定到一个 repository：
+
+```sh
+driftseal-mcp --root /absolute/path/to/repository
+```
+
+在 Codex 中，可以把安装后的命令添加为 stdio MCP server：
+
+```sh
+codex mcp add driftseal -- driftseal-mcp --root /absolute/path/to/repository
+```
+
+root 只能在启动时配置，不是 tool input。MCP 模式也会忽略继承到进程中的
+`DRIFTSEAL_HOME` 和 `DRIFTSEAL_DECISION_HOME` override，因此 tool call 不能把
+写入重定向到所选 repository 之外。
+
+v1 server 提供：
+
+| MCP capability | 用途 |
+| --- | --- |
+| `driftseal_status`, `driftseal_log` | 读取当前 intent 和 intent 历史。 |
+| `driftseal_begin`, `driftseal_end` | 开启并诚实关闭一轮工作。 |
+| `driftseal_reclaim`, `driftseal_unreclaim` | 用 append-only 标记隐藏已无意义的已关闭记录，或将其恢复。 |
+| `driftseal_decision_list`, `driftseal_decision_show` | 查找并读取 MADR record。 |
+| `driftseal_decision_add`, `driftseal_decision_update` | 克制地增加 decision，并 reconcile 已关联的 decision。 |
+| `driftseal://intent/current` | 以 JSON resource 读取当前 intent。 |
+| `driftseal://intents/recent` | 以 JSON resource 读取最近十条 intent。 |
+| `driftseal://decisions` | 以 JSON resource 读取 decision catalog。 |
+
+配套 skill 仍然不可替代：MCP 提供受控、结构化的操作，skill 则告诉 agent
+何时使用这些操作，以及怎样避免 drift。
+
 ## 一轮标准工作流
 
 修改文件前，先声明这轮工作的目标：
@@ -75,7 +114,9 @@ driftseal end \
 | `driftseal begin "<intent>" [-v "<verify>"] [--decision id] [--force]` | 开启一轮工作，并可关联已有 decision。 |
 | `driftseal end [id] [-s status] [-n note] [-r verify-result]` | 诚实地关闭 intent。 |
 | `driftseal status` | 查看当前进行中的 intent。 |
-| `driftseal log [-n N]` | 查看 intent 历史。 |
+| `driftseal log [-n N] [--all]` | 查看 intent 历史（`--all` 包含已回收的记录）。 |
+| `driftseal reclaim [id ...] --reason "..." [--older-than days] [--force] [--dry-run]` | 用 append-only 标记隐藏已无意义的已关闭记录。 |
+| `driftseal unreclaim <id> --reason "..."` | 把已回收的记录恢复到可见历史中。 |
 | `driftseal decision add "<title>" -c "..." -o "..."` | 写入编号化的 MADR decision。 |
 | `driftseal decision update <id> [-s status] -n "..."` | 在当前 intent 中 reconcile 已关联的 decision。 |
 | `driftseal decision list [-s status] [--last N \| --count]` | 列出或统计 decision records，也可按 status 筛选。 |
@@ -88,6 +129,19 @@ driftseal end \
 每一条关联 decision。update 可以改变当前 status，并会追加一条包含时间和
 intent ID 的 history。没有关联 decision 的 intent 仍沿用普通流程。
 
+## 回收已无意义的记录
+
+有些已关闭的记录会随着时间失去意义：harness 或 sandbox 导致的失败会被如实记录为
+`failed`，但它与项目本身无关。`driftseal reclaim` 可以在不改写历史的前提下让这类
+记录退场——它只是向同一个 append-only log 追加一条 `reclaim` 标记（必须附带
+`--reason`），被回收的记录会从 `driftseal log` 和 `driftseal status` 的输出中隐藏，
+但仍保留在 `events.jsonl` 中，并可通过 `log --all` 查看。若事后发现某条记录仍然
+重要，用 `driftseal unreclaim <id> --reason "..."` 恢复。
+
+不带 id 的批量模式只回收已关闭、未关联 decision、且早于 `--older-than` 天（默认 7
+天）的 `failed`/`abandoned` 记录；可以先用 `--dry-run` 预览。`completed` 和 `partial`
+记录，以及任何关联了 decision 的记录，只能按显式 id 加 `--force` 回收。
+
 ## 一致性与恢复
 
 DriftSeal 会对配置后的 intent log 与 decision log 根目录加锁，并按固定顺序获取这些
@@ -114,7 +168,7 @@ recovery 只处理当前 intent，因此历史冲突不会阻塞之后的 decisi
 
 ## 数据保存在哪里
 
-- `.intent-log/events.jsonl`：append-only intent log。
+- `.intent-log/events.jsonl`：append-only intent log。所有读写都必须经过 `driftseal`（CLI 或 MCP）——不要直接读取、修改、移动或删除该文件；需要让无意义的记录退场时使用 `driftseal reclaim`，而不是删除日志行。
 - `.decision-log/`：编号化的 MADR decision records。
 - 设置 `DRIFTSEAL_HOME` 或 `DRIFTSEAL_DECISION_HOME`，即可把对应 log 放到当前项目之外。
 

package/bin/driftseal-mcp.js

@@ -0,0 +1,405 @@
+#!/usr/bin/env node
+'use strict';
+
+const path = require('node:path');
+const { createApi, DECISION_STATUSES, END_STATUSES } = require('./driftseal.js');
+
+const SERVER_NAME = 'driftseal';
+const SERVER_VERSION = require('../package.json').version;
+
+function parseArguments(argv) {
+  let root = process.cwd();
+  for (let index = 0; index < argv.length; index++) {
+    const argument = argv[index];
+    if (argument === '--help' || argument === '-h') return { help: true, root };
+    if (argument === '--root') {
+      const value = argv[++index];
+      if (!value || value.startsWith('-')) throw new Error('--root requires a directory');
+      root = value;
+      continue;
+    }
+    if (argument.startsWith('--root=')) {
+      const value = argument.slice('--root='.length);
+      if (!value) throw new Error('--root requires a directory');
+      root = value;
+      continue;
+    }
+    throw new Error(`unknown argument: ${argument}`);
+  }
+  return { help: false, root };
+}
+
+function helpText() {
+  return `DriftSeal MCP server
+
+usage:
+  driftseal-mcp [--root <repository>]
+
+The server uses stdio transport and fixes all DriftSeal state to the selected
+repository. Tool calls cannot select another root.`;
+}
+
+function jsonText(value) {
+  return JSON.stringify(value, null, 2);
+}
+
+function success(structuredContent, summary) {
+  return {
+    structuredContent,
+    content: [{ type: 'text', text: summary || jsonText(structuredContent) }],
+  };
+}
+
+function failure(error) {
+  const message = error && error.message ? error.message : String(error);
+  return {
+    isError: true,
+    content: [{ type: 'text', text: `DriftSeal rejected the operation: ${message}` }],
+  };
+}
+
+function guarded(action) {
+  try {
+    return action();
+  } catch (error) {
+    return failure(error);
+  }
+}
+
+function registerTools(server, api, z) {
+  const intentRecord = z.object({
+    id: z.string(),
+    intent: z.string(),
+    verify: z.string().nullable(),
+    decisions: z.array(z.string()),
+    status: z.enum(END_STATUSES).or(z.literal('in_progress')),
+    note: z.string().nullable(),
+    verifyResult: z.string().nullable(),
+    beganAt: z.string(),
+    endedAt: z.string().nullable(),
+    reclaimed: z.boolean(),
+    reclaimReason: z.string().nullable(),
+    reclaimedAt: z.string().nullable(),
+  });
+  const decisionRecord = z.object({
+    id: z.string(),
+    title: z.string(),
+    status: z.enum(DECISION_STATUSES),
+    file: z.string(),
+  });
+  const decisionWithContent = decisionRecord.extend({ content: z.string() });
+  const closedStatus = z.enum(END_STATUSES);
+  const decisionStatus = z.enum(DECISION_STATUSES);
+  const decisionId = z.string().regex(/^\d+$/, 'decision id must contain only digits');
+  const nonEmpty = z.string().trim().min(1);
+  const readOnly = { readOnlyHint: true, destructiveHint: false, openWorldHint: false };
+  const localWrite = { readOnlyHint: false, destructiveHint: false, openWorldHint: false };
+
+  server.registerTool(
+    'driftseal_status',
+    {
+      title: 'Get current DriftSeal intent',
+      description:
+        'Inspect the one intent currently in progress before repository work or after context loss. Returns null when no intent is open.',
+      inputSchema: {},
+      outputSchema: { root: z.string(), intent: intentRecord.nullable() },
+      annotations: readOnly,
+    },
+    async () =>
+      guarded(() => {
+        const intent = api.status();
+        return success(
+          { root: api.root, intent },
+          intent ? `Intent ${intent.id} is ${intent.status}.` : 'No DriftSeal intent is in progress.'
+        );
+      })
+  );
+
+  server.registerTool(
+    'driftseal_begin',
+    {
+      title: 'Begin a DriftSeal intent',
+      description:
+        'Open one focused work-round intent before making repository changes. Fails if another intent is already open; close it explicitly first.',
+      inputSchema: {
+        intent: nonEmpty.describe('Outcome this work round will accomplish.'),
+        verify: nonEmpty.optional().describe('Exact command or outcome check that will prove completion.'),
+        decisions: z
+          .array(decisionId)
+          .default([])
+          .describe('Existing decision IDs this round may change or explicitly confirm.'),
+      },
+      outputSchema: { root: z.string(), intent: intentRecord },
+      annotations: localWrite,
+    },
+    async (input) =>
+      guarded(() => {
+        const intent = api.begin(input);
+        return success({ root: api.root, intent }, `Opened DriftSeal intent ${intent.id}.`);
+      })
+  );
+
+  server.registerTool(
+    'driftseal_end',
+    {
+      title: 'Close a DriftSeal intent',
+      description:
+        'Close the current work-round intent with an honest terminal status, note, and verification result. Linked decisions must be reconciled before completed or partial closure.',
+      inputSchema: {
+        id: z.string().optional().describe('Intent ID; omit to close the current open intent.'),
+        status: closedStatus.default('completed'),
+        note: nonEmpty.optional().describe('What actually happened in the round.'),
+        verifyResult: nonEmpty.optional().describe('Concise, honest result of the declared verification.'),
+      },
+      outputSchema: { root: z.string(), intent: intentRecord },
+      annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: false },
+    },
+    async (input) =>
+      guarded(() => {
+        const intent = api.end(input);
+        return success({ root: api.root, intent }, `Closed DriftSeal intent ${intent.id} as ${intent.status}.`);
+      })
+  );
+
+  server.registerTool(
+    'driftseal_log',
+    {
+      title: 'List DriftSeal intent history',
+      description:
+        'Review recent or complete DriftSeal intent history to re-anchor work and understand prior outcomes. Reclaimed records are hidden unless includeReclaimed is set.',
+      inputSchema: {
+        last: z.number().int().positive().max(100).optional(),
+        includeReclaimed: z.boolean().default(false),
+      },
+      outputSchema: { root: z.string(), intents: z.array(intentRecord) },
+      annotations: readOnly,
+    },
+    async (input) =>
+      guarded(() => {
+        const intents = api.log({ last: input.last, all: input.includeReclaimed });
+        return success({ root: api.root, intents }, `Found ${intents.length} DriftSeal intent records.`);
+      })
+  );
+
+  server.registerTool(
+    'driftseal_reclaim',
+    {
+      title: 'Reclaim DriftSeal intent records',
+      description:
+        'Hide meaningless closed intent records (for example harness- or sandbox-caused failures) by appending reclaim markers. Never deletes log lines. Without ids, reclaims failed/abandoned, decision-unlinked records older than olderThan days.',
+      inputSchema: {
+        ids: z
+          .array(z.string())
+          .default([])
+          .describe('Intent IDs to reclaim; omit for batch mode by age.'),
+        reason: nonEmpty.describe('Why these records are meaningless (required, kept in the log).'),
+        olderThan: z
+          .number()
+          .int()
+          .positive()
+          .optional()
+          .describe('Batch mode retention window in days (default 7).'),
+        force: z
+          .boolean()
+          .default(false)
+          .describe('Allow reclaiming partial/completed or decision-linked records by explicit id.'),
+        dryRun: z.boolean().default(false),
+      },
+      outputSchema: { root: z.string(), intents: z.array(intentRecord) },
+      annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: false },
+    },
+    async (input) =>
+      guarded(() => {
+        const intents = api.reclaim({
+          ids: input.ids,
+          reason: input.reason,
+          olderThan: input.olderThan,
+          force: input.force,
+          dryRun: input.dryRun,
+        });
+        return success(
+          { root: api.root, intents },
+          input.dryRun
+            ? `${intents.length} DriftSeal intent records match.`
+            : `Reclaimed ${intents.length} DriftSeal intent records.`
+        );
+      })
+  );
+
+  server.registerTool(
+    'driftseal_unreclaim',
+    {
+      title: 'Restore a reclaimed DriftSeal intent record',
+      description: 'Restore one reclaimed intent record to the visible log by appending an unreclaim marker.',
+      inputSchema: {
+        id: z.string(),
+        reason: nonEmpty.describe('Why this record is being restored (required, kept in the log).'),
+      },
+      outputSchema: { root: z.string(), intent: intentRecord },
+      annotations: localWrite,
+    },
+    async (input) =>
+      guarded(() => {
+        const intent = api.unreclaim(input);
+        return success({ root: api.root, intent }, `Restored DriftSeal intent ${intent.id}.`);
+      })
+  );
+
+  server.registerTool(
+    'driftseal_decision_list',
+    {
+      title: 'List DriftSeal decisions',
+      description:
+        'Find MADR decision records, optionally filtered by current status. Use this before showing or linking a decision.',
+      inputSchema: {
+        status: decisionStatus.optional(),
+        last: z.number().int().positive().max(100).optional(),
+      },
+      outputSchema: { root: z.string(), decisions: z.array(decisionRecord) },
+      annotations: readOnly,
+    },
+    async (input) =>
+      guarded(() => {
+        const decisions = api.decisionList(input);
+        return success({ root: api.root, decisions }, `Found ${decisions.length} DriftSeal decisions.`);
+      })
+  );
+
+  server.registerTool(
+    'driftseal_decision_show',
+    {
+      title: 'Show a DriftSeal decision',
+      description: 'Read one complete MADR decision record by stable numeric ID.',
+      inputSchema: { id: decisionId },
+      outputSchema: { root: z.string(), decision: decisionWithContent },
+      annotations: readOnly,
+    },
+    async ({ id }) =>
+      guarded(() => {
+        const decision = api.decisionShow({ id });
+        return success({ root: api.root, decision }, `Loaded DriftSeal decision ${decision.id}.`);
+      })
+  );
+
+  server.registerTool(
+    'driftseal_decision_add',
+    {
+      title: 'Add a DriftSeal decision',
+      description:
+        'Create a MADR record only for durable rationale, rejected paths, deferred choices, or costly-to-reverse decisions that Git and the intent log cannot recover.',
+      inputSchema: {
+        title: nonEmpty,
+        context: nonEmpty,
+        outcome: nonEmpty,
+        status: decisionStatus.default('accepted'),
+        drivers: z.array(nonEmpty).default([]),
+        options: z.array(nonEmpty).default([]),
+        consequences: z.array(nonEmpty).default([]),
+      },
+      outputSchema: { root: z.string(), decision: decisionWithContent },
+      annotations: localWrite,
+    },
+    async (input) =>
+      guarded(() => {
+        const decision = api.decisionAdd(input);
+        return success({ root: api.root, decision }, `Created DriftSeal decision ${decision.id}.`);
+      })
+  );
+
+  server.registerTool(
+    'driftseal_decision_update',
+    {
+      title: 'Reconcile a DriftSeal decision',
+      description:
+        'Reconcile one decision linked to the current open intent, updating or explicitly confirming its status with a history note.',
+      inputSchema: {
+        id: decisionId,
+        status: decisionStatus.optional(),
+        note: nonEmpty,
+      },
+      outputSchema: { root: z.string(), decision: decisionWithContent },
+      annotations: localWrite,
+    },
+    async (input) =>
+      guarded(() => {
+        const decision = api.decisionUpdate(input);
+        return success({ root: api.root, decision }, `Reconciled DriftSeal decision ${decision.id}.`);
+      })
+  );
+}
+
+function registerResources(server, api) {
+  const registerJson = (name, uri, title, description, read) => {
+    server.registerResource(
+      name,
+      uri,
+      { title, description, mimeType: 'application/json' },
+      async () => {
+        const value = read();
+        return { contents: [{ uri, mimeType: 'application/json', text: jsonText(value) }] };
+      }
+    );
+  };
+
+  registerJson(
+    'current-intent',
+    'driftseal://intent/current',
+    'Current DriftSeal intent',
+    'The work-round intent currently in progress for the fixed repository.',
+    () => ({ root: api.root, intent: api.status() })
+  );
+  registerJson(
+    'recent-intents',
+    'driftseal://intents/recent',
+    'Recent DriftSeal intents',
+    'The ten most recent work-round intent records for the fixed repository.',
+    () => ({ root: api.root, intents: api.log({ last: 10 }) })
+  );
+  registerJson(
+    'decision-catalog',
+    'driftseal://decisions',
+    'DriftSeal decision catalog',
+    'All MADR decision summaries for the fixed repository.',
+    () => ({ root: api.root, decisions: api.decisionList() })
+  );
+}
+
+async function createServer({ root }) {
+  const [{ McpServer }, { StdioServerTransport }, zod] = await Promise.all([
+    import('@modelcontextprotocol/sdk/server/mcp.js'),
+    import('@modelcontextprotocol/sdk/server/stdio.js'),
+    import('zod'),
+  ]);
+  const z = zod.z || zod.default || zod;
+  const api = createApi({ root: path.resolve(root), isolateStorage: true });
+  const server = new McpServer(
+    { name: SERVER_NAME, version: SERVER_VERSION },
+    {
+      instructions:
+        'Use driftseal_status before repository changes or after context loss. Open one focused intent with driftseal_begin before changes, then run the declared verification and close it honestly with driftseal_end. Reconcile every linked decision before completed or partial closure.',
+    }
+  );
+  registerTools(server, api, z);
+  registerResources(server, api);
+  return { server, transport: new StdioServerTransport(), root: api.root };
+}
+
+async function main() {
+  const options = parseArguments(process.argv.slice(2));
+  if (options.help) {
+    process.stdout.write(helpText() + '\n');
+    return;
+  }
+  const { server, transport } = await createServer(options);
+  await server.connect(transport);
+}
+
+module.exports = { createServer, helpText, parseArguments, registerResources, registerTools };
+
+if (require.main === module) {
+  main().catch((error) => {
+    const message = error && error.message ? error.message : String(error);
+    console.error(`driftseal-mcp: error: ${message}`);
+    process.exitCode = 1;
+  });
+}