driftseal 1.1.0 → 1.1.2

package/README.md

@@ -179,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" \
@@ -197,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
 
@@ -293,7 +298,10 @@ 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`.
-Clones need `init` again because the driver lives in local git config.
+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
 

package/README.zh-CN.md

@@ -172,7 +172,7 @@ Kimi Code 只在全局 `config.toml` 中记录 hook，因此该 target 必须指
 
 ## 一轮标准工作流
 
-修改文件前，先声明这轮工作的目标：
+进行非 Git 改动前，先声明这轮工作的目标：
 
 ```sh
 driftseal begin "add rate limiting to /api/login" \
@@ -190,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 内容改动，就开启新一轮。
 
 ## 命令速览
 
@@ -270,8 +273,10 @@ driftseal absorb ../other-worktree/.intent-log/events.jsonl \
 不带 path 时，`absorb` 修复当前日志里的冲突标记或已经拼在一起的重复 id。两边都还有未关闭 intent 时，必须加上 `--abandon-theirs` 或 `--abandon-ours`。共享 base 里已经存在、又被两边同时改过的 decision，不会自动合并。
 
 `driftseal init` 会把这条 absorb 规则写入 `AGENTS.md`，同时写入 `.gitattributes`
-并配置 local git merge driver，让 `events.jsonl` 走 `absorb --git`。clone 之后
-需要再跑一次 `init`，因为 driver 只存在于 local git config。
+并配置 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。
 
 ## 数据保存在哪里
 

package/bin/driftseal.js

@@ -36,7 +36,7 @@ const DECISION_STATUSES = [
   'superseded',
 ];
 const EVENT_SCHEMA_VERSION = 3;
-const PROTOCOL_VERSION = 9;
+const PROTOCOL_VERSION = 10;
 const LOCK_STALE_MS = 30 * 60 * 1000;
 const LOCK_INIT_STALE_MS = 5 * 1000;
 const MAX_DECISION_SLUG_LENGTH = 180;
@@ -1136,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
@@ -1153,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
@@ -1175,7 +1178,34 @@ ${INTENT_PROTOCOL_END}`;
 }
 
 function previousIntentProtocolBlock(version) {
-  const v8 = 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`.',
@@ -1308,7 +1338,9 @@ Commit \`.decision-log/\` with the code.`;
 }
 
 function previousDecisionProtocolBlock(version) {
-  const v8 = decisionProtocolBlock(version).replace(
+  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.',
     ''
@@ -1654,7 +1686,7 @@ function directoryDigest(directory) {
   function visit(current, relative) {
     const stat = fs.lstatSync(current);
     if (stat.isDirectory()) {
-      digest.update(`directory\0${relative}\0${stat.mode & 0o777}\0`);
+      digest.update(`directory\0${relative}\0`);
       for (const name of fs.readdirSync(current).sort()) {
         visit(path.join(current, name), relative ? path.join(relative, name) : name);
       }
@@ -2042,18 +2074,23 @@ function runHookReminder(event, argv) {
   return { changed: true, event, format };
 }
 
-function gitCapture(args, cwd = process.cwd()) {
+function gitCaptureRaw(args, cwd = process.cwd()) {
   try {
     return execFileSync('git', args, {
       cwd,
       encoding: 'utf8',
       stdio: ['ignore', 'pipe', 'ignore'],
-    }).trim();
+    });
   } 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';
 }
@@ -2072,6 +2109,32 @@ function gitMergeBase(cwd = process.cwd()) {
   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();
@@ -2091,7 +2154,7 @@ function gitDecisionEntries(treeish, cwd = process.cwd()) {
     const name = path.basename(file);
     const match = name.match(/^(\d{4,})-.*\.md$/);
     if (!match) continue;
-    const content = gitCapture(['show', `${treeish}:${file}`], cwd);
+    const content = gitReadFile(treeish, file, cwd);
     if (content === null) continue;
     entries.push({
       id: normalizeDecisionId(match[1]),
@@ -2103,6 +2166,11 @@ function gitDecisionEntries(treeish, cwd = process.cwd()) {
   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)
@@ -2210,15 +2278,39 @@ function splitDuplicateDecisions(entries) {
   return { ours, theirs };
 }
 
-function planDecisionAbsorb({ oursEntries, theirsEntries, baseIds }) {
+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 hashMap = 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);
@@ -2234,27 +2326,73 @@ function planDecisionAbsorb({ oursEntries, theirsEntries, baseIds }) {
       continue;
     }
     const oursContent = ours.content !== undefined ? ours.content : fs.readFileSync(ours.path, 'utf8');
-    if (contentHash(oursContent) === contentHash(theirsContent)) continue;
-    if (baseIds.has(entry.id)) {
+    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 });
+    const rewritten = rewriteDecisionId(theirsContent, newId);
+    const originalHash = contentHash(theirsContent);
+    const rewrittenHash = contentHash(rewritten);
+    if (originalHash !== rewrittenHash) hashMap.set(originalHash, rewrittenHash);
     copies.push({
       fromFile: entry.file,
       toFile: `${newId}-${decisionSlugFromFile(entry.file)}.md`,
-      content: rewriteDecisionId(theirsContent, newId),
+      content: rewritten,
       removeFile: entry.file !== ours.file ? entry.file : null,
     });
   }
-  return { decisionMap, mappings, copies };
+  return { decisionMap, hashMap, mappings, copies };
 }
 
-function remapEvent(event, intentMap, decisionMap) {
+function remapEvent(event, intentMap, decisionMap, hashMap = new Map()) {
   const next = { ...event };
   if (intentMap.has(event.id)) next.id = intentMap.get(event.id);
   if (Array.isArray(next.decisions) && next.decisions.length > 0) {
@@ -2267,10 +2405,15 @@ function remapEvent(event, intentMap, decisionMap) {
     const normalized = normalizeDecisionId(next.decisionId);
     if (decisionMap.has(normalized)) next.decisionId = decisionMap.get(normalized);
   }
+  for (const field of ['oldHash', 'newHash', 'fileHash']) {
+    if (typeof next[field] === 'string' && hashMap.has(next[field])) {
+      next[field] = hashMap.get(next[field]);
+    }
+  }
   return next;
 }
 
-function remapTheirsRecords(theirsNew, oursUsedEvents, decisionMap) {
+function remapTheirsRecords(theirsNew, oursUsedEvents, decisionMap, hashMap = new Map()) {
   const intentMap = new Map();
   const mappings = [];
   const used = [...oursUsedEvents];
@@ -2282,22 +2425,24 @@ function remapTheirsRecords(theirsNew, oursUsedEvents, decisionMap) {
       intentMap.set(event.id, newId);
       mappings.push({ kind: 'intent', from: event.id, to: newId });
     }
-    event = remapEvent(event, intentMap, decisionMap);
+    event = remapEvent(event, intentMap, decisionMap, hashMap);
     used.push(event);
     return { event };
   });
   return { records, mappings };
 }
 
-function repairDuplicateIntentRecords(records, decisionMap) {
+function repairDuplicateIntentRecords(records, decisionMap, hashMap = new Map()) {
   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);
@@ -2305,12 +2450,17 @@ function repairDuplicateIntentRecords(records, decisionMap) {
     } else if (event.type === 'begin') {
       seenBegins.add(event.id);
     }
-    const remapped = remapEvent(event, intentMap, decisionMap);
+    const remapped = remapEvent(
+      event,
+      intentMap,
+      incomingSide ? decisionMap : new Map(),
+      incomingSide ? hashMap : 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 };
+  return { records: result, mappings, incomingSide };
 }
 
 function serializeRecords(records) {
@@ -2479,6 +2629,7 @@ function finishAbsorb({
   outputFile,
   intentCount,
   allowConflict = false,
+  followupMessage = null,
 }) {
   const { abandoned, conflict } = resolveOpenIntents(result, oursRecords, theirsRecords, abandon, {
     allowConflict,
@@ -2501,12 +2652,13 @@ function finishAbsorb({
   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 ? 1 : 0,
+    exitCode: conflict || followupMessage ? 1 : 0,
   };
 }
 
@@ -2515,12 +2667,14 @@ function absorbFromStreams(ours, theirs, baseRecords, options) {
   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
+    decisionPlan.decisionMap,
+    decisionPlan.hashMap
   );
   const result = [...streams.base, ...streams.oursNew, ...remapped.records];
   return finishAbsorb({
@@ -2533,13 +2687,61 @@ function absorbFromStreams(ours, theirs, baseRecords, options) {
     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)
@@ -2555,22 +2757,33 @@ function absorbLogs(otherFile, otherDecisions, { abandon, dryRun }) {
         ? listDecisionEntries(otherDecisions)
         : splitDuplicateDecisions(listDecisionEntries(decisionDir(), { allowDuplicates: true })).theirs,
       baseDecisionIds,
+      baseDecisionEntries: gitBase ? gitDecisionEntries(gitBase) : [],
     });
   }
 
   if (!otherFile) {
-    const oursEntries = listDecisionEntries(decisionDir(), { allowDuplicates: true });
+    const oursEntries = currentDecisionEntries;
     const split = splitDuplicateDecisions(oursEntries);
-    const repaired = repairDuplicateIntentRecords(loaded.records, new Map());
     const gitBase = gitMergeBase();
     const decisionPlan = planDecisionAbsorb({
       oursEntries: split.ours,
       theirsEntries: split.theirs,
+      baseEntries: gitBase ? gitDecisionEntries(gitBase) : [],
       baseIds: gitBase ? gitDecisionIds(gitBase) : new Set(),
     });
-    const withDecisions = repairDuplicateIntentRecords(repaired.records, decisionPlan.decisionMap);
-    const result = withDecisions.records;
-    const mappings = [...repaired.mappings, ...withDecisions.mappings, ...decisionPlan.mappings];
+    const repaired = repairDuplicateIntentRecords(
+      loaded.records,
+      decisionPlan.decisionMap,
+      decisionPlan.hashMap
+    );
+    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)
     );
@@ -2606,6 +2819,7 @@ function absorbLogs(otherFile, otherDecisions, { abandon, dryRun }) {
     outputFile: oursFile,
     oursDecisionEntries: listDecisionEntries(decisionDir()),
     theirsDecisionEntries: listDecisionEntries(otherDecisions || path.join(path.dirname(otherFile), '..', '.decision-log')),
+    baseDecisionEntries: gitBase ? gitDecisionEntries(gitBase) : [],
     baseDecisionIds,
   });
 }
@@ -2617,18 +2831,36 @@ function absorbGit(baseFile, oursFile, theirsFile, { abandon, dryRun }) {
   if (base.conflict || ours.conflict || theirs.conflict) {
     fail('git merge driver received a log that still contains conflict markers');
   }
-  const otherHead = gitOtherHead();
-  const mergeBase = gitMergeBase();
+  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,
-    oursDecisionEntries: listDecisionEntries(decisionDir(), { allowDuplicates: true }),
-    theirsDecisionEntries: otherHead ? gitDecisionEntries(otherHead) : [],
-    baseDecisionIds: mergeBase
-      ? gitDecisionIds(mergeBase)
-      : collectDecisionIdsFromEvents(base.records.map((record) => record.event)),
+    followupMessage,
   });
 }
 
@@ -3099,6 +3331,7 @@ const commands = {
         protocolEol(previousIntentProtocolBlock(6), eol),
         protocolEol(previousIntentProtocolBlock(7), eol),
         protocolEol(previousIntentProtocolBlock(8), eol),
+        protocolEol(previousIntentProtocolBlock(9), eol),
       ],
       knownLegacyBlocks: [protocolEol(legacyIntentProtocolBlock(), eol)],
     });
@@ -3117,6 +3350,7 @@ const commands = {
         protocolEol(previousDecisionProtocolBlock(6), eol),
         protocolEol(previousDecisionProtocolBlock(7), eol),
         protocolEol(previousDecisionProtocolBlock(8), eol),
+        protocolEol(previousDecisionProtocolBlock(9), eol),
       ],
       knownLegacyBlocks: [protocolEol(legacyDecisionProtocolBlock(), eol)],
     });

package/package.json

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