driftseal 3.1.0 → 3.3.0

package/README.md

@@ -47,6 +47,9 @@ npm install --global driftseal
 driftseal --version
 ```
 
+The package also installs `ds` as a short alias for `driftseal`. Both commands use
+the same CLI; for example, `ds status` is equivalent to `driftseal status`.
+
 From a source checkout:
 
 ```sh
@@ -213,7 +216,7 @@ driftseal decision update 1 --status accepted --note "Confirmed by the final imp
 | `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. |
+| `driftseal absorb [other-events.jsonl] [--decisions dir] [--abandon-theirs\|--abandon-ours]` | Merge another lineage, remap colliding ids, and repair stale MADR Decision History references. |
 | `driftseal decision add\|update\|list\|show` | Manage MADR records. |
 | `driftseal migrate v1-to-v2 inspect --json [migration paths]` | Normalize v1 state for model-assisted grouping. |
 | `driftseal migrate v1-to-v2 apply --plan <file> [migration paths]` | Validate a grouping plan and stage the v2 seal beside v1. |
@@ -311,6 +314,16 @@ ids, rebinds affected contract hashes, and refuses concurrent edits of a shared
 MADR. If both lineages remain open, choose explicitly with `--abandon-theirs` or
 `--abandon-ours`.
 
+`absorb` also repairs managed MADR Decision History outcome references by joining
+their reconciliation IDs to the merged log, and rebinds matching content hashes.
+It uses the local seal's `madr/` directory by default; when importing another log,
+its sibling `../madr/` is the default source (`--decisions` overrides that source).
+Run `driftseal absorb --dry-run` to preview repairs, including stale references
+left by an older merge whose outcome IDs are already unique. Entries without a
+matching reconciliation ID are left unchanged. If the Git merge driver reports
+that decision history requires worktree repair, run `driftseal absorb`, stage the
+repaired log and MADRs, then finish the merge.
+
 ## Node API and MCP
 
 ```js

package/README.zh-CN.md

@@ -41,6 +41,9 @@ npm install --global driftseal
 driftseal --version
 ```
 
+安装后也可以用短别名 `ds`，它与 `driftseal` 使用同一个 CLI 入口。
+例如，`ds status` 等同于 `driftseal status`。
+
 在源码 checkout 中使用：
 
 ```sh
@@ -193,7 +196,7 @@ driftseal decision update 1 --status accepted --note "Confirmed by the final imp
 | `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 并处理撞号。 |
+| `driftseal absorb [other-events.jsonl] [--decisions dir] [--abandon-theirs\|--abandon-ours]` | 合并另一条 lineage，处理撞号，并修复 MADR Decision History 中的过期 outcome 引用。 |
 | `driftseal decision add\|update\|list\|show` | 管理 MADR。 |
 | `driftseal migrate v1-to-v2 inspect --json [migration paths]` | 规范化 v1 状态，供模型分组。 |
 | `driftseal migrate v1-to-v2 apply --plan <file> [migration paths]` | 校验分组计划，并在 v1 旁边创建 v2 seal。 |
@@ -281,6 +284,14 @@ driftseal absorb
 contract hash，并拒绝自动合并 shared MADR 的并发编辑。若两条 lineage 都处于 open
 状态，必须显式选择 `--abandon-theirs` 或 `--abandon-ours`。
 
+`absorb` 还会通过 reconciliation ID 将 MADR 的 Decision History 条目与合并后的 log
+对应，修正其中的 outcome 引用，并同步匹配的内容 hash。默认处理当前 seal 的 `madr/`；
+导入其他 log 时，默认从该 log 的 `../madr/` 读取 MADR，可用 `--decisions` 指定其他来源。
+运行 `driftseal absorb --dry-run` 可预览修复；旧版本合并后留下的错链，即使 outcome ID
+已经没有冲突，也可以修复。找不到对应 reconciliation ID 的条目会保持原样。若 Git merge
+driver 提示 decision history 需要修复，运行 `driftseal absorb`，将修复后的 log 和 MADR
+加入 staging area，再完成 merge。
+
 ## Node API 与 MCP
 
 ```js

package/bin/driftseal-mcp.js

@@ -135,6 +135,7 @@ function registerTools(server, api, z) {
     abandoned: z.string().nullable(),
     copies: z.array(z.string()),
     outputFile: z.string(),
+    repairs: z.number().int().nonnegative(),
     exitCode: z.number().int(),
   });
   const closedStatus = z.enum(END_STATUSES);
@@ -416,7 +417,7 @@ function registerTools(server, api, z) {
     {
       title: 'Absorb another DriftSeal lineage',
       description:
-        'Repair the fixed repository after a merge collision or absorb another worktree\'s outcome and MADR logs, remapping colliding IDs.',
+        'Repair the fixed repository after a merge collision or absorb another worktree\'s outcome and MADR logs, remapping colliding IDs and repairing stale Decision History outcome references. Run with no incoming log after Git stops for decision-id or decision-history worktree repair.',
       inputSchema: {
         otherLog: z
           .string()
@@ -439,9 +440,16 @@ function registerTools(server, api, z) {
       guarded(() => {
         const result = api.absorb(input);
         const action = input.dryRun ? 'Absorb dry run' : 'Absorb';
+        const parts = [];
+        if (result.mappings.length > 0) {
+          parts.push(`${result.mappings.length} ID remapping(s)`);
+        }
+        if (result.repairs > 0) {
+          parts.push(`${result.repairs} decision history repair(s)`);
+        }
         return success(
           { root: api.root, result },
-          `${action} completed with ${result.mappings.length} ID remapping(s).`
+          `${action} completed with ${parts.join(' and ') || 'nothing to apply'}.`
         );
       })
   );

package/bin/driftseal.js

@@ -2636,7 +2636,10 @@ Seal root: \`.seal/\` (override with \`$DRIFTSEAL_HOME\`); outcome log:
 ${INTENT_PROTOCOL_END}`;
 }
 
-function intentProtocolBlockV21(version = PROTOCOL_VERSION, language = DEFAULT_LOG_LANGUAGE, localLog = false) {
+function intentProtocolBlockV21Text(version = PROTOCOL_VERSION, language = DEFAULT_LOG_LANGUAGE, localLog = false, { historyRepair = true } = {}) {
+  const absorbWhen = historyRepair
+    ? 'collisions or when Decision History outcome references are stale'
+    : 'collisions';
   return `${INTENT_PROTOCOL_MARKER}
 <!-- driftseal-version: ${version} -->
 <!-- driftseal-log-language: ${language} -->${localLog ? '\n<!-- driftseal-local-log: true -->' : ''}
@@ -2688,13 +2691,21 @@ ${outcomeLogLanguageParagraph(language)}
 **Log access goes only through DriftSeal.** Never read, edit, move, or delete
 \`.seal/outcomes/events.jsonl\` (or its configured equivalent) directly. Use
 \`reclaim\`/\`unreclaim\` for visibility markers and \`absorb\` after merge
-collisions. These operations preserve append-only single-lineage history.
+${absorbWhen}. These operations preserve append-only single-lineage history.
 
 Seal root: \`.seal/\` (override with \`$DRIFTSEAL_HOME\`); outcome log:
 \`.seal/outcomes/events.jsonl\`; ${localLog ? 'keep `.seal/` local and untracked.' : 'commit `.seal/` with the code.'}
 ${INTENT_PROTOCOL_END}`;
 }
 
+function intentProtocolBlockV21(version = PROTOCOL_VERSION, language = DEFAULT_LOG_LANGUAGE, localLog = false) {
+  return intentProtocolBlockV21Text(version, language, localLog, { historyRepair: true });
+}
+
+function intentProtocolBlockV21AbsorbCollisions(version = PROTOCOL_VERSION, language = DEFAULT_LOG_LANGUAGE, localLog = false) {
+  return intentProtocolBlockV21Text(version, language, localLog, { historyRepair: false });
+}
+
 function intentProtocolBlock(version = PROTOCOL_VERSION, language = DEFAULT_LOG_LANGUAGE, localLog = false) {
   if (String(version) === '2.0') return intentProtocolBlockV20(language, localLog);
   return intentProtocolBlockV21(version, language, localLog);
@@ -2991,7 +3002,19 @@ function protocolEol(content, eol) {
   return eol === '\n' ? content : content.replace(/\n/g, eol);
 }
 
+function decisionProtocolBlockAbsorbCollisions(version = PROTOCOL_VERSION, language = DEFAULT_LOG_LANGUAGE, localLog = false) {
+  return decisionProtocolBlockText(version, language, localLog, { historyRepair: false });
+}
+
 function decisionProtocolBlock(version = PROTOCOL_VERSION, language = DEFAULT_LOG_LANGUAGE, localLog = false) {
+  if (String(version) === '2.0') return decisionProtocolBlockAbsorbCollisions(version, language, localLog);
+  return decisionProtocolBlockText(version, language, localLog, { historyRepair: true });
+}
+
+function decisionProtocolBlockText(version = PROTOCOL_VERSION, language = DEFAULT_LOG_LANGUAGE, localLog = false, { historyRepair = true } = {}) {
+  const absorbSentence = historyRepair
+    ? 'After a\nmerge, `driftseal absorb` remaps colliding ids and repairs managed Decision History\noutcome references; it never auto-merges concurrent edits of a shared MADR.'
+    : 'After a\nmerge, `driftseal absorb` remaps colliding ids; it never auto-merges concurrent\nedits of a shared MADR.';
   return `${DECISION_PROTOCOL_MARKER}
 <!-- driftseal-decisions-version: ${version} -->
 <!-- driftseal-log-language: ${language} -->${localLog ? '\n<!-- driftseal-local-log: true -->' : ''}
@@ -3009,9 +3032,7 @@ ${decisionLogLanguageParagraph(language)}
 
 Use \`proposed|accepted|rejected|deferred|deprecated|superseded\` statuses. Link
 existing MADRs from \`begin\` or \`extend\`, then reconcile each linked record
-with \`driftseal decision update\` before successful or partial closure. After a
-merge, \`driftseal absorb\` remaps colliding ids; it never auto-merges concurrent
-edits of a shared MADR.
+with \`driftseal decision update\` before successful or partial closure. ${absorbSentence}
 ${localLog ? 'Keep `.seal/madr/` local and untracked.' : 'Commit `.seal/madr/` with the code.'}
 ${DECISION_PROTOCOL_END}`;
 }
@@ -3421,6 +3442,7 @@ const SKILL_RELEASE_DIGESTS = new Set([
   'b4b2cc27ea71c5777b5eb9b67d861fbe1da43f31ab5d422d6a877e0cad592493', // 2.1.0 lane re-anchor recovery
   '6c49523c2f4a36ea1cd9d0b4e793ea3cdbd9d299174cf1f9a0a54f3d9a7cd331', // workspace park sidecar wording
   '678cbaa8380f75f7a45d634010b500e51a59b06ea759eaf23cff2980142662f0', // default-seal parking help wording
+  'b5f2379fba311e19a5139dd6eb80795473fa6754fa959f90d4a36cc273b56e8f', // absorb Decision History repair
 ]);
 
 function skillInstallUsage() {
@@ -4226,6 +4248,75 @@ function rewriteDecisionId(content, newId) {
   return content.replace(/^# [0-9]+\. /, `# ${String(BigInt(newId))}. `);
 }
 
+function decisionIdFromFile(file) {
+  const match = path.basename(file).match(/^(\d{4,})-/);
+  if (!match) fail(`invalid decision filename: ${file}`);
+  return normalizeDecisionId(match[1]);
+}
+
+function reconciliationOutcomes(records) {
+  return new Map(records
+    .filter((record) => record.event.type === 'decision_reconcile_prepare')
+    .map((record) => [record.event.reconciliationId, record.event]));
+}
+
+function rewriteDecisionHistory(content, decisionId, outcomes) {
+  let repairs = 0;
+  const rewritten = content.replace(
+    /^(<!-- [a-z][a-z0-9-]*-reconciliation: ([^>\r\n]+) -->\r?\n### [^\r\n]+ — (?:Outcome|Intent) `)(\d{4}-\d{2}-\d{2}-\d{3,})(`\r?$)/gm,
+    (entry, prefix, reconciliationId, outcomeId, suffix) => {
+      const prepare = outcomes.get(reconciliationId);
+      if (!prepare || normalizeDecisionId(prepare.decisionId) !== decisionId || prepare.id === outcomeId) {
+        return entry;
+      }
+      repairs++;
+      return `${prefix}${prepare.id}${suffix}`;
+    }
+  );
+  return { content: rewritten, repairs };
+}
+
+function planDecisionHistoryRepair(records, copies, entries) {
+  const outcomes = reconciliationOutcomes(records);
+  const targets = new Map(entries.map((entry) => [entry.file, entry]));
+  const plannedCopies = new Map(copies.map((copy) => [copy.toFile, copy]));
+  const hashMap = new Map();
+  let repairs = 0;
+  for (const copy of copies) {
+    if (copy.removeFile) targets.delete(copy.removeFile);
+  }
+  for (const copy of copies) {
+    targets.set(copy.toFile, {
+      file: copy.toFile,
+      id: decisionIdFromFile(copy.toFile),
+      content: copy.content,
+    });
+  }
+  for (const entry of targets.values()) {
+    const content = entry.content !== undefined ? entry.content : fs.readFileSync(entry.path, 'utf8');
+    const rewritten = rewriteDecisionHistory(content, entry.id, outcomes);
+    if (rewritten.repairs === 0) continue;
+    repairs += rewritten.repairs;
+    // Rebind only hashes that attest the exact pre-repair bytes. Unrelated edits
+    // must still fail reconciliation recovery or closure after this repair.
+    hashMap.set(contentHash(content), contentHash(rewritten.content));
+    plannedCopies.set(entry.file, {
+      fromFile: entry.file,
+      toFile: entry.file,
+      removeFile: null,
+      ...plannedCopies.get(entry.file),
+      content: rewritten.content,
+    });
+  }
+  const unchangedIds = new Map();
+  const rewrittenRecords = records.map((record) =>
+    ['oldHash', 'newHash', 'fileHash'].some((field) => hashMap.has(record.event[field]))
+      ? { event: remapEvent(record.event, unchangedIds, unchangedIds, hashMap) }
+      : record
+  );
+  return { records: rewrittenRecords, copies: [...plannedCopies.values()], repairs };
+}
+
 function splitDuplicateDecisions(entries) {
   const ours = [];
   const theirs = [];
@@ -4676,6 +4767,7 @@ function finishAbsorb({
   outcomeCount,
   allowConflict = false,
   followupMessage = null,
+  repairDecisionHistory = true,
 }) {
   // A parked outcome is local even though the tracked log never saw it.
   const park = shouldAttachInProgress(outputFile)
@@ -4703,33 +4795,52 @@ function finishAbsorb({
   // A parked overlay with nothing left open in it belongs in the tracked log, whether the
   // abandon flag just closed it or an interrupted end left it closed.
   const flushOverlay = parkedClosed || (overlay.length > 0 && !parkedOpen);
-  const merged = flushOverlay ? [...result, ...overlay] : result;
   const effective = [...result, ...overlay].map((record) => record.event);
   fold(effective);
   if (!conflict) openOutcome(fold(effective));
+  const history = repairDecisionHistory
+    ? planDecisionHistoryRepair(
+      [...result, ...overlay], copies, listDecisionEntries(decisionDir(), { allowDuplicates: true })
+    )
+    : { records: [...result, ...overlay], copies, repairs: 0 };
+  const repairedResult = history.records.slice(0, result.length);
+  const repairedOverlay = history.records.slice(result.length);
+  const merged = flushOverlay ? history.records : repairedResult;
+  fold(history.records.map((record) => record.event));
   if (!dryRun) {
     writeJsonl(outputFile, merged);
-    applyDecisionCopies(copies, dryRun);
+    applyDecisionCopies(history.copies, dryRun);
     if (plan) {
       if (plan.alreadyCommitted || flushOverlay) discardInProgressLog(park);
-      else if (plan.mappings.length > 0) writeJsonl(park, overlay);
+      else if (plan.mappings.length > 0 || repairedOverlay.some((record, i) => record !== overlay[i])) {
+        writeJsonl(park, repairedOverlay);
+      }
     }
   }
+  const historyOnly =
+    history.repairs > 0 &&
+    outcomeCount === 0 &&
+    allMappings.length === 0 &&
+    !abandoned &&
+    !flushOverlay;
   if (
     outcomeCount === 0 &&
     allMappings.length === 0 &&
-    copies.length === 0 &&
+    history.copies.length === 0 &&
     !abandoned &&
     !flushOverlay
   ) {
     printLine('nothing to absorb');
-  } else {
+  } else if (!historyOnly) {
     printAbsorbReport({
       mappings: allMappings,
       abandoned,
       outcomeCount,
     });
   }
+  if (history.repairs > 0) {
+    printLine(`${dryRun ? 'would repair' : 'repaired'} ${history.repairs} decision history reference(s)`);
+  }
   if (conflict) {
     printLine('multiple outcomes remain in progress; re-run with --abandon-theirs or --abandon-ours');
   }
@@ -4737,13 +4848,14 @@ function finishAbsorb({
   return {
     mappings: allMappings,
     abandoned,
-    copies: copies.map((item) => item.toFile),
+    copies: history.copies.map((item) => item.toFile),
     outputFile,
+    repairs: history.repairs,
     exitCode: conflict || followupMessage ? 1 : 0,
   };
 }
 
-function absorbFromStreams(ours, theirs, baseRecords, options) {
+function planAbsorbMerge(ours, theirs, baseRecords, options = {}) {
   const streams = mergeRecordStreams(ours, theirs, baseRecords);
   const decisionPlan = planDecisionAbsorb({
     oursEntries: options.oursDecisionEntries || [],
@@ -4751,28 +4863,65 @@ function absorbFromStreams(ours, theirs, baseRecords, options) {
     baseEntries: options.baseDecisionEntries || [],
     baseIds: options.baseDecisionIds || new Set(),
   });
+  const oursRecords = [...streams.base, ...streams.oursNew];
   const remapped = remapTheirsRecords(
     dropDuplicateLaneAdds(
-      [...streams.base, ...streams.oursNew].map((record) => record.event),
+      oursRecords.map((record) => record.event),
       streams.theirsNew
     ),
-    [...streams.base, ...streams.oursNew].map((record) => record.event),
+    oursRecords.map((record) => record.event),
     decisionPlan.decisionMap,
     decisionPlan.hashMap
   );
-  const result = [...streams.base, ...streams.oursNew, ...remapped.records];
-  return finishAbsorb({
-    result,
-    oursRecords: [...streams.base, ...streams.oursNew],
+  return {
+    decisionPlan,
+    remapped,
+    result: [...oursRecords, ...remapped.records],
+    oursRecords,
     theirsRecords: [...streams.base, ...remapped.records],
     mappings: [...remapped.mappings, ...decisionPlan.mappings],
-    copies: decisionPlan.copies,
+    outcomeCount: streams.theirsNew.filter((record) => isOutcomeStart(record.event)).length,
+  };
+}
+
+function previewParkedOverlay(result, outputFile) {
+  // Git merge drivers often receive a temporary %A that is not the live WAL, so
+  // parked history still has to be previewed from the worktree sidecar.
+  const park = shouldAttachInProgress(outputFile)
+    ? existingInProgressFileForLog(outputFile)
+    : existingInProgressFile();
+  if (!park) return [];
+  const plan = planInProgressOverlay(
+    result.map((record) => record.event),
+    park,
+    { repairTail: true, readOnly: true }
+  );
+  return plan && !plan.alreadyCommitted ? plan.records : [];
+}
+
+function decisionHistoryNeedsRepair(records, entries) {
+  const outcomes = reconciliationOutcomes(records);
+  return entries.some((entry) => {
+    const content = entry.content !== undefined ? entry.content : fs.readFileSync(entry.path, 'utf8');
+    return rewriteDecisionHistory(content, entry.id, outcomes).repairs > 0;
+  });
+}
+
+function absorbFromStreams(ours, theirs, baseRecords, options) {
+  const merge = planAbsorbMerge(ours, theirs, baseRecords, options);
+  return finishAbsorb({
+    result: merge.result,
+    oursRecords: merge.oursRecords,
+    theirsRecords: merge.theirsRecords,
+    mappings: merge.mappings,
+    copies: merge.decisionPlan.copies,
     abandon: options.abandon,
     dryRun: options.dryRun,
     outputFile: options.outputFile,
     allowConflict: options.allowConflict,
     followupMessage: options.followupMessage,
-    outcomeCount: streams.theirsNew.filter((record) => ['begin', 'import'].includes(record.event.type)).length,
+    repairDecisionHistory: options.repairDecisionHistory,
+    outcomeCount: merge.outcomeCount,
   });
 }
 
@@ -4920,14 +5069,19 @@ function absorbGit(baseFile, oursFile, theirsFile, { abandon, dryRun }) {
     gitFindCommitForFile(theirsFile, '.seal/outcomes/events.jsonl') ||
     gitFindCommitForFile(theirsFile, '.intent-log/events.jsonl');
   const mergeBase = otherHead ? gitMergeBaseFor('HEAD', otherHead) : null;
+  // Driver merge remaps the jsonl only. Decision copies stay with a later
+  // worktree absorb so Git can finish merging MADR files first.
+  const merge = planAbsorbMerge(ours.records, theirs.records, base.records, {});
   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 oursDecisionEntries = gitDecisionEntries('HEAD');
+    const theirsDecisionEntries = gitDecisionEntries(otherHead);
     const decisionPlan = planDecisionAbsorb({
-      oursEntries: gitDecisionEntries('HEAD'),
-      theirsEntries: gitDecisionEntries(otherHead),
+      oursEntries: oursDecisionEntries,
+      theirsEntries: theirsDecisionEntries,
       baseEntries: mergeBase ? gitDecisionEntries(mergeBase) : [],
       baseIds: mergeBase
         ? gitDecisionIds(mergeBase)
@@ -4939,14 +5093,33 @@ function absorbGit(baseFile, oursFile, theirsFile, { abandon, dryRun }) {
     if (requiresDecisionRepair) {
       followupMessage =
         'decision ids require worktree repair; run driftseal absorb, then stage the repaired logs';
+    } else {
+      const overlay = previewParkedOverlay(merge.result, oursFile);
+      const worktreeEntries = listDecisionEntries(decisionDir(), { allowDuplicates: true });
+      if (decisionHistoryNeedsRepair(
+        [...merge.result, ...overlay],
+        [...oursDecisionEntries, ...theirsDecisionEntries, ...worktreeEntries]
+      )) {
+        followupMessage =
+          'decision history requires worktree repair; run driftseal absorb, then stage the repaired logs';
+      }
     }
   }
-  return absorbFromStreams(ours.records, theirs.records, base.records, {
+  return finishAbsorb({
+    result: merge.result,
+    oursRecords: merge.oursRecords,
+    theirsRecords: merge.theirsRecords,
+    mappings: merge.mappings,
+    copies: merge.decisionPlan.copies,
     abandon,
     dryRun,
     outputFile: oursFile,
     allowConflict: !abandon,
     followupMessage,
+    // Git owns the worktree MADR merge. Stop for a normal absorb when history
+    // needs repair rather than racing Git by writing other paths from its driver.
+    repairDecisionHistory: false,
+    outcomeCount: merge.outcomeCount,
   });
 }
 
@@ -6672,6 +6845,8 @@ const commands = {
         ...sourceLanguages.flatMap((source) => [
           protocolEol(intentProtocolBlock(PROTOCOL_VERSION, source), eol),
           protocolEol(intentProtocolBlock(PROTOCOL_VERSION, source, true), eol),
+          protocolEol(intentProtocolBlockV21AbsorbCollisions(PROTOCOL_VERSION, source), eol),
+          protocolEol(intentProtocolBlockV21AbsorbCollisions(PROTOCOL_VERSION, source, true), eol),
           protocolEol(intentProtocolBlockV20(source), eol),
           protocolEol(intentProtocolBlockV20(source, true), eol),
           protocolEol(v1IntentProtocolBlock(14, source), eol),
@@ -6706,6 +6881,8 @@ const commands = {
         ...sourceLanguages.flatMap((source) => [
           protocolEol(decisionProtocolBlock(PROTOCOL_VERSION, source), eol),
           protocolEol(decisionProtocolBlock(PROTOCOL_VERSION, source, true), eol),
+          protocolEol(decisionProtocolBlockAbsorbCollisions(PROTOCOL_VERSION, source), eol),
+          protocolEol(decisionProtocolBlockAbsorbCollisions(PROTOCOL_VERSION, source, true), eol),
           protocolEol(decisionProtocolBlock('2.0', source), eol),
           protocolEol(decisionProtocolBlock('2.0', source, true), eol),
           protocolEol(v1DecisionProtocolBlock(14, source), eol),
@@ -6781,6 +6958,8 @@ const commands = {
 
 Outcome-level write-ahead log for agent sessions.
 
+The ds command is an alias for driftseal; all commands and options are identical.
+
 usage:
   driftseal begin "<outcome>" [--accept "<observable result>"] [--verify "<command>"]
                  [--decision <id>] [--force]
@@ -6805,6 +6984,7 @@ usage:
   driftseal absorb [other-events.jsonl] [--decisions <dir>]
                  [--abandon-theirs | --abandon-ours] [--dry-run]
                                  merge another outcome log, remapping colliding ids
+                                 and repairing stale MADR Decision History references
   driftseal absorb --git <base> <ours> <theirs>
                                  git merge driver for .seal/outcomes/events.jsonl
   driftseal decision add "<title>" --context "..." --outcome "..." [options]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "driftseal",
-  "version": "3.1.0",
+  "version": "3.3.0",
   "description": "Seal outcomes, verification, and decisions into an auditable workflow for agentic coding",
   "keywords": [
     "driftseal",
@@ -26,6 +26,7 @@
   "main": "index.js",
   "bin": {
     "driftseal": "bin/driftseal.js",
+    "ds": "bin/driftseal.js",
     "driftseal-mcp": "bin/driftseal-mcp.js"
   },
   "directories": {

package/skills/use-driftseal/SKILL.md

@@ -44,8 +44,12 @@ driftseal help
 ## After a merge
 
 If `status` or `log` fails with a duplicate id or with `multiple outcomes in
-progress`, or the outcome log has conflict markers, run `driftseal absorb`
-instead of editing `.seal/outcomes/events.jsonl`. When both sides still have an
+progress`, or the outcome log has conflict markers, or Git stops because
+decision ids or Decision History need worktree repair, run `driftseal absorb`
+instead of editing `.seal/outcomes/events.jsonl`. A merge can leave the log
+healthy while MADR Decision History still quotes pre-merge outcome ids; `absorb`
+(and `absorb --dry-run`) repairs those references even when ids are already
+unique. When both sides still have an
 open outcome, add `--abandon-theirs` or `--abandon-ours`; this works whether your
 open outcome sits in the log or is parked beside the WAL. `driftseal init` also
 configures the local git merge driver; clones need `init` again for that driver.

package/test/package-smoke.js

@@ -112,16 +112,32 @@ try {
     DRIFTSEAL_HOME: home,
     DRIFTSEAL_DECISION_HOME: path.join(home, 'madr'),
   };
+  for (const name of ['driftseal', 'ds', 'driftseal-mcp']) {
+    const executable = process.platform === 'win32' ? `${name}.cmd` : name;
+    assert.equal(
+      fs.existsSync(path.join(consumer, 'node_modules', '.bin', executable)),
+      true,
+      `${name} is installed as an executable`
+    );
+  }
+  function runInstalled(name, args) {
+    return runNpm(['exec', '--offline', '--prefix', consumer, '--', name, ...args], {
+      cwd: sandbox,
+      env,
+    });
+  }
+  const metadata = require(path.join(installed, 'package.json'));
+  for (const name of ['driftseal', 'ds']) {
+    assert.equal(runInstalled(name, ['--version']), `${metadata.version}\n`);
+  }
+  const help = runInstalled('driftseal', ['--help']);
+  assert.match(help, /The ds command is an alias for driftseal/);
+  assert.equal(runInstalled('ds', ['--help']), help);
+
   const cli = path.join(installed, 'bin', 'driftseal.js');
-  run(process.execPath, [cli, 'begin', 'packaged sqlite smoke'], {
-    cwd: sandbox,
-    env,
-  });
-  run(
-    process.execPath,
-    [cli, 'end', '--status', 'abandoned', '--note', 'packaged smoke'],
-    { cwd: sandbox, env }
-  );
+  runInstalled('ds', ['begin', 'packaged sqlite smoke']);
+  assert.match(runInstalled('driftseal', ['status']), /packaged sqlite smoke/);
+  runInstalled('driftseal', ['end', '--status', 'abandoned', '--note', 'packaged smoke']);
   const logged = spawnSync(process.execPath, [cli, 'log', '--last', '1'], {
     cwd: sandbox,
     env,
@@ -130,6 +146,7 @@ try {
   });
   assert.equal(logged.status, 0, logged.stderr);
   assert.match(logged.stdout, /packaged sqlite smoke/);
+  assert.equal(runInstalled('ds', ['log', '--last', '1']), logged.stdout);
   assert.doesNotMatch(logged.stderr, /SQLite is an experimental feature/);
   assert.equal(fs.existsSync(indexFile), true);
   fs.writeFileSync(indexFile, 'corrupt package smoke index');