driftseal 1.0.0 → 1.1.1

package/README.md

@@ -34,7 +34,9 @@ cd your-project
 driftseal init
 ```
 
-`driftseal init` safely adds the protocol to `AGENTS.md` and can be run again without duplicating it. DriftSeal requires Node.js 18+.
+`driftseal init` writes the protocol to `AGENTS.md`, including how to `absorb`
+colliding worktree logs, and configures the local git merge driver. It can be
+run again without duplicating either. DriftSeal requires Node.js 18+.
 
 For local development from this checkout:
 
@@ -177,7 +179,7 @@ Cursor have no supported hook surface for this yet.
 
 ## A work round
 
-Declare the round before changing files:
+Declare the round before making non-Git changes:
 
 ```sh
 driftseal begin "add rate limiting to /api/login" \
@@ -195,7 +197,12 @@ driftseal end \
 
 If the scope changes, close the current intent as `partial` or `abandoned`, then start a new one. After context loss, use `driftseal status` and `driftseal log --last 3` to re-anchor.
 
-Single-step commands that only build, check, or record work already done — compiling, running tests, `git add`/`git commit` — need no intent of their own. When a commit is authorized, staging and committing only the verified changes and the just-closed intent log finalizes that round. Any content change made while preparing the commit starts a new round.
+Git operations are entirely outside the intent log because Git maintains their
+history. Inspection, branch and worktree management, staging, commits, merges,
+rebases, cherry-picks, tags, and pushes never need an intent of their own. They
+still require normal authorization and safety checks. Single-step builds and
+checks, such as compiling or running tests, also need no intent. Any non-Git
+content change starts a new work round.
 
 ## Commands
 
@@ -207,6 +214,8 @@ Single-step commands that only build, check, or record work already done — com
 | `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 absorb [other-events.jsonl] [--decisions dir] [--abandon-theirs \| --abandon-ours] [--dry-run]` | Merge another worktree's logs, remapping colliding intent and decision ids. |
+| `driftseal absorb --git <base> <ours> <theirs>` | Git merge driver for `.intent-log/events.jsonl`. |
 | `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. |
@@ -215,7 +224,7 @@ Single-step commands that only build, check, or record work already done — com
 | `driftseal mcp install --target TARGET [--scope project\|global] [--root path] [--force]` | Install the repository-pinned MCP server into Codex, Kimi Code, OpenCode, Claude Code, or Cursor. |
 | `driftseal hook install --target TARGET [--scope project\|global] [--root path] [--force]` | Install advisory lifecycle reminders into Kimi Code, Claude Code, or Codex. |
 | `driftseal hook prompt\|stop [--format plain\|claude-code]` | Emit the reminder a lifecycle hook injects; never blocks. |
-| `driftseal init` | Add the adoption protocol to `AGENTS.md`. |
+| `driftseal init` | Add the adoption protocol to `AGENTS.md` and configure the git merge driver. |
 | `driftseal --version` or `driftseal -V` | Print the installed DriftSeal version. |
 | `driftseal help` | Print CLI usage. |
 
@@ -269,9 +278,34 @@ contents. Status-filtered listing and counting parse all records because status
 is stored in each MADR document; DriftSeal does not maintain a stale-prone sidecar
 index.
 
+## Merging worktrees
+
+Two worktrees allocate intent and decision ids from their local logs, so a
+same-day parallel `begin` or `decision add` can collide when the branches
+merge. `driftseal absorb` rebuilds a valid log by keeping our ids and remapping
+the incoming side, then prints the mapping. A single lineage stays append-only;
+absorb is the one cross-lineage rewrite.
+
+```sh
+driftseal absorb ../other-worktree/.intent-log/events.jsonl \
+  --decisions ../other-worktree/.decision-log
+```
+
+With no path, `absorb` repairs the current log after a git conflict or a
+concatenated duplicate. If both sides still have an open intent, pass
+`--abandon-theirs` or `--abandon-ours`. Concurrent edits of a decision that
+already existed in the shared base are not auto-merged.
+
+`driftseal init` writes that absorb rule into `AGENTS.md`, plus `.gitattributes`
+and the local git merge driver so `events.jsonl` merges through `absorb --git`.
+When decision ids collide, the driver stops the merge before Git can commit an
+ambiguous decision catalog. Run `driftseal absorb`, stage the repaired intent
+and decision logs, then continue the merge. Clones need `init` again because
+the driver lives in local git config.
+
 ## Storage
 
-- `.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.
+- `.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. After a merge collision, use `driftseal absorb` instead of editing the file.
 - `.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

@@ -34,7 +34,8 @@ cd your-project
 driftseal init
 ```
 
-`driftseal init` 会安全地把协议加入 `AGENTS.md`，重复运行也不会产生副本。DriftSeal 需要 Node.js 18+。
+`driftseal init` 会把协议写入 `AGENTS.md`（包括 worktree 撞号后如何 `absorb`），
+并配置 local git merge driver。重复运行不会产生副本。DriftSeal 需要 Node.js 18+。
 
 从当前 checkout 本地开发时：
 
@@ -171,7 +172,7 @@ Kimi Code 只在全局 `config.toml` 中记录 hook，因此该 target 必须指
 
 ## 一轮标准工作流
 
-修改文件前，先声明这轮工作的目标：
+进行非 Git 改动前，先声明这轮工作的目标：
 
 ```sh
 driftseal begin "add rate limiting to /api/login" \
@@ -189,7 +190,10 @@ driftseal end \
 
 如果范围发生变化，先把当前 intent 以 `partial` 或 `abandoned` 关闭，再开启新的 intent。发生 context loss 后，用 `driftseal status` 和 `driftseal log --last 3` 重新锚定当前目标。
 
-只负责构建、检查或记录已完成工作的单步命令（编译、跑测试、`git add`/`git commit`）不需要单独开启 intent。如果用户已经授权创建 Git commit，只把已验证的改动和刚关闭的 intent log 进行 stage 和 commit，就属于这一轮的持久化收尾。准备 commit 时一旦需要修改内容，就必须开启新一轮。
+Git 操作完全不计入 intent log，因为 Git 会自行维护历史。查看状态、管理 branch
+或 worktree、stage、commit、merge、rebase、cherry-pick、tag 和 push 都不需要
+单独开启 intent，但仍须遵守正常的授权与安全要求。编译、跑测试等单步构建或检查
+也不需要 intent；只要要做非 Git 内容改动，就开启新一轮。
 
 ## 命令速览
 
@@ -201,6 +205,8 @@ driftseal end \
 | `driftseal log [-n N] [--all]` | 查看 intent 历史（`--all` 包含已回收的记录）。 |
 | `driftseal reclaim [id ...] --reason "..." [--older-than days] [--force] [--dry-run]` | 用 append-only 标记隐藏已无意义的已关闭记录。 |
 | `driftseal unreclaim <id> --reason "..."` | 把已回收的记录恢复到可见历史中。 |
+| `driftseal absorb [other-events.jsonl] [--decisions dir] [--abandon-theirs \| --abandon-ours] [--dry-run]` | 合并另一条 worktree 的日志，并给撞号的 intent / decision id 重新编号。 |
+| `driftseal absorb --git <base> <ours> <theirs>` | `.intent-log/events.jsonl` 的 git merge driver。 |
 | `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 筛选。 |
@@ -209,7 +215,7 @@ driftseal end \
 | `driftseal mcp install --target TARGET [--scope project\|global] [--root path] [--force]` | 把固定到 repository 的 MCP server 安装到 Codex、Kimi Code、OpenCode、Claude Code 或 Cursor。 |
 | `driftseal hook install --target TARGET [--scope project\|global] [--root path] [--force]` | 把建议性的 lifecycle 提醒安装到 Kimi Code、Claude Code 或 Codex。 |
 | `driftseal hook prompt\|stop [--format plain\|claude-code]` | 输出 lifecycle hook 注入的提醒；绝不阻断。 |
-| `driftseal init` | 把接入协议写入 `AGENTS.md`。 |
+| `driftseal init` | 把接入协议写入 `AGENTS.md`，并配置 git merge driver。 |
 | `driftseal --version` 或 `driftseal -V` | 输出当前安装的 DriftSeal 版本。 |
 | `driftseal help` | 查看 CLI 用法。 |
 
@@ -255,9 +261,26 @@ recovery 只处理当前 intent，因此历史冲突不会阻塞之后的 decisi
 时仍需解析全部 records，因为 status 保存在各个 MADR 文档中；DriftSeal 不维护容易
 滞后的 sidecar index。
 
+## 合并 worktree
+
+两条 worktree 各自按本地日志分配 intent / decision id，同一天并行 `begin` 或 `decision add`，分支合并时就会撞号。`driftseal absorb` 保留我方编号、给进来的一侧重编号，并打印对照表。单线 WAL 仍然只追加；absorb 是唯一允许的跨谱系重写。
+
+```sh
+driftseal absorb ../other-worktree/.intent-log/events.jsonl \
+  --decisions ../other-worktree/.decision-log
+```
+
+不带 path 时，`absorb` 修复当前日志里的冲突标记或已经拼在一起的重复 id。两边都还有未关闭 intent 时，必须加上 `--abandon-theirs` 或 `--abandon-ours`。共享 base 里已经存在、又被两边同时改过的 decision，不会自动合并。
+
+`driftseal init` 会把这条 absorb 规则写入 `AGENTS.md`，同时写入 `.gitattributes`
+并配置 local git merge driver，让 `events.jsonl` 走 `absorb --git`。decision id
+撞号时，driver 会先中止 merge，避免 Git 提交语义不明确的 decision catalog；运行
+`driftseal absorb`、stage 修复后的 intent / decision logs，再继续 merge。clone
+之后需要再跑一次 `init`，因为 driver 只存在于 local git config。
+
 ## 数据保存在哪里
 
-- `.intent-log/events.jsonl`：append-only intent log。所有读写都必须经过 `driftseal`（CLI 或 MCP）——不要直接读取、修改、移动或删除该文件；需要让无意义的记录退场时使用 `driftseal reclaim`，而不是删除日志行。
+- `.intent-log/events.jsonl`：append-only intent log。所有读写都必须经过 `driftseal`（CLI 或 MCP）——不要直接读取、修改、移动或删除该文件；需要让无意义的记录退场时使用 `driftseal reclaim`，而不是删除日志行。合并撞号时用 `driftseal absorb`，不要手改这个文件。
 - `.decision-log/`：编号化的 MADR decision records。
 - 设置 `DRIFTSEAL_HOME` 或 `DRIFTSEAL_DECISION_HOME`，即可把对应 log 放到当前项目之外。
 

package/bin/driftseal.js

@@ -36,7 +36,7 @@ const DECISION_STATUSES = [
   'superseded',
 ];
 const EVENT_SCHEMA_VERSION = 3;
-const PROTOCOL_VERSION = 8;
+const PROTOCOL_VERSION = 10;
 const LOCK_STALE_MS = 30 * 60 * 1000;
 const LOCK_INIT_STALE_MS = 5 * 1000;
 const MAX_DECISION_SLUG_LENGTH = 180;
@@ -213,15 +213,19 @@ function readEvents({ repairTail = false, file = logFile() } = {}) {
       content = content.slice(0, validLength);
     }
   }
+  return parseJsonlRecords(content, file).map((record) => record.event);
+}
+
+function parseJsonlRecords(content, source = 'log') {
   return content
     .split('\n')
     .filter((line) => line.trim().length > 0)
     .map((line, i) => {
       try {
-        return normalizeEvent(JSON.parse(line), i + 1);
+        return { raw: line, event: normalizeEvent(JSON.parse(line), i + 1) };
       } catch (err) {
         if (err instanceof DriftSealError) throw err;
-        fail(`corrupt log line ${i + 1} in ${file}`);
+        fail(`corrupt log line ${i + 1} in ${source}`);
       }
     });
 }
@@ -714,16 +718,26 @@ function openIntent(records) {
   return open[0] || null;
 }
 
-function nextId(events) {
-  const today = new Date().toISOString().slice(0, 10); // YYYY-MM-DD
+function parseIntentId(id) {
+  const match = String(id).match(/^(\d{4}-\d{2}-\d{2})-(\d+)$/);
+  if (!match) fail(`invalid intent id: ${id}`);
+  return { date: match[1], seq: Number.parseInt(match[2], 10) };
+}
+
+function nextIdForDate(date, events) {
   let maxSeq = 0;
+  const prefix = `${date}-`;
   for (const ev of events) {
-    if (ev.type === 'begin' && typeof ev.id === 'string' && ev.id.startsWith(today + '-')) {
-      const seq = parseInt(ev.id.slice(today.length + 1), 10);
+    if (ev.type === 'begin' && typeof ev.id === 'string' && ev.id.startsWith(prefix)) {
+      const seq = Number.parseInt(ev.id.slice(prefix.length), 10);
       if (Number.isFinite(seq) && seq > maxSeq) maxSeq = seq;
     }
   }
-  return `${today}-${String(maxSeq + 1).padStart(3, '0')}`;
+  return `${date}-${String(maxSeq + 1).padStart(3, '0')}`;
+}
+
+function nextId(events) {
+  return nextIdForDate(new Date().toISOString().slice(0, 10), events);
 }
 
 function normalizeDecisionId(value) {
@@ -771,25 +785,31 @@ function compareDecisionEntries(a, b) {
   return a.id.length - b.id.length || a.id.localeCompare(b.id) || a.file.localeCompare(b.file);
 }
 
-function decisionIndex() {
-  if (!fs.existsSync(decisionDir())) return [];
+function listDecisionEntries(dir, { allowDuplicates = false } = {}) {
+  if (!dir || !fs.existsSync(dir)) return [];
   const entries = [];
   const ids = new Map();
-  for (const entry of fs.readdirSync(decisionDir(), { withFileTypes: true })) {
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
     const match = entry.name.match(/^(\d{4,})-.*\.md$/);
     if (!match) continue;
-    const fullPath = path.join(decisionDir(), entry.name);
+    const fullPath = path.join(dir, entry.name);
     const stat = fs.lstatSync(fullPath);
     if (stat.isSymbolicLink()) fail(`decision record must not be a symbolic link: ${entry.name}`);
     if (!stat.isFile()) fail(`decision record is not a regular file: ${entry.name}`);
     const id = normalizeDecisionId(match[1]);
-    if (ids.has(id)) fail(`duplicate decision id ${id}: ${ids.get(id)}, ${entry.name}`);
-    ids.set(id, entry.name);
+    if (ids.has(id) && !allowDuplicates) {
+      fail(`duplicate decision id ${id}: ${ids.get(id)}, ${entry.name}`);
+    }
+    if (!ids.has(id)) ids.set(id, entry.name);
     entries.push({ id, file: entry.name, path: fullPath });
   }
   return entries.sort(compareDecisionEntries);
 }
 
+function decisionIndex() {
+  return listDecisionEntries(decisionDir());
+}
+
 function readDecision(entry) {
   const noFollow = fs.constants.O_NOFOLLOW || 0;
   let fd;
@@ -1116,11 +1136,14 @@ default; the companion skill only helps discover and resume the workflow, while
 MCP and lifecycle hooks are optional adapters.
 
 1. **Write intent first**, before modifying, creating, or deleting files, or
-   making any other change that may need a rollback:
+   making any other non-Git change that may need a rollback:
    \`driftseal begin "<what this round will accomplish>" --verify "<command or check that proves it>"\`.
    Add one \`--decision <id>\` for each existing decision this round may change.
-   Single-step commands that only build, check, or record work already done
-   (compiling, running tests, \`git add\`/\`git commit\`) need no intent.
+   Git operations never need an intent and are not included in the intent log;
+   Git maintains their history. This includes inspection, branch and worktree
+   management, staging, commits, merges, rebases, cherry-picks, tags, and pushes.
+   Single-step commands that only build or check work already done, such as
+   compiling or running tests, also need no intent.
 2. **Execute only the intent.** Scope change? Close the current intent
    (\`driftseal end -s partial|abandoned -n "<why>"\`) and \`driftseal begin\` a new one.
 3. **Verify, then close**: run the declared verification, then
@@ -1133,9 +1156,9 @@ MCP and lifecycle hooks are optional adapters.
    the final content hash is recorded. Interrupted reconciliation is recovered
    by the next linked \`decision update\` or successful \`end\`. Closing as
    \`failed\` or \`abandoned\` cancels pending recovery for that intent.
-   An authorized Git commit that only stages and records the verified changes and
-   just-closed log finalizes that round without requiring a new intent. Any content
-   change made while preparing the commit does require a new intent.
+   Git operations remain subject to normal authorization and safety requirements
+   even though they do not require an intent. Any non-Git content change made while
+   preparing a Git operation does require a new intent.
 4. **Re-anchor after context loss**: run \`driftseal status\` and \`driftseal log --last 3\` before
    doing anything else. The open intent is the source of truth: resume it when its
    objective still matches the current task; otherwise close it (\`partial\` or
@@ -1146,13 +1169,50 @@ MCP and lifecycle hooks are optional adapters.
 \`driftseal\` commands or the MCP tools. Retire meaningless closed records with
 \`driftseal reclaim [id ...] --reason "<why>"\` — it appends a marker, never
 deletes log lines; \`driftseal unreclaim <id> --reason "<why>"\` restores one.
+After a merge collision, run \`driftseal absorb\` rather than editing the log;
+if both sides still have an open intent, add \`--abandon-theirs\` or
+\`--abandon-ours\`.
 
 Log: \`.intent-log/events.jsonl\` (override with \`$DRIFTSEAL_HOME\`); commit it with the code.
 ${INTENT_PROTOCOL_END}`;
 }
 
 function previousIntentProtocolBlock(version) {
-  const v7 = intentProtocolBlock(version).replace(
+  const v9 = intentProtocolBlock(version)
+    .replace(
+      '1. **Write intent first**, before modifying, creating, or deleting files, or\n' +
+        '   making any other non-Git change that may need a rollback:\n' +
+        '   `driftseal begin "<what this round will accomplish>" --verify "<command or check that proves it>"`.\n' +
+        '   Add one `--decision <id>` for each existing decision this round may change.\n' +
+        '   Git operations never need an intent and are not included in the intent log;\n' +
+        '   Git maintains their history. This includes inspection, branch and worktree\n' +
+        '   management, staging, commits, merges, rebases, cherry-picks, tags, and pushes.\n' +
+        '   Single-step commands that only build or check work already done, such as\n' +
+        '   compiling or running tests, also need no intent.',
+      '1. **Write intent first**, before modifying, creating, or deleting files, or\n' +
+        '   making any other change that may need a rollback:\n' +
+        '   `driftseal begin "<what this round will accomplish>" --verify "<command or check that proves it>"`.\n' +
+        '   Add one `--decision <id>` for each existing decision this round may change.\n' +
+        '   Single-step commands that only build, check, or record work already done\n' +
+        '   (compiling, running tests, `git add`/`git commit`) need no intent.'
+    )
+    .replace(
+      '   Git operations remain subject to normal authorization and safety requirements\n' +
+        '   even though they do not require an intent. Any non-Git content change made while\n' +
+        '   preparing a Git operation does require a new intent.',
+      '   An authorized Git commit that only stages and records the verified changes and\n' +
+        '   just-closed log finalizes that round without requiring a new intent. Any content\n' +
+        '   change made while preparing the commit does require a new intent.'
+    );
+  if (version >= 9) return v9;
+  const v8 = v9.replace(
+    '\nAfter a merge collision, run `driftseal absorb` rather than editing the log;\n' +
+      'if both sides still have an open intent, add `--abandon-theirs` or\n' +
+      '`--abandon-ours`.',
+    ''
+  );
+  if (version >= 8) return v8;
+  const v7 = v8.replace(
     '\nThis `AGENTS.md` protocol is the source of truth. Use the `driftseal` CLI by\n' +
       'default; the companion skill only helps discover and resume the workflow, while\n' +
       'MCP and lifecycle hooks are optional adapters.\n',
@@ -1220,6 +1280,8 @@ Count postponed choices with \`driftseal decision list --status deferred --count
 then review them with \`driftseal decision list --status deferred\`.
 When an intent declares an existing decision with \`--decision <id>\`, use
 \`driftseal decision update\` to record its status transition or explicit confirmation.
+After a merge, colliding decision ids are remapped with \`driftseal absorb\`;
+concurrent edits of a shared decision are not auto-merged.
 Commit \`.decision-log/\` with the code.
 ${DECISION_PROTOCOL_END}`;
 }
@@ -1276,8 +1338,15 @@ Commit \`.decision-log/\` with the code.`;
 }
 
 function previousDecisionProtocolBlock(version) {
-  if (version >= 7) return decisionProtocolBlock(version);
-  return decisionProtocolBlock(version).replace(' --driver "<decision driver>"', '');
+  const v9 = decisionProtocolBlock(version);
+  if (version >= 9) return v9;
+  const v8 = v9.replace(
+    '\nAfter a merge, colliding decision ids are remapped with `driftseal absorb`;\n' +
+      'concurrent edits of a shared decision are not auto-merged.',
+    ''
+  );
+  if (version >= 7) return v8;
+  return v8.replace(' --driver "<decision driver>"', '');
 }
 
 function upgradeManagedBlock({
@@ -2005,6 +2074,776 @@ function runHookReminder(event, argv) {
   return { changed: true, event, format };
 }
 
+function gitCaptureRaw(args, cwd = process.cwd()) {
+  try {
+    return execFileSync('git', args, {
+      cwd,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+  } catch {
+    return null;
+  }
+}
+
+function gitCapture(args, cwd = process.cwd()) {
+  const output = gitCaptureRaw(args, cwd);
+  return output === null ? null : output.trim();
+}
+
+function isGitWorkTree(cwd = process.cwd()) {
+  return gitCapture(['rev-parse', '--is-inside-work-tree'], cwd) === 'true';
+}
+
+function gitOtherHead(cwd = process.cwd()) {
+  return (
+    gitCapture(['rev-parse', '--verify', 'MERGE_HEAD'], cwd) ||
+    gitCapture(['rev-parse', '--verify', 'REBASE_HEAD'], cwd) ||
+    gitCapture(['rev-parse', '--verify', 'CHERRY_PICK_HEAD'], cwd)
+  );
+}
+
+function gitMergeBase(cwd = process.cwd()) {
+  const other = gitOtherHead(cwd);
+  if (!other) return null;
+  return gitCapture(['merge-base', 'HEAD', other], cwd);
+}
+
+function gitMergeBaseFor(left, right, cwd = process.cwd()) {
+  return gitCapture(['merge-base', left, right], cwd);
+}
+
+function gitReadFile(treeish, file, cwd = process.cwd()) {
+  return gitCaptureRaw(['show', `${treeish}:${file}`], cwd);
+}
+
+function gitFindCommitForFile(file, repositoryPath, cwd = process.cwd()) {
+  const blob = gitCapture(['hash-object', file], cwd);
+  const history = gitCapture(['rev-list', '--all', '--reflog', '--', repositoryPath], cwd);
+  if (!blob || !history) return null;
+  for (const commit of history.split('\n')) {
+    if (gitCapture(['rev-parse', `${commit}:${repositoryPath}`], cwd) === blob) return commit;
+  }
+  return null;
+}
+
+function gitMergeParents(cwd = process.cwd()) {
+  const line = gitCapture(['rev-list', '--parents', '-n', '1', 'HEAD'], cwd);
+  if (!line) return null;
+  const parts = line.split(/\s+/);
+  if (parts.length !== 3) return null;
+  return { ours: parts[1], theirs: parts[2] };
+}
+
+function gitDecisionIds(treeish, cwd = process.cwd()) {
+  const out = gitCapture(['ls-tree', '-r', '--name-only', treeish, '.decision-log'], cwd);
+  if (!out) return new Set();
+  const ids = new Set();
+  for (const file of out.split('\n')) {
+    const match = path.basename(file).match(/^(\d{4,})-.*\.md$/);
+    if (match) ids.add(normalizeDecisionId(match[1]));
+  }
+  return ids;
+}
+
+function gitDecisionEntries(treeish, cwd = process.cwd()) {
+  const out = gitCapture(['ls-tree', '-r', '--name-only', treeish, '.decision-log'], cwd);
+  if (!out) return [];
+  const entries = [];
+  for (const file of out.split('\n')) {
+    const name = path.basename(file);
+    const match = name.match(/^(\d{4,})-.*\.md$/);
+    if (!match) continue;
+    const content = gitReadFile(treeish, file, cwd);
+    if (content === null) continue;
+    entries.push({
+      id: normalizeDecisionId(match[1]),
+      file: name,
+      path: file,
+      content,
+    });
+  }
+  return entries;
+}
+
+function gitIntentRecords(treeish, cwd = process.cwd()) {
+  const content = gitReadFile(treeish, '.intent-log/events.jsonl', cwd);
+  return content === null ? [] : parseJsonlRecords(content, `${treeish}:.intent-log/events.jsonl`);
+}
+
+function canonicalEvent(event) {
+  return Object.fromEntries(
+    Object.entries(event)
+      .filter(([, value]) => value !== undefined)
+      .sort(([left], [right]) => left.localeCompare(right))
+  );
+}
+
+function eventsEqual(left, right) {
+  return JSON.stringify(canonicalEvent(left)) === JSON.stringify(canonicalEvent(right));
+}
+
+function commonPrefixLength(ours, theirs) {
+  let index = 0;
+  while (
+    index < ours.length &&
+    index < theirs.length &&
+    eventsEqual(ours[index].event, theirs[index].event)
+  ) {
+    index += 1;
+  }
+  return index;
+}
+
+function recordsHavePrefix(records, prefix) {
+  if (prefix.length > records.length) return false;
+  return prefix.every((record, index) => eventsEqual(record.event, records[index].event));
+}
+
+function parseConflictContent(content) {
+  if (!/^<<<<<<< /m.test(content)) return null;
+  const eol = content.includes('\r\n') ? '\r\n' : '\n';
+  const ours = [];
+  const theirs = [];
+  let mode = 'base';
+  for (const line of content.split(/\r?\n/)) {
+    if (line.startsWith('<<<<<<< ')) {
+      mode = 'ours';
+      continue;
+    }
+    if (line.startsWith('||||||| ')) {
+      mode = 'ancestor';
+      continue;
+    }
+    if (line.startsWith('=======')) {
+      mode = 'theirs';
+      continue;
+    }
+    if (line.startsWith('>>>>>>> ')) {
+      mode = 'base';
+      continue;
+    }
+    if (mode === 'base') {
+      ours.push(line);
+      theirs.push(line);
+    } else if (mode === 'ours') {
+      ours.push(line);
+    } else if (mode === 'theirs') {
+      theirs.push(line);
+    }
+  }
+  return { oursText: ours.join(eol), theirsText: theirs.join(eol) };
+}
+
+function collectDecisionIdsFromEvents(events) {
+  const ids = new Set();
+  for (const event of events) {
+    if (Array.isArray(event.decisions)) {
+      for (const id of event.decisions) ids.add(normalizeDecisionId(id));
+    }
+    if (event.decisionId) ids.add(normalizeDecisionId(event.decisionId));
+  }
+  return ids;
+}
+
+function nextDecisionIdFromIds(ids) {
+  if (ids.size === 0) return '0001';
+  let max = 0n;
+  for (const id of ids) {
+    const value = BigInt(id);
+    if (value > max) max = value;
+  }
+  return String(max + 1n).padStart(4, '0');
+}
+
+function decisionSlugFromFile(file) {
+  return file.replace(/^\d+-/, '').replace(/\.md$/, '');
+}
+
+function rewriteDecisionId(content, newId) {
+  return content.replace(/^# [0-9]+\. /, `# ${String(BigInt(newId))}. `);
+}
+
+function splitDuplicateDecisions(entries) {
+  const ours = [];
+  const theirs = [];
+  const seen = new Set();
+  for (const entry of entries) {
+    if (seen.has(entry.id)) theirs.push(entry);
+    else {
+      seen.add(entry.id);
+      ours.push(entry);
+    }
+  }
+  return { ours, theirs };
+}
+
+function hasDuplicateDecisionIds(entries) {
+  const seen = new Set();
+  for (const entry of entries) {
+    if (seen.has(entry.id)) return true;
+    seen.add(entry.id);
+  }
+  return false;
+}
+
+function hasDuplicateIntentBegins(records) {
+  const seen = new Set();
+  for (const record of records) {
+    if (record.event.type !== 'begin') continue;
+    if (seen.has(record.event.id)) return true;
+    seen.add(record.event.id);
+  }
+  return false;
+}
+
+function planDecisionAbsorb({ oursEntries, theirsEntries, baseEntries = [], baseIds = new Set() }) {
+  const mappings = [];
+  const copies = [];
+  const decisionMap = new Map();
+  const usedIds = new Set(oursEntries.map((entry) => entry.id));
+  const oursById = new Map();
+  const baseById = new Map();
+  for (const entry of oursEntries) {
+    if (!oursById.has(entry.id)) oursById.set(entry.id, entry);
+  }
+  for (const entry of baseEntries) {
+    if (!baseById.has(entry.id)) baseById.set(entry.id, entry);
+  }
+
+  for (const entry of theirsEntries) {
+    const ours = oursById.get(entry.id);
+    const theirsContent = entry.content !== undefined ? entry.content : fs.readFileSync(entry.path, 'utf8');
+    if (!ours) {
+      copies.push({
+        fromFile: entry.file,
+        toFile: entry.file,
+        content: theirsContent,
+        removeFile: null,
+      });
+      usedIds.add(entry.id);
+      continue;
+    }
+    const oursContent = ours.content !== undefined ? ours.content : fs.readFileSync(ours.path, 'utf8');
+    const oursHash = contentHash(oursContent);
+    const theirsHash = contentHash(theirsContent);
+    if (oursHash === theirsHash) {
+      if (ours.file !== entry.file) {
+        copies.push({
+          fromFile: entry.file,
+          toFile: ours.file,
+          content: oursContent,
+          removeFile: entry.file,
+        });
+      }
+      continue;
+    }
+
+    const base = baseById.get(entry.id);
+    if (base) {
+      const baseContent = base.content !== undefined ? base.content : fs.readFileSync(base.path, 'utf8');
+      const baseHash = contentHash(baseContent);
+      if (oursHash === baseHash) {
+        copies.push({
+          fromFile: entry.file,
+          toFile: ours.file,
+          content: theirsContent,
+          removeFile: entry.file !== ours.file ? entry.file : null,
+        });
+        continue;
+      }
+      if (theirsHash === baseHash) {
+        if (entry.file !== ours.file) {
+          copies.push({
+            fromFile: entry.file,
+            toFile: ours.file,
+            content: oursContent,
+            removeFile: entry.file,
+          });
+        }
+        continue;
+      }
+      fail(
+        `decision ${entry.id} was edited on both sides; resolve ${ours.file} manually before absorbing`
+      );
+    }
+    if (baseIds.has(entry.id)) {
+      fail(
+        `decision ${entry.id} was edited on both sides or its base content is unavailable; ` +
+          `resolve ${ours.file} manually before absorbing`
+      );
+    }
+    const newId = nextDecisionIdFromIds(usedIds);
+    usedIds.add(newId);
+    decisionMap.set(entry.id, newId);
+    mappings.push({ kind: 'decision', from: entry.id, to: newId });
+    copies.push({
+      fromFile: entry.file,
+      toFile: `${newId}-${decisionSlugFromFile(entry.file)}.md`,
+      content: rewriteDecisionId(theirsContent, newId),
+      removeFile: entry.file !== ours.file ? entry.file : null,
+    });
+  }
+  return { decisionMap, mappings, copies };
+}
+
+function remapEvent(event, intentMap, decisionMap) {
+  const next = { ...event };
+  if (intentMap.has(event.id)) next.id = intentMap.get(event.id);
+  if (Array.isArray(next.decisions) && next.decisions.length > 0) {
+    next.decisions = next.decisions.map((id) => {
+      const normalized = normalizeDecisionId(id);
+      return decisionMap.get(normalized) || id;
+    });
+  }
+  if (next.decisionId) {
+    const normalized = normalizeDecisionId(next.decisionId);
+    if (decisionMap.has(normalized)) next.decisionId = decisionMap.get(normalized);
+  }
+  return next;
+}
+
+function remapTheirsRecords(theirsNew, oursUsedEvents, decisionMap) {
+  const intentMap = new Map();
+  const mappings = [];
+  const used = [...oursUsedEvents];
+  const records = theirsNew.map((record) => {
+    let event = record.event;
+    if (event.type === 'begin' && used.some((item) => item.type === 'begin' && item.id === event.id)) {
+      const { date } = parseIntentId(event.id);
+      const newId = nextIdForDate(date, used);
+      intentMap.set(event.id, newId);
+      mappings.push({ kind: 'intent', from: event.id, to: newId });
+    }
+    event = remapEvent(event, intentMap, decisionMap);
+    used.push(event);
+    return { event };
+  });
+  return { records, mappings };
+}
+
+function repairDuplicateIntentRecords(records, decisionMap) {
+  const seenBegins = new Set();
+  const intentMap = new Map();
+  const used = [];
+  const mappings = [];
+  const result = [];
+  let incomingSide = false;
+  for (const record of records) {
+    let event = record.event;
+    if (event.type === 'begin' && seenBegins.has(event.id)) {
+      incomingSide = true;
+      const { date } = parseIntentId(event.id);
+      const newId = nextIdForDate(date, used);
+      intentMap.set(event.id, newId);
+      mappings.push({ kind: 'intent', from: event.id, to: newId });
+    } else if (event.type === 'begin') {
+      seenBegins.add(event.id);
+    }
+    const remapped = remapEvent(event, intentMap, incomingSide ? decisionMap : new Map());
+    const changed = remapped !== event && JSON.stringify(remapped) !== JSON.stringify(event);
+    result.push(changed ? { event: remapped } : record);
+    used.push(result.at(-1).event);
+  }
+  return { records: result, mappings, incomingSide };
+}
+
+function serializeRecords(records) {
+  if (records.length === 0) return '';
+  return `${records.map((record) => record.raw || JSON.stringify(record.event)).join('\n')}\n`;
+}
+
+function writeJsonl(file, records) {
+  ensureDirectoryDurable(path.dirname(file));
+  atomicWriteFile(file, serializeRecords(records));
+}
+
+function applyDecisionCopies(copies, dryRun) {
+  if (dryRun || copies.length === 0) return;
+  ensureDirectoryDurable(decisionDir());
+  for (const item of copies) {
+    atomicWriteFile(path.join(decisionDir(), item.toFile), item.content);
+    if (item.removeFile && item.removeFile !== item.toFile) {
+      const stale = path.join(decisionDir(), item.removeFile);
+      if (fs.existsSync(stale)) {
+        fs.unlinkSync(stale);
+        fsyncDirectory(decisionDir());
+      }
+    }
+  }
+}
+
+function countAbsorbedIntents(records) {
+  return records.filter((record) => record.event.type === 'begin').length;
+}
+
+function printAbsorbReport({ mappings, abandoned, intentCount }) {
+  const remappedIntents = mappings.filter((mapping) => mapping.kind === 'intent').length;
+  const remappedDecisions = mappings.filter((mapping) => mapping.kind === 'decision').length;
+  printLine(
+    `absorbed ${intentCount} intent(s), remapped ${remappedIntents} intent id(s), ${remappedDecisions} decision id(s)`
+  );
+  for (const mapping of mappings) {
+    if (mapping.kind === 'intent') printLine(`${mapping.from} (theirs) -> ${mapping.to}`);
+    else printLine(`decision ${mapping.from} (theirs) -> ${mapping.to}`);
+  }
+  if (abandoned) printLine(`abandoned ${abandoned} during absorb`);
+}
+
+function abandonOpenIntent(records, targetId, side) {
+  records.push({
+    event: {
+      schemaVersion: EVENT_SCHEMA_VERSION,
+      type: 'end',
+      id: targetId,
+      ts: new Date().toISOString(),
+      status: 'abandoned',
+      note: `abandoned during absorb (--abandon-${side})`,
+      verifyResult: null,
+    },
+  });
+  return targetId;
+}
+
+function resolveOpenIntents(result, oursRecords, theirsRecords, abandon, { allowConflict = false } = {}) {
+  const oursOpen = openIntent(fold(oursRecords.map((record) => record.event)));
+  const theirsOpen = openIntent(fold(theirsRecords.map((record) => record.event)));
+  try {
+    openIntent(fold(result.map((record) => record.event)));
+    return { abandoned: null, conflict: false };
+  } catch (err) {
+    if (!(err instanceof DriftSealError) || !/multiple intents in progress/.test(err.message)) {
+      throw err;
+    }
+    if (abandon === 'theirs' && theirsOpen) {
+      return { abandoned: abandonOpenIntent(result, theirsOpen.id, 'theirs'), conflict: false };
+    }
+    if (abandon === 'ours' && oursOpen) {
+      return { abandoned: abandonOpenIntent(result, oursOpen.id, 'ours'), conflict: false };
+    }
+    if (allowConflict) return { abandoned: null, conflict: true };
+    fail(`${err.message}; re-run with --abandon-theirs or --abandon-ours`);
+  }
+}
+
+function mergeRecordStreams(ours, theirs, baseRecords) {
+  const inferred = ours.slice(0, commonPrefixLength(ours, theirs));
+  const prefix = baseRecords && baseRecords.length > 0 ? baseRecords : inferred;
+  if (!recordsHavePrefix(ours, prefix) || !recordsHavePrefix(theirs, prefix)) {
+    fail('cannot absorb: shared history does not match the base log');
+  }
+  return {
+    base: prefix,
+    oursNew: ours.slice(prefix.length),
+    theirsNew: theirs.slice(prefix.length),
+  };
+}
+
+function GITATTRIBUTES_MERGE_LINE() {
+  return '.intent-log/events.jsonl merge=driftseal';
+}
+
+function ensureGitAttributes() {
+  const target = path.join(process.cwd(), '.gitattributes');
+  const line = GITATTRIBUTES_MERGE_LINE();
+  const existed = fs.existsSync(target);
+  const current = existed ? fs.readFileSync(target, 'utf8') : '';
+  const eol = current.includes('\r\n') ? '\r\n' : '\n';
+  const lines = current.split(/\r?\n/);
+  if (lines.some((entry) => entry.trim() === line)) return { changed: false, target };
+  const prefix = current.length === 0 || current.endsWith('\n') || current.endsWith('\r\n') ? '' : eol;
+  const next = `${current}${prefix}${line}${eol}`;
+  atomicWriteFile(target, next);
+  return { changed: true, target };
+}
+
+function ensureGitMergeDriver() {
+  if (!isGitWorkTree()) return { changed: false, configured: false };
+  const name = gitCapture(['config', '--local', '--get', 'merge.driftseal.name']);
+  const driver = gitCapture(['config', '--local', '--get', 'merge.driftseal.driver']);
+  const expectedName = 'DriftSeal intent log merge';
+  const expectedDriver = 'driftseal absorb --git %O %A %B';
+  if (name === expectedName && driver === expectedDriver) {
+    return { changed: false, configured: true };
+  }
+  execFileSync('git', ['config', '--local', 'merge.driftseal.name', expectedName], {
+    stdio: ['ignore', 'ignore', 'pipe'],
+  });
+  execFileSync('git', ['config', '--local', 'merge.driftseal.driver', expectedDriver], {
+    stdio: ['ignore', 'ignore', 'pipe'],
+  });
+  return { changed: true, configured: true };
+}
+
+function absorbUsage() {
+  return (
+    'usage: driftseal absorb [other-events.jsonl] [--decisions <dir>] [--abandon-theirs | --abandon-ours] [--dry-run]\n' +
+    '   or: driftseal absorb --git <base> <ours> <theirs>'
+  );
+}
+
+function loadAbsorbSide(file, label, { repairTail = false, allowMissing = false } = {}) {
+  if (!fs.existsSync(file)) {
+    if (allowMissing) return { records: [], conflict: false };
+    fail(`intent log not found: ${file}`);
+  }
+  let content = fs.readFileSync(file, 'utf8');
+  if (repairTail && !/^<<<<<<< /m.test(content)) {
+    readEvents({ file, repairTail: true });
+    content = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : '';
+  }
+  const conflict = parseConflictContent(content);
+  if (conflict) {
+    return {
+      ours: parseJsonlRecords(conflict.oursText, `${label} ours`),
+      theirs: parseJsonlRecords(conflict.theirsText, `${label} theirs`),
+      conflict: true,
+    };
+  }
+  return { records: parseJsonlRecords(content, label), conflict: false };
+}
+
+function finishAbsorb({
+  result,
+  oursRecords,
+  theirsRecords,
+  mappings,
+  copies,
+  abandon,
+  dryRun,
+  outputFile,
+  intentCount,
+  allowConflict = false,
+  followupMessage = null,
+}) {
+  const { abandoned, conflict } = resolveOpenIntents(result, oursRecords, theirsRecords, abandon, {
+    allowConflict,
+  });
+  fold(result.map((record) => record.event));
+  if (!conflict) openIntent(fold(result.map((record) => record.event)));
+  if (!dryRun) {
+    writeJsonl(outputFile, result);
+    applyDecisionCopies(copies, dryRun);
+  }
+  if (intentCount === 0 && mappings.length === 0 && copies.length === 0 && !abandoned) {
+    printLine('nothing to absorb');
+  } else {
+    printAbsorbReport({
+      mappings,
+      abandoned,
+      intentCount,
+    });
+  }
+  if (conflict) {
+    printLine('multiple intents remain in progress; re-run with --abandon-theirs or --abandon-ours');
+  }
+  if (followupMessage) printLine(followupMessage);
+  return {
+    mappings,
+    abandoned,
+    copies: copies.map((item) => item.toFile),
+    outputFile,
+    exitCode: conflict || followupMessage ? 1 : 0,
+  };
+}
+
+function absorbFromStreams(ours, theirs, baseRecords, options) {
+  const streams = mergeRecordStreams(ours, theirs, baseRecords);
+  const decisionPlan = planDecisionAbsorb({
+    oursEntries: options.oursDecisionEntries || [],
+    theirsEntries: options.theirsDecisionEntries || [],
+    baseEntries: options.baseDecisionEntries || [],
+    baseIds: options.baseDecisionIds || new Set(),
+  });
+  const remapped = remapTheirsRecords(
+    streams.theirsNew,
+    [...streams.base, ...streams.oursNew].map((record) => record.event),
+    decisionPlan.decisionMap
+  );
+  const result = [...streams.base, ...streams.oursNew, ...remapped.records];
+  return finishAbsorb({
+    result,
+    oursRecords: [...streams.base, ...streams.oursNew],
+    theirsRecords: [...streams.base, ...remapped.records],
+    mappings: [...remapped.mappings, ...decisionPlan.mappings],
+    copies: decisionPlan.copies,
+    abandon: options.abandon,
+    dryRun: options.dryRun,
+    outputFile: options.outputFile,
+    allowConflict: options.allowConflict,
+    followupMessage: options.followupMessage,
+    intentCount: streams.theirsNew.filter((record) => record.event.type === 'begin').length,
+  });
+}
+
+function gitAbsorbRepairContext(records, decisionEntries) {
+  const pending = gitOtherHead();
+  if (pending) {
+    return {
+      ours: 'HEAD',
+      theirs: pending,
+      base: gitMergeBaseFor('HEAD', pending),
+    };
+  }
+  if (!hasDuplicateDecisionIds(decisionEntries) && !hasDuplicateIntentBegins(records)) return null;
+  const parents = gitMergeParents();
+  if (!parents) return null;
+  return {
+    ...parents,
+    base: gitMergeBaseFor(parents.ours, parents.theirs),
+  };
+}
+
+function absorbFromGitContext(context, { abandon, dryRun, outputFile }) {
+  const baseRecords = context.base ? gitIntentRecords(context.base) : [];
+  return absorbFromStreams(
+    gitIntentRecords(context.ours),
+    gitIntentRecords(context.theirs),
+    baseRecords,
+    {
+      abandon,
+      dryRun,
+      outputFile,
+      oursDecisionEntries: gitDecisionEntries(context.ours),
+      theirsDecisionEntries: gitDecisionEntries(context.theirs),
+      baseDecisionEntries: context.base ? gitDecisionEntries(context.base) : [],
+      baseDecisionIds: context.base
+        ? gitDecisionIds(context.base)
+        : collectDecisionIdsFromEvents(baseRecords.map((record) => record.event)),
+    }
+  );
+}
+
+function absorbLogs(otherFile, otherDecisions, { abandon, dryRun }) {
+  const oursFile = logFile();
+  const loaded = loadAbsorbSide(oursFile, oursFile, { repairTail: true, allowMissing: !otherFile });
+  const currentDecisionEntries = !otherFile
+    ? listDecisionEntries(decisionDir(), { allowDuplicates: true })
+    : [];
+  const gitContext = !otherFile
+    ? gitAbsorbRepairContext(loaded.records || [], currentDecisionEntries)
+    : null;
+  if (gitContext) {
+    return absorbFromGitContext(gitContext, { abandon, dryRun, outputFile: oursFile });
+  }
+  if (loaded.conflict) {
+    const baseIds = collectDecisionIdsFromEvents(
+      loaded.ours.slice(0, commonPrefixLength(loaded.ours, loaded.theirs)).map((record) => record.event)
+    );
+    const gitBase = gitMergeBase();
+    const baseDecisionIds = gitBase ? gitDecisionIds(gitBase) : baseIds;
+    return absorbFromStreams(loaded.ours, loaded.theirs, null, {
+      abandon,
+      dryRun,
+      outputFile: oursFile,
+      oursDecisionEntries: listDecisionEntries(decisionDir(), { allowDuplicates: true }),
+      theirsDecisionEntries: otherDecisions
+        ? listDecisionEntries(otherDecisions)
+        : splitDuplicateDecisions(listDecisionEntries(decisionDir(), { allowDuplicates: true })).theirs,
+      baseDecisionIds,
+      baseDecisionEntries: gitBase ? gitDecisionEntries(gitBase) : [],
+    });
+  }
+
+  if (!otherFile) {
+    const oursEntries = currentDecisionEntries;
+    const split = splitDuplicateDecisions(oursEntries);
+    const gitBase = gitMergeBase();
+    const decisionPlan = planDecisionAbsorb({
+      oursEntries: split.ours,
+      theirsEntries: split.theirs,
+      baseEntries: gitBase ? gitDecisionEntries(gitBase) : [],
+      baseIds: gitBase ? gitDecisionIds(gitBase) : new Set(),
+    });
+    const repaired = repairDuplicateIntentRecords(loaded.records, decisionPlan.decisionMap);
+    if (decisionPlan.mappings.length > 0 && !repaired.incomingSide) {
+      fail(
+        'cannot determine which intent records own the duplicate decision; ' +
+          'run absorb during the merge or provide the incoming log and decision directory'
+      );
+    }
+    const result = repaired.records;
+    const mappings = [...repaired.mappings, ...decisionPlan.mappings];
+    const remappedIds = new Set(
+      mappings.filter((mapping) => mapping.kind === 'intent').map((mapping) => mapping.to)
+    );
+    const oursRecords = result.filter((record) => !remappedIds.has(record.event.id));
+    return finishAbsorb({
+      result,
+      oursRecords: oursRecords.length > 0 ? oursRecords : result,
+      theirsRecords: result,
+      mappings,
+      copies: decisionPlan.copies,
+      abandon,
+      dryRun,
+      outputFile: oursFile,
+      intentCount: remappedIds.size,
+    });
+  }
+
+  const theirs = loadAbsorbSide(otherFile, otherFile);
+  if (theirs.conflict) fail(`incoming log still contains conflict markers: ${otherFile}`);
+  const otherRoot = path.resolve(path.dirname(otherFile), '..');
+  const otherHead = isGitWorkTree(otherRoot) ? gitCapture(['rev-parse', 'HEAD'], otherRoot) : null;
+  const gitBase = otherHead ? gitCapture(['merge-base', 'HEAD', otherHead]) : gitMergeBase();
+  const baseDecisionIds = gitBase
+    ? gitDecisionIds(gitBase)
+    : collectDecisionIdsFromEvents(
+        loaded.records
+          .slice(0, commonPrefixLength(loaded.records, theirs.records))
+          .map((record) => record.event)
+      );
+  return absorbFromStreams(loaded.records, theirs.records, null, {
+    abandon,
+    dryRun,
+    outputFile: oursFile,
+    oursDecisionEntries: listDecisionEntries(decisionDir()),
+    theirsDecisionEntries: listDecisionEntries(otherDecisions || path.join(path.dirname(otherFile), '..', '.decision-log')),
+    baseDecisionEntries: gitBase ? gitDecisionEntries(gitBase) : [],
+    baseDecisionIds,
+  });
+}
+
+function absorbGit(baseFile, oursFile, theirsFile, { abandon, dryRun }) {
+  const base = loadAbsorbSide(baseFile, baseFile, { allowMissing: true });
+  const ours = loadAbsorbSide(oursFile, oursFile);
+  const theirs = loadAbsorbSide(theirsFile, theirsFile);
+  if (base.conflict || ours.conflict || theirs.conflict) {
+    fail('git merge driver received a log that still contains conflict markers');
+  }
+  const otherHead =
+    gitOtherHead() || gitFindCommitForFile(theirsFile, '.intent-log/events.jsonl');
+  const mergeBase = otherHead ? gitMergeBaseFor('HEAD', otherHead) : null;
+  let followupMessage = null;
+  if (!otherHead) {
+    followupMessage =
+      'incoming Git tree could not be identified safely; re-run driftseal absorb after Git stops the merge';
+  } else {
+    const decisionPlan = planDecisionAbsorb({
+      oursEntries: gitDecisionEntries('HEAD'),
+      theirsEntries: gitDecisionEntries(otherHead),
+      baseEntries: mergeBase ? gitDecisionEntries(mergeBase) : [],
+      baseIds: mergeBase
+        ? gitDecisionIds(mergeBase)
+        : collectDecisionIdsFromEvents(base.records.map((record) => record.event)),
+    });
+    const requiresDecisionRepair =
+      decisionPlan.mappings.length > 0 ||
+      decisionPlan.copies.some((copy) => copy.removeFile && copy.removeFile !== copy.toFile);
+    if (requiresDecisionRepair) {
+      followupMessage =
+        'decision ids require worktree repair; run driftseal absorb, then stage the repaired logs';
+    }
+  }
+  return absorbFromStreams(ours.records, theirs.records, base.records, {
+    abandon,
+    dryRun,
+    outputFile: oursFile,
+    allowConflict: !abandon,
+    followupMessage,
+  });
+}
+
 const commands = {
   begin(argv) {
     const { positionals, flags } = parseArgs(argv, {
@@ -2425,6 +3264,29 @@ const commands = {
     fail(hookUsage());
   },
 
+  absorb(argv) {
+    const { positionals, flags } = parseArgs(argv, {
+      git: 'boolean',
+      decisions: 'single',
+      'abandon-theirs': 'boolean',
+      'abandon-ours': 'boolean',
+      'dry-run': 'boolean',
+    });
+    if (flags['abandon-theirs'] && flags['abandon-ours']) {
+      fail('cannot combine --abandon-theirs and --abandon-ours');
+    }
+    const abandon = flags['abandon-theirs'] ? 'theirs' : flags['abandon-ours'] ? 'ours' : null;
+    const dryRun = Boolean(flags['dry-run']);
+
+    if (flags.git) {
+      if (positionals.length !== 3) fail(absorbUsage());
+      if (flags.decisions) fail('--decisions cannot be combined with --git');
+      return absorbGit(positionals[0], positionals[1], positionals[2], { abandon, dryRun });
+    }
+    if (positionals.length > 1) fail(absorbUsage());
+    return absorbLogs(positionals[0], flags.decisions, { abandon, dryRun });
+  },
+
   init(argv) {
     const { positionals } = parseArgs(argv, {});
     if (positionals.length > 0) fail('usage: driftseal init');
@@ -2448,6 +3310,8 @@ const commands = {
         protocolEol(previousIntentProtocolBlock(5), eol),
         protocolEol(previousIntentProtocolBlock(6), eol),
         protocolEol(previousIntentProtocolBlock(7), eol),
+        protocolEol(previousIntentProtocolBlock(8), eol),
+        protocolEol(previousIntentProtocolBlock(9), eol),
       ],
       knownLegacyBlocks: [protocolEol(legacyIntentProtocolBlock(), eol)],
     });
@@ -2465,6 +3329,8 @@ const commands = {
         protocolEol(previousDecisionProtocolBlock(5), eol),
         protocolEol(previousDecisionProtocolBlock(6), eol),
         protocolEol(previousDecisionProtocolBlock(7), eol),
+        protocolEol(previousDecisionProtocolBlock(8), eol),
+        protocolEol(previousDecisionProtocolBlock(9), eol),
       ],
       knownLegacyBlocks: [protocolEol(legacyDecisionProtocolBlock(), eol)],
     });
@@ -2484,12 +3350,28 @@ const commands = {
       updated += separator + additions.join(eol + eol) + eol;
     }
 
-    if (updated === current) {
+    const attributes = ensureGitAttributes();
+    let driver = { changed: false, configured: false };
+    try {
+      driver = ensureGitMergeDriver();
+    } catch (err) {
+      printLine(`warning: could not configure git merge driver: ${err && err.message ? err.message : err}`);
+    }
+
+    if (updated === current && !attributes.changed && !driver.changed) {
       printLine('AGENTS.md already contains the DriftSeal protocols; nothing to do');
       return { changed: false, target };
     }
-    atomicWriteFile(target, updated);
-    printLine(`DriftSeal protocol ${existed ? 'updated in' : 'written to'} ${target}`);
+    if (updated !== current) {
+      atomicWriteFile(target, updated);
+      printLine(`DriftSeal protocol ${existed ? 'updated in' : 'written to'} ${target}`);
+    }
+    if (attributes.changed) {
+      printLine(`Configured git merge attribute: ${attributes.target}`);
+    }
+    if (driver.changed) {
+      printLine('Configured local git merge driver for DriftSeal intent logs');
+    }
     return { changed: true, target };
   },
 
@@ -2507,6 +3389,11 @@ usage:
                                  hide meaningless closed records without deleting them
   driftseal unreclaim <id> --reason "<why>"
                                  restore a reclaimed record to the visible log
+  driftseal absorb [other-events.jsonl] [--decisions <dir>]
+                 [--abandon-theirs | --abandon-ours] [--dry-run]
+                                 merge another intent log, remapping colliding ids
+  driftseal absorb --git <base> <ours> <theirs>
+                                 git merge driver for .intent-log/events.jsonl
   driftseal decision add "<title>" --context "..." --outcome "..." [options]
   driftseal decision update <id> [--status STATUS] --note "..."
                                  reconcile a linked decision in the open intent
@@ -2524,7 +3411,7 @@ usage:
                                  targets: kimi-code (global only), claude-code, codex (prompt only)
   driftseal hook prompt|stop [--format plain|claude-code]
                                  emit the reminder a lifecycle hook injects; never blocks
-  driftseal init                       inject intent and decision protocols into ./AGENTS.md
+  driftseal init                       inject protocols into ./AGENTS.md and configure the git merge driver
   driftseal --version | -V             print the installed DriftSeal version
   driftseal help
 
@@ -2559,6 +3446,7 @@ function mutationResources(cmd, argv) {
   if (cmd === 'hook') return [parseHookInstallRequest(argv.slice(1)).configDir];
   if (cmd === 'init') return [process.cwd()];
   if (cmd === 'reclaim' || cmd === 'unreclaim') return [logDir()];
+  if (cmd === 'absorb') return [logDir(), decisionDir()];
   if (cmd === 'begin' && !argv.some((arg) => arg === '--decision' || arg.startsWith('--decision='))) {
     return [logDir()];
   }
@@ -2580,13 +3468,14 @@ function dispatch(argv) {
   const fn = commands[cmd];
   if (!fn) fail(`unknown command: ${cmd} (run: driftseal help)`);
   const mutates =
-    ['begin', 'end', 'init', 'skill', 'mcp', 'reclaim', 'unreclaim'].includes(cmd) ||
+    ['begin', 'end', 'init', 'skill', 'mcp', 'reclaim', 'unreclaim', 'absorb'].includes(cmd) ||
     (cmd === 'hook' && rest[0] === 'install') ||
     (cmd === 'decision' && ['add', 'update'].includes(rest[0]));
   const readsIntentLog = ['status', 'log'].includes(cmd);
   if (mutates || readsIntentLog) {
     const resources = readsIntentLog ? [logDir()] : mutationResources(cmd, rest);
-    return { data: withMutationLocks(resources, () => fn(rest)), exitCode: 0 };
+    const data = withMutationLocks(resources, () => fn(rest));
+    return { data, exitCode: data && Number.isInteger(data.exitCode) ? data.exitCode : 0 };
   }
   return { data: fn(rest), exitCode: 0 };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "driftseal",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "Seal intent, verification, and decisions into an auditable workflow for agentic coding",
   "keywords": [
     "driftseal",

package/skills/use-driftseal/SKILL.md

@@ -37,5 +37,13 @@ requires. For command syntax, run:
 driftseal help
 ```
 
+## After a merge
+
+If `status` or `log` fails with a duplicate id, or the intent log has conflict
+markers, run `driftseal absorb` instead of editing `.intent-log/events.jsonl`.
+When both sides still have an open intent, add `--abandon-theirs` or
+`--abandon-ours`. `driftseal init` also configures the local git merge driver;
+clones need `init` again for that driver.
+
 Do not treat this skill, MCP descriptions, or lifecycle-hook reminders as
 additional policy. If they conflict with `AGENTS.md`, follow `AGENTS.md`.