driftseal 2.0.0 → 3.0.0

package/README.md

@@ -28,15 +28,19 @@ DriftSeal v2 is an outcome log rather than an intent-per-step log.
   decision link to the currently open outcome.
 - Every extension changes the contract hash and invalidates earlier verification
   and MADR reconciliation.
-- Stored events use `logVersion: 2` and `schemaVersion: 1`.
-- The generated `AGENTS.md` protocol series is `2.0`; compatible protocol
-  refinements use `2.1`, `2.2`, and so on.
+- Stored events use `logVersion: 2`. Compatible clients accept `schemaVersion`
+  `1` or `2`; lane events and non-default `begin.lane` use `schemaVersion: 2`.
+- The generated `AGENTS.md` protocol series is `2.1`. `driftseal init` upgrades
+  recognized `2.0` blocks.
+- Named lanes partition outcome history on the same WAL. The default lane is
+  `main`; `driftseal log` follows the current lane.
 - The public CLI, Node API, MCP tools, and MCP resources use outcome terminology.
   v1 names and storage paths are not runtime aliases.
 
 ## Install
 
-DriftSeal requires Node.js 18 or newer.
+DriftSeal requires Node.js 22.13 or newer. Its derived outcome index uses the
+built-in `node:sqlite` module; no native database package is installed.
 
 ```sh
 npm install --global driftseal
@@ -121,6 +125,56 @@ The scope belongs to the worktree, not to the agent process. Agents and subagent
 working in the same worktree resume its matching open outcome. Separate worktrees
 hold separate outcomes.
 
+## Lanes
+
+Orthogonal long-lived capabilities can share one append-only log without sharing
+narrative context. Each outcome belongs to one named lane. Untagged history lives
+on `main`. `status` and `log --last 3` follow the current lane, which is local to
+the worktree.
+
+```sh
+driftseal lane add index --desc "On-disk inverted index"
+driftseal lane switch index
+driftseal begin "Ship the inverted index" --accept "lookups return stored postings" --verify "npm test"
+```
+
+Close the open outcome before switching. Later work on the same capability
+switches back and begins a new outcome on that lane; it does not reopen a closed
+record. `driftseal lane assign <id> <name>` moves a closed outcome. Cross-cutting
+work stays on `main`. An open outcome stays visible in `log` even when it belongs
+to another lane; `status` prints that lane when it differs from the current one.
+
+Lanes cannot be renamed or removed. A typo in `lane add` stays in `driftseal lane`
+output; add the intended name and stop using the old one.
+
+If a `begin` names a lane whose `lane_add` is missing, DriftSeal infers the lane
+so `status`, `log`, and `lane` still work, and `lane add` can write the missing
+event. Duplicate `lane_add` records last-write the description instead of failing
+the fold. A `lane_assign` that names an unknown lane infers it the same way.
+If the worktree's current-lane pointer names a lane the WAL no longer
+has, `status`, `log`, and `lane` fall back to `main` with a warning; `begin`
+still refuses until you `lane switch main` or add the lane. `log --last N` can
+return more than N records when an open outcome sits on another lane.
+
+A derived SQLite outcome index stores folded records in Git metadata (or beside
+a custom seal). It is a disposable read model; `events.jsonl` remains the only
+canonical history. Incremental sync follows `indexedThrough` and
+`indexedLines`. File identity makes unchanged hot reads constant-time, while a
+full checksum of the previously indexed WAL prefix validates every incremental
+catch-up. A source rewrite, incompatible schema, malformed indexed row, or
+SQLite read error triggers a full rebuild.
+
+`log --last N` uses a `(lane, reclaimed, ordinal)` SQLite index and reads only
+the selected outcome rows plus open outcomes from other lanes. Parked events
+are checked and folded as a targeted overlay using indexed committed event
+identities, so an open outcome does not force a committed-WAL scan. When a
+lock-free read sees a missing or stale database, DriftSeal folds the canonical
+WAL in memory instead of serving stale index data. Stored WAL byte ranges remain
+available for future projections but are not required for recent-log lookup.
+The database is reconstructable and is not committed with the log. Custom-home
+sidecars sit next to `events.jsonl`; when that directory is inside a Git
+worktree, they are listed in its `.gitignore`.
+
 ## Decisions and MADR
 
 Use a MADR only for context that the outcome log and Git cannot recover: a
@@ -152,8 +206,9 @@ driftseal decision update 1 --status accepted --note "Confirmed by the final imp
 | `driftseal extend "<addition>" [--accept "..."] [--verify "..."] [--decision id]` | Append scope to the same outcome and invalidate earlier verification. |
 | `driftseal verify [--allow-tracked-command]` | Execute the declared cumulative verifier and bind evidence. |
 | `driftseal end [id] [-s status] [-n note] [-r verify-result]` | Close an outcome honestly. |
-| `driftseal status` | Show the outcome in progress. |
-| `driftseal log [--last N] [--all]` | Review outcome history. |
+| `driftseal status` | Show the outcome in progress and the current lane. |
+| `driftseal log [--last N] [--all] [--all-lanes]` | Review outcome history (current lane unless `--all-lanes`). |
+| `driftseal lane add\|switch\|assign\|show` | Partition history by long-lived capability. |
 | `driftseal reclaim [id ...] --reason "..." [--force]` | Hide meaningless closed records with append-only markers. |
 | `driftseal unreclaim <id> --reason "..."` | Restore a reclaimed record. |
 | `driftseal absorb [other-events.jsonl] [--decisions dir] [--abandon-theirs\|--abandon-ours]` | Merge another lineage and remap colliding outcome or MADR ids. |
@@ -266,24 +321,31 @@ seal.begin({
 seal.extend({ extension: 'Document token expiry' });
 ```
 
-The API also exposes `status`, `verify`, `end`, `log`, `absorb`, reclaim,
-decision, init, and migration methods.
+The API also exposes `status`, `verify`, `end`, `log`, `lane`, `laneAdd`,
+`laneSwitch`, `laneAssign`, `absorb`, reclaim, decision, init, and migration
+methods.
 
 The stdio MCP server fixes all operations to one repository root. Its v2 tools
 include `driftseal_status`, `driftseal_begin`, `driftseal_extend`,
-`driftseal_verify`, `driftseal_end`, outcome history and absorb tools, MADR
-tools, and the three migration tools. Resources are:
+`driftseal_verify`, `driftseal_end`, outcome history, lane, and absorb tools,
+MADR tools, and the three migration tools. Resources are:
 
 - `driftseal://outcome/current`
 - `driftseal://outcomes/recent`
+- `driftseal://lanes`
 - `driftseal://madr`
 
 ## Storage and trust boundary
 
 - `.seal/outcomes/events.jsonl` is the append-only outcome log. Access it through
-  DriftSeal; use `reclaim`, `unreclaim`, and `absorb` instead of manual edits.
+  DriftSeal; use `reclaim`, `unreclaim`, `lane`, and `absorb` instead of manual edits.
 - `.seal/madr/` stores numbered MADR documents.
 - `$DRIFTSEAL_HOME` replaces the `.seal` root.
+- The current lane and derived SQLite outcome index live in Git metadata for a default
+  repository seal, or beside a custom seal (`outcomes/.current-lane` and
+  `outcomes/.outcome-index.sqlite`). When the custom seal sits inside a Git
+  worktree, those sidecars are gitignored. They are reconstructable and are not
+  part of the committed WAL.
 - Advisory hooks remind agents about lifecycle state but never broaden the
   repository's `AGENTS.md` policy.
 

package/README.zh-CN.md

@@ -23,14 +23,18 @@ DriftSeal v2 从“按步骤记录 intent”改为“按交付记录 outcome”
   目录；migration 时需要显式传入旧位置，之后再 unset 或替换这个变量。
 - `driftseal extend` 可以向当前 outcome 追加步骤、acceptance、verifier 或 decision link。
 - 每次 extend 都会改变 contract hash，并让之前的 verification 与 MADR reconciliation 失效。
-- event 使用 `logVersion: 2`、`schemaVersion: 1`。
-- `AGENTS.md` 的新协议版本从 `2.0` 开始，兼容改进依次使用 `2.1`、`2.2`。
+- event 使用 `logVersion: 2`。兼容客户端接受 `schemaVersion` `1` 或 `2`；lane
+  事件以及非默认的 `begin.lane` 使用 `schemaVersion: 2`。
+- `AGENTS.md` 的新协议版本是 `2.1`。`driftseal init` 会升级可识别的 `2.0` block。
+- 具名 lane 在同一条 WAL 上切分 outcome 历史。默认 lane 是 `main`；`driftseal log`
+  跟随当前 lane。
 - CLI、Node API、MCP tool 与 resource 全部使用 outcome 命名；v1 名称和路径不会作为
   runtime alias 保留。
 
 ## 安装
 
-DriftSeal 需要 Node.js 18 或更高版本。
+DriftSeal 需要 Node.js 22.13 或更高版本。派生 outcome index 使用 Node 内置的
+`node:sqlite`，不会安装 native database package。
 
 ```sh
 npm install --global driftseal
@@ -109,6 +113,48 @@ driftseal log --last 3
 作用域属于 worktree，而不是某一个 agent process。同一 worktree 内的 agent 与
 subagent 重新锚定并继续匹配的 open outcome；不同 worktree 各自持有 outcome。
 
+## Lane
+
+彼此正交、会长期回来接着做的能力，可以共用一条 append-only log，而不共用叙事上下文。
+每个 outcome 只属于一条具名 lane。未打标签的历史在 `main` 上。`status` 与
+`log --last 3` 跟随当前 lane，指针是 worktree 本地的。
+
+```sh
+driftseal lane add index --desc "On-disk inverted index"
+driftseal lane switch index
+driftseal begin "Ship the inverted index" --accept "lookups return stored postings" --verify "npm test"
+```
+
+有 open outcome 时不能切 lane。以后回到同一能力，是切回去再 `begin` 新的 outcome，
+而不是重开已关闭的记录。`driftseal lane assign <id> <name>` 可以把已关闭的 outcome
+移过去。跨切工作留在 `main`。open outcome 即使属于别的 lane，也会出现在 `log` 里；
+若它和当前 lane 不同，`status` 会写出它的 lane。
+
+lane 不能改名或删除。`lane add` 打错的名字会一直出现在 `driftseal lane` 输出里；
+补上正确名字，旧名字不要再用。
+
+如果 `begin` 引用了 WAL 里没有 `lane_add` 的 lane，DriftSeal 会推断这条 lane，
+让 `status` / `log` / `lane` 仍可读，也允许再用 `lane add` 补上缺失事件。重复的
+`lane_add` 只更新 description，不会让 fold 失败；没有前置 `lane_add` 的
+`lane_assign` 同样会推断该 lane。若 worktree 的 current-lane 指针指向 WAL 里已
+不存在的 lane，`status` / `log` / `lane` 会警告并回落到 `main`；`begin` 仍会拒绝，
+直到 `lane switch main` 或把该 lane 加回来。`log --last N` 在 open outcome 属于
+别的 lane 时，返回条数可以多于 N。
+
+派生的 SQLite outcome index 放在 Git metadata（或自定义 seal 旁边）。它只是可以
+随时删除重建的 read model；`events.jsonl` 仍是唯一 canonical history。增量同步跟随
+`indexedThrough` 和 `indexedLines`。未变化的 hot read 用 file identity 做常量时间
+校验；增量追赶前会校验此前全部 WAL prefix 的 checksum。source 被改写、schema
+不兼容、indexed row 损坏或 SQLite read 失败时，DriftSeal 会全量重建。
+
+`log --last N` 使用 `(lane, reclaimed, ordinal)` SQLite index，只读取命中的 outcome
+row，并补上其他 lane 的 open outcome。parked event 会依据 index 中保存的 committed
+event identity 做定向 overlay，不再因此重扫 committed WAL。无锁读取遇到缺失或 stale
+database 时，会在内存中 fold canonical WAL，绝不会返回 stale index。保存的 WAL byte
+range 留给后续 projection 使用，但 recent-log lookup 不依赖它。database 可以重建，
+不会随 log 一起提交。自定义 home 下的 sidecar 放在 `events.jsonl` 旁边；该目录在 Git
+worktree 内时，由目录里的 `.gitignore` 忽略。
+
 ## Decision 与 MADR
 
 只有当 outcome log 与 Git 无法还原重要上下文时才建立 MADR，例如值得以后重访的
@@ -139,8 +185,9 @@ driftseal decision update 1 --status accepted --note "Confirmed by the final imp
 | `driftseal extend "<addition>" [--accept "..."] [--verify "..."] [--decision id]` | 向同一 outcome 追加内容，并让旧 verification 失效。 |
 | `driftseal verify [--allow-tracked-command]` | 执行累计 verifier 并绑定证据。 |
 | `driftseal end [id] [-s status] [-n note] [-r verify-result]` | 诚实关闭 outcome。 |
-| `driftseal status` | 查看进行中的 outcome。 |
-| `driftseal log [--last N] [--all]` | 查看 outcome 历史。 |
+| `driftseal status` | 查看进行中的 outcome 和当前 lane。 |
+| `driftseal log [--last N] [--all] [--all-lanes]` | 查看 outcome 历史（默认当前 lane）。 |
+| `driftseal lane add\|switch\|assign\|show` | 按长期能力切分历史。 |
 | `driftseal reclaim [id ...] --reason "..." [--force]` | 通过 append-only marker 隐藏无意义的已关闭记录。 |
 | `driftseal unreclaim <id> --reason "..."` | 恢复 reclaimed record。 |
 | `driftseal absorb [other-events.jsonl] [--decisions dir] [--abandon-theirs\|--abandon-ours]` | 合并另一条 lineage 并处理撞号。 |
@@ -243,23 +290,30 @@ seal.begin({
 seal.extend({ extension: 'Document token expiry' });
 ```
 
-API 还提供 `status`、`verify`、`end`、`log`、`absorb`、reclaim、decision、init 与
-migration 方法。
+API 还提供 `status`、`verify`、`end`、`log`、`lane`、`laneAdd`、`laneSwitch`、
+`laneAssign`、`absorb`、reclaim、decision、init 与 migration 方法。
 
 stdio MCP server 会把所有操作固定在一个 repo root。v2 tools 包括
 `driftseal_status`、`driftseal_begin`、`driftseal_extend`、`driftseal_verify`、
-`driftseal_end`、outcome history/absorb、MADR，以及三个 migration tools。resources 为：
+`driftseal_end`、outcome history、lane、absorb、MADR，以及三个 migration tools。
+resources 为：
 
 - `driftseal://outcome/current`
 - `driftseal://outcomes/recent`
+- `driftseal://lanes`
 - `driftseal://madr`
 
 ## 存储与信任边界
 
 - `.seal/outcomes/events.jsonl` 是 append-only outcome log。通过 DriftSeal 访问它；
-  需要调整可见性或处理 merge 时使用 `reclaim`、`unreclaim`、`absorb`，不要手改。
+  需要调整可见性、切分 lane 或处理 merge 时使用 `reclaim`、`unreclaim`、`lane`、
+  `absorb`，不要手改。
 - `.seal/madr/` 保存编号化 MADR。
 - `$DRIFTSEAL_HOME` 替换整个 `.seal` root。
+- 当前 lane 与派生 SQLite outcome index 对默认 repo seal 存在 Git metadata 里，对自定义 seal
+  则放在旁边（`outcomes/.current-lane` 与 `outcomes/.outcome-index.sqlite`）。自定义
+  seal 在 Git worktree 内时，这些 sidecar 会被 gitignore。它们可以重建，不是
+  committed WAL 的一部分。
 - advisory hook 只提示 lifecycle 状态，不会扩大 repo 中 `AGENTS.md` 的政策边界。
 
 DriftSeal 不会替你判断 verification command 是否安全，也不会判断测试本身是否充分。

package/benchmark/recent-log.js

@@ -0,0 +1,181 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const { execFileSync } = require('node:child_process');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { performance } = require('node:perf_hooks');
+const { openOutcomeIndex } = require('../lib/outcome-index-sqlite.js');
+
+const DRIFTSEAL = path.join(__dirname, '..', 'bin', 'driftseal.js');
+const quick = process.argv.includes('--quick');
+const large = process.argv.includes('--large');
+const unrelatedOutcomes = large ? 100_000 : quick ? 2_000 : 10_000;
+const laneOutcomes = large ? 1_000 : quick ? 20 : 100;
+const samples = quick ? 5 : 20;
+const root = fs.mkdtempSync(path.join(os.tmpdir(), 'driftseal-recent-log-benchmark-'));
+const home = path.join(root, 'seal');
+const outcomeDirectory = path.join(home, 'outcomes');
+const wal = path.join(outcomeDirectory, 'events.jsonl');
+const indexFile = path.join(outcomeDirectory, '.outcome-index.sqlite');
+const env = {
+  ...process.env,
+  DRIFTSEAL_HOME: home,
+  DRIFTSEAL_DECISION_HOME: path.join(home, 'madr'),
+};
+
+function runCli(args, envOverrides = {}) {
+  return execFileSync(process.execPath, [DRIFTSEAL, ...args], {
+    cwd: root,
+    encoding: 'utf8',
+    env: { ...env, ...envOverrides },
+    stdio: ['ignore', 'pipe', 'pipe'],
+    maxBuffer: 64 * 1024 * 1024,
+  });
+}
+
+function event(type, fields) {
+  return {
+    logVersion: 2,
+    schemaVersion: type === 'lane_add' || fields.lane ? 2 : 1,
+    type,
+    ...fields,
+  };
+}
+
+function outcomeEvents(id, outcome, lane, minute) {
+  const beganAt = new Date(Date.UTC(2026, 0, 1, 0, minute, 0)).toISOString();
+  const endedAt = new Date(Date.UTC(2026, 0, 1, 0, minute, 1)).toISOString();
+  return [
+    event('begin', {
+      id,
+      ts: beganAt,
+      outcome,
+      acceptance: [],
+      verify: null,
+      decisions: [],
+      ...(lane === 'main' ? {} : { lane }),
+    }),
+    event('end', {
+      id,
+      ts: endedAt,
+      status: 'abandoned',
+      note: `closed ${outcome}`,
+      verifyResult: null,
+      head: null,
+    }),
+  ];
+}
+
+function writeSyntheticWal() {
+  fs.mkdirSync(outcomeDirectory, { recursive: true });
+  const lines = [];
+  let sequence = 1;
+  for (let i = 0; i < unrelatedOutcomes; i++) {
+    const id = `2026-01-01-${String(sequence++).padStart(6, '0')}`;
+    lines.push(...outcomeEvents(id, `unrelated work ${i}`, 'main', i % 1440));
+  }
+  lines.push(
+    event('lane_add', {
+      id: 'lane:focus',
+      lane: 'focus',
+      description: 'Benchmark focus lane',
+      ts: '2026-01-02T00:00:00.000Z',
+    })
+  );
+  for (let i = 0; i < laneOutcomes; i++) {
+    const id = `2026-01-02-${String(sequence++).padStart(6, '0')}`;
+    lines.push(...outcomeEvents(id, `focus work ${i}`, 'focus', i));
+  }
+  fs.writeFileSync(wal, `${lines.map(JSON.stringify).join('\n')}\n`);
+  fs.writeFileSync(path.join(outcomeDirectory, '.current-lane'), 'focus\n');
+}
+
+function distribution(values) {
+  const sorted = [...values].sort((left, right) => left - right);
+  return {
+    p50: Number(sorted[Math.floor(sorted.length * 0.5)].toFixed(2)),
+    p95: Number(sorted[Math.min(sorted.length - 1, Math.floor(sorted.length * 0.95))].toFixed(2)),
+  };
+}
+
+function measure(action, count = samples) {
+  const durations = [];
+  let value;
+  for (let i = 0; i < count; i++) {
+    const started = performance.now();
+    value = action();
+    durations.push(performance.now() - started);
+  }
+  return { ...distribution(durations), value };
+}
+
+try {
+  writeSyntheticWal();
+  const cold = measure(() => runCli(['log', '--last', '3']), 1);
+  const hot = measure(() => runCli(['log', '--last', '3']));
+  const fullFold = measure(
+    () =>
+      runCli(['log', '--last', '3'], {
+        _DRIFTSEAL_TEST_DISABLE_OUTCOME_INDEX: '1',
+      }),
+    quick ? 1 : 3
+  );
+  assert.equal(hot.value, fullFold.value);
+  assert.match(hot.value, new RegExp(`focus work ${laneOutcomes - 1}`));
+  assert.doesNotMatch(hot.value, /unrelated work/);
+
+  const index = openOutcomeIndex(indexFile, { readOnly: true });
+  const direct = measure(() => index.queryRecent('focus', 3));
+  const queryPlan = index.explainRecent().map((row) => row.detail);
+  index.close();
+  assert.equal(direct.value.length, 3);
+  assert.ok(
+    queryPlan.some((detail) => /outcomes_lane_visible_ordinal/.test(detail)),
+    `expected recent query index in plan: ${queryPlan.join('; ')}`
+  );
+
+  const nextId = `2026-01-03-${String(unrelatedOutcomes + laneOutcomes + 1).padStart(6, '0')}`;
+  fs.appendFileSync(
+    wal,
+    `${outcomeEvents(nextId, 'incremental focus work', 'focus', 0)
+      .map(JSON.stringify)
+      .join('\n')}\n`
+  );
+  const incremental = measure(() => runCli(['log', '--last', '3']), 1);
+  assert.match(incremental.value, /incremental focus work/);
+
+  const startup = measure(() =>
+    execFileSync(process.execPath, ['-e', ''], {
+      cwd: root,
+      stdio: 'ignore',
+    })
+  );
+  const stats = {
+    mode: large ? 'large' : quick ? 'quick' : 'default',
+    node: process.version,
+    platform: `${process.platform}-${process.arch}`,
+    outcomes: {
+      unrelated: unrelatedOutcomes,
+      currentLane: laneOutcomes,
+    },
+    samples,
+    bytes: {
+      wal: fs.statSync(wal).size,
+      sqlite: fs.statSync(indexFile).size,
+    },
+    milliseconds: {
+      processStartup: { p50: startup.p50, p95: startup.p95 },
+      coldBuildAndRecent: { p50: cold.p50, p95: cold.p95 },
+      hotRecentCli: { p50: hot.p50, p95: hot.p95 },
+      hotRecentQuery: { p50: direct.p50, p95: direct.p95 },
+      fullFoldRecent: { p50: fullFold.p50, p95: fullFold.p95 },
+      incrementalAndRecent: { p50: incremental.p50, p95: incremental.p95 },
+    },
+    queryPlan,
+  };
+  process.stdout.write(`${JSON.stringify(stats, null, 2)}\n`);
+} finally {
+  fs.rmSync(root, { recursive: true, force: true });
+}

package/bin/driftseal-mcp.js

@@ -94,6 +94,7 @@ function registerTools(server, api, z) {
   const outcomeRecord = z.object({
     id: z.string(),
     outcome: z.string(),
+    lane: z.string().optional(),
     extensions: z.array(extensionRecord),
     acceptance: z.array(z.string()),
     verify: z.string().nullable(),
@@ -281,10 +282,14 @@ function registerTools(server, api, z) {
     {
       title: 'List DriftSeal outcome history',
       description:
-        'Review recent or complete DriftSeal outcome history. Reclaimed records are hidden unless includeReclaimed is set.',
+        'Review recent or complete DriftSeal outcome history. Defaults to the current lane. Reclaimed records are hidden unless includeReclaimed is set.',
       inputSchema: {
         last: z.number().int().positive().max(100).optional(),
         includeReclaimed: z.boolean().default(false),
+        allLanes: z
+          .boolean()
+          .default(false)
+          .describe('Show outcomes from every lane instead of the current lane.'),
       },
       outputSchema: {
         root: z.string(),
@@ -295,7 +300,11 @@ function registerTools(server, api, z) {
     },
     async (input) =>
       guarded(() => {
-        const outcomes = api.log({ last: input.last, all: input.includeReclaimed });
+        const outcomes = api.log({
+          last: input.last,
+          all: input.includeReclaimed,
+          allLanes: input.allLanes,
+        });
         const readOnly = api.readOnly;
         const summary = `Found ${outcomes.length} DriftSeal outcome records.`;
         return success(
@@ -305,6 +314,103 @@ function registerTools(server, api, z) {
       })
   );
 
+  const laneRecord = z.object({
+    name: z.string(),
+    description: z.string().nullable(),
+    addedAt: z.string().nullable(),
+    inferred: z.boolean().optional(),
+    visible: z.number().int().nonnegative(),
+    count: z.number().int().nonnegative(),
+    current: z.boolean().optional(),
+  });
+
+  server.registerTool(
+    'driftseal_lane',
+    {
+      title: 'Show DriftSeal lanes',
+      description:
+        'List named outcome lanes and the current lane. Re-anchoring and log history follow the current lane.',
+      inputSchema: {},
+      outputSchema: {
+        root: z.string(),
+        current: z.string(),
+        missingCurrentLane: z.string().nullable().optional(),
+        lanes: z.array(laneRecord),
+        total: z.number().int().nonnegative(),
+        readOnly: z.boolean().optional(),
+      },
+      annotations: readOnly,
+    },
+    async () =>
+      guarded(() => {
+        const snapshot = api.lane();
+        const readOnly = api.readOnly;
+        return success(
+          { root: api.root, ...snapshot, ...(readOnly ? { readOnly: true } : {}) },
+          `Current DriftSeal lane is ${snapshot.current}.`
+        );
+      })
+  );
+
+  server.registerTool(
+    'driftseal_lane_add',
+    {
+      title: 'Add a DriftSeal lane',
+      description:
+        'Create a named lane for a long-lived capability. The default lane main always exists.',
+      inputSchema: {
+        name: nonEmpty.describe('Lane name: a lowercase letter, then letters, digits, or hyphens.'),
+        description: nonEmpty.optional(),
+      },
+      outputSchema: { root: z.string(), name: z.string(), description: z.string().nullable() },
+      annotations: localWrite,
+    },
+    async (input) =>
+      guarded(() => {
+        const lane = api.laneAdd({ name: input.name, description: input.description });
+        return success({ root: api.root, ...lane }, `Added DriftSeal lane ${lane.name}.`);
+      })
+  );
+
+  server.registerTool(
+    'driftseal_lane_switch',
+    {
+      title: 'Switch the current DriftSeal lane',
+      description:
+        'Move this worktree onto an existing lane. Refused while an outcome is open.',
+      inputSchema: { name: nonEmpty },
+      outputSchema: { root: z.string(), current: z.string() },
+      annotations: localWrite,
+    },
+    async (input) =>
+      guarded(() => {
+        const result = api.laneSwitch({ name: input.name });
+        return success({ root: api.root, ...result }, `Switched to DriftSeal lane ${result.current}.`);
+      })
+  );
+
+  server.registerTool(
+    'driftseal_lane_assign',
+    {
+      title: 'Assign a closed outcome to a lane',
+      description: 'Move a closed outcome onto an existing lane with an append-only assign event.',
+      inputSchema: {
+        id: nonEmpty.describe('Closed outcome id.'),
+        lane: nonEmpty,
+      },
+      outputSchema: { root: z.string(), outcome: outcomeRecord },
+      annotations: localWrite,
+    },
+    async (input) =>
+      guarded(() => {
+        const outcome = api.laneAssign({ id: input.id, lane: input.lane });
+        return success(
+          { root: api.root, outcome },
+          `Assigned outcome ${outcome.id} to lane ${outcome.lane}.`
+        );
+      })
+  );
+
   server.registerTool(
     'driftseal_absorb',
     {
@@ -568,9 +674,16 @@ function registerResources(server, api) {
     'recent-outcomes',
     'driftseal://outcomes/recent',
     'Recent DriftSeal outcomes',
-    'The ten most recent outcome records for the fixed repository.',
+    'The ten most recent outcome records on the current lane.',
     () => ({ root: api.root, outcomes: api.log({ last: 10 }) })
   );
+  registerJson(
+    'outcome-lanes',
+    'driftseal://lanes',
+    'DriftSeal outcome lanes',
+    'Named lanes that partition outcome history, including the current lane.',
+    () => ({ root: api.root, ...api.lane() })
+  );
   registerJson(
     'decision-catalog',
     'driftseal://madr',
@@ -592,7 +705,7 @@ async function createServer({ root }) {
     { name: SERVER_NAME, version: SERVER_VERSION },
     {
       instructions:
-        'Use driftseal_status before durable project changes or after context loss. Open one coherent outcome with driftseal_begin and append same-outcome steps with driftseal_extend. Reconcile linked decisions after the final extension, inspect the cumulative verifier, use driftseal_verify for fresh contract-bound evidence, and close honestly with driftseal_end.',
+        'Use driftseal_status before durable project changes or after context loss. Open one coherent outcome with driftseal_begin and append same-outcome steps with driftseal_extend. Reconcile linked decisions after the final extension, inspect the cumulative verifier, use driftseal_verify for fresh contract-bound evidence, and close honestly with driftseal_end. Named lanes isolate orthogonal capability history; driftseal_log follows the current lane.',
     }
   );
   registerTools(server, api, z);