ultra-builder-pro-cli 0.13.0 → 0.15.0

package/hooks/subagent_tracker.py

@@ -1,73 +1,67 @@
 #!/usr/bin/env python3
-"""Subagent lifecycle tracker.
+"""Append minimal Ultra subagent lifecycle metadata to state.db events.
 
-Logs SubagentStart/Stop events to .ultra/debug/subagent-log.jsonl (project-level)
-for debugging and cost analysis.
-
-Protocol fields:
-  SubagentStart: agent_id, agent_type, session_id
-  SubagentStop: agent_id, agent_type, session_id, agent_transcript_path,
-                last_assistant_message, stop_hook_active
-
-Usage:
-  python3 subagent_tracker.py start  # called by SubagentStart hook
-  python3 subagent_tracker.py stop   # called by SubagentStop hook
+The hook never stores prompts, messages, transcript paths, or a parallel JSONL log.
+It is advisory: a failed lifecycle event is reported on stderr but never blocks the
+host's subagent operation.
 """
 
 import json
 import os
-import random
+import shutil
+import subprocess
 import sys
-from datetime import datetime, timezone
 from pathlib import Path
 
-TERMINAL = {"committed", "completed", "done", "cancelled"}
-MAX_LOG_LINES = 5000
+from context_spine import find_root
 
 
-def get_log_dir(hook_input: dict):
-    start = Path(hook_input.get("cwd") or Path.cwd()).resolve()
-    for root in (start, *start.parents):
-        state_file = root / ".ultra" / "workflow-state.json"
-        if not state_file.is_file():
-            continue
-        try:
-            state = json.loads(state_file.read_text(encoding="utf-8"))
-        except (OSError, json.JSONDecodeError) as exc:
-            print(f"[subagent_tracker] cannot read {state_file}: {exc}", file=sys.stderr)
-            return None
-        if isinstance(state, dict) and state.get("status") not in TERMINAL:
-            return root / ".ultra" / "runtime"
-        return None
-    return None
-
-
-def rotate_log(log_file: Path) -> None:
-    """Keep last MAX_LOG_LINES entries to prevent unbounded growth."""
-    try:
-        if not log_file.exists():
-            return
-        with open(log_file, "r", encoding="utf-8") as f:
-            lines = f.readlines()
-        if len(lines) <= MAX_LOG_LINES:
-            return
-        with open(log_file, "w", encoding="utf-8") as f:
-            f.writelines(lines[-MAX_LOG_LINES:])
-    except OSError as exc:
-        print(f"[subagent_tracker] log rotation failed: {exc}", file=sys.stderr)
-
-
-def main():
-    if len(sys.argv) < 2:
-        print(json.dumps({}))
-        return
+def helper_path() -> Path:
+    hook_root = Path(__file__).resolve().parent
+    installed = hook_root.parent / "runtime" / "hook-event.cjs"
+    if installed.is_file():
+        return installed
+    source = hook_root.parent / "mcp-server" / "hook-event.cjs"
+    if source.is_file():
+        return source
+    raise RuntimeError("bundled hook lifecycle helper is missing")
 
-    action = sys.argv[1]
+
+def node_binary() -> str:
+    configured = os.environ.get("UBP_NODE")
+    if configured:
+        return configured
+    discovered = shutil.which("node")
+    if discovered:
+        return discovered
+    raise RuntimeError("node executable is unavailable")
+
+
+def append_event(root: Path, action: str, hook_input: dict) -> None:
+    payload = {
+        "agent_id": hook_input.get("agent_id", "unknown"),
+        "agent_type": hook_input.get("agent_type", "unknown"),
+        "session_id": hook_input.get("session_id", ""),
+    }
+    result = subprocess.run(
+        [node_binary(), str(helper_path()), str(root.resolve()), action],
+        input=json.dumps(payload),
+        text=True,
+        capture_output=True,
+        check=False,
+        timeout=5,
+    )
+    if result.returncode != 0:
+        detail = result.stderr.strip() or f"exit {result.returncode}"
+        raise RuntimeError(detail)
+
+
+def main() -> None:
+    action = sys.argv[1] if len(sys.argv) > 1 else ""
     if action not in ("start", "stop"):
         print(json.dumps({}))
         return
 
-    # Read hook input from stdin
     try:
         raw = sys.stdin.read()
         hook_input = json.loads(raw) if raw.strip() else {}
@@ -77,37 +71,12 @@ def main():
         print(f"[subagent_tracker] invalid hook input: {exc}", file=sys.stderr)
         hook_input = {}
 
-    # Lazy init: avoid module-level subprocess
-    log_dir = get_log_dir(hook_input)
-    if log_dir is None:
-        print(json.dumps({}))
-        return
-    log_file = log_dir / "subagent-log.jsonl"
-    log_dir.mkdir(parents=True, exist_ok=True)
-
-    entry = {
-        "timestamp": datetime.now(timezone.utc).isoformat(),
-        "event": f"subagent_{action}",
-        "agent_id": hook_input.get("agent_id", "unknown"),
-        "agent_type": hook_input.get("agent_type", "unknown"),
-        "session_id": hook_input.get("session_id", ""),
-    }
-
-    # SubagentStop provides additional fields
-    if action == "stop":
-        transcript = hook_input.get("agent_transcript_path", "")
-        if transcript:
-            entry["agent_transcript_path"] = transcript
-
-    try:
-        with open(log_file, "a", encoding="utf-8") as f:
-            f.write(json.dumps(entry, ensure_ascii=False) + "\n")
-    except OSError as exc:
-        print(f"[subagent_tracker] event write failed: {exc}", file=sys.stderr)
-
-    # Periodic log rotation (~1% of writes)
-    if random.random() < 0.01:
-        rotate_log(log_file)
+    root = find_root(Path(hook_input.get("cwd") or Path.cwd()).resolve())
+    if root is not None:
+        try:
+            append_event(root, action, hook_input)
+        except (OSError, RuntimeError, subprocess.TimeoutExpired) as exc:
+            print(f"[subagent_tracker] lifecycle event unavailable: {exc}", file=sys.stderr)
 
     print(json.dumps({}))
 

package/hooks/workflow_checkpoint.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-"""Write a minimal, mechanical compaction checkpoint for an active workflow."""
+"""Write a recovery projection of the canonical DB breadcrumb before compaction."""
 
 import json
 import os
@@ -8,18 +8,12 @@ import tempfile
 from datetime import datetime, timezone
 from pathlib import Path
 
-TERMINAL = {"committed", "completed", "done", "cancelled"}
-
-
-def valid_workflow(state: object) -> bool:
-    return (
-        isinstance(state, dict)
-        and isinstance(state.get("command"), str)
-        and bool(state["command"].strip())
-        and state.get("step") is not None
-        and isinstance(state.get("status"), str)
-        and bool(state["status"].strip())
-    )
+from context_spine import (
+    ContextSpineError,
+    find_root,
+    read_breadcrumb,
+    render_breadcrumb,
+)
 
 
 def main() -> None:
@@ -29,41 +23,39 @@ def main() -> None:
     except json.JSONDecodeError as exc:
         print(f"[workflow_checkpoint] invalid hook input: {exc}", file=sys.stderr)
         data = {}
-    start = Path(data.get("cwd") or Path.cwd()).resolve()
-    for root in (start, *start.parents):
-        state_file = root / ".ultra" / "workflow-state.json"
-        if not state_file.is_file():
-            continue
-        try:
-            state = json.loads(state_file.read_text(encoding="utf-8"))
-        except (OSError, json.JSONDecodeError) as exc:
-            print(f"[workflow_checkpoint] cannot read {state_file}: {exc}", file=sys.stderr)
-            break
-        if not valid_workflow(state):
-            print(f"[workflow_checkpoint] invalid workflow state in {state_file}", file=sys.stderr)
-            break
-        if state.get("status") in TERMINAL:
-            break
-        runtime_dir = root / ".ultra" / "runtime"
-        runtime_dir.mkdir(parents=True, exist_ok=True)
-        checkpoint = {
-            "schema": 1,
-            "captured_at": datetime.now(timezone.utc).isoformat(),
-            "session_id": data.get("session_id", ""),
-            "workflow": state,
-        }
-        fd, temp_name = tempfile.mkstemp(prefix="checkpoint.", suffix=".json", dir=runtime_dir)
-        try:
-            with os.fdopen(fd, "w", encoding="utf-8") as handle:
-                json.dump(checkpoint, handle, ensure_ascii=False, indent=2)
-                handle.write("\n")
-            os.replace(temp_name, runtime_dir / "checkpoint.json")
-        finally:
-            if os.path.exists(temp_name):
-                os.unlink(temp_name)
-        print(json.dumps({"systemMessage": "Ultra workflow checkpoint saved."}))
+    root = find_root(Path(data.get("cwd") or Path.cwd()).resolve())
+    if root is None:
+        print(json.dumps({}))
+        return
+    try:
+        breadcrumb = read_breadcrumb(root)
+    except ContextSpineError as exc:
+        print(f"[workflow_checkpoint] cannot inspect Context Spine: {exc}", file=sys.stderr)
+        print(json.dumps({}))
         return
-    print(json.dumps({}))
+    if not breadcrumb or not breadcrumb.get("change_id"):
+        print(json.dumps({}))
+        return
+
+    runtime_dir = root / ".ultra" / "runtime"
+    runtime_dir.mkdir(parents=True, exist_ok=True)
+    checkpoint = {
+        "schema": 2,
+        "captured_at": datetime.now(timezone.utc).isoformat(),
+        "session_id": data.get("session_id", ""),
+        "breadcrumb": dict(breadcrumb),
+        "rendered": render_breadcrumb(root, breadcrumb),
+    }
+    fd, temp_name = tempfile.mkstemp(prefix="checkpoint.", suffix=".json", dir=runtime_dir)
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as handle:
+            json.dump(checkpoint, handle, ensure_ascii=False, indent=2)
+            handle.write("\n")
+        os.replace(temp_name, runtime_dir / "checkpoint.json")
+    finally:
+        if os.path.exists(temp_name):
+            os.unlink(temp_name)
+    print(json.dumps({"systemMessage": "Ultra workflow checkpoint saved."}))
 
 
 if __name__ == "__main__":

package/hooks/workflow_context.py

@@ -2,11 +2,10 @@
 """Inject one compact Ultra state position without persistent memory."""
 
 import json
-import sqlite3
 import sys
 from pathlib import Path
 
-from context_spine import find_root, read_breadcrumb, render_breadcrumb
+from context_spine import ContextSpineError, find_root, read_breadcrumb, render_breadcrumb
 
 
 def payload() -> dict:
@@ -26,18 +25,14 @@ def main() -> None:
         return
     try:
         breadcrumb = read_breadcrumb(root)
-    except (sqlite3.Error, OSError) as exc:
+    except ContextSpineError as exc:
         print(f"[workflow_context] cannot inspect Context Spine: {exc}", file=sys.stderr)
         breadcrumb = None
     if breadcrumb:
         context = render_breadcrumb(root, breadcrumb)
     else:
-        context = "\n".join([
-            "[Ultra baseline]",
-            f"Project: {root}",
-            "No active continuous change. Start daily work with the ultra-change workflow.",
-            "Authority: .ultra/state.db; JSON/Markdown remain projections or evidence artifacts.",
-        ])
+        print(json.dumps({}))
+        return
     print(json.dumps({"hookSpecificOutput": {
         "hookEventName": "SessionStart",
         "additionalContext": context,

package/hooks/workflow_resume.py

@@ -1,84 +1,53 @@
 #!/usr/bin/env python3
-"""Restore only the current Ultra workflow boundary after compaction."""
+"""Re-inject live DB authority after compaction; checkpoints are advisory only."""
 
 import json
-import os
-import sqlite3
 import sys
-import tempfile
-from datetime import datetime, timezone
+from datetime import datetime
 from pathlib import Path
 
-from context_spine import find_root, read_breadcrumb, render_breadcrumb
+from context_spine import (
+    ContextSpineError,
+    find_root,
+    read_breadcrumb,
+    render_breadcrumb,
+)
 
-TERMINAL = {"committed", "completed", "done", "cancelled"}
 
+def _hook_output(event: str, text: str) -> dict:
+    if event == "SessionStart":
+        return {"hookSpecificOutput": {
+            "hookEventName": "SessionStart",
+            "additionalContext": text,
+        }}
+    return {"additionalContext": text}
 
-def valid_workflow(state: object) -> bool:
-    return (
-        isinstance(state, dict)
-        and isinstance(state.get("command"), str)
-        and bool(state["command"].strip())
-        and state.get("step") is not None
-        and isinstance(state.get("status"), str)
-        and bool(state["status"].strip())
-    )
 
-
-def read_json(file: Path, label: str):
+def _checkpoint_advisory(root: Path):
+    file = root / ".ultra" / "runtime" / "checkpoint.json"
     if not file.is_file():
         return None
     try:
-        return json.loads(file.read_text(encoding="utf-8"))
-    except (OSError, json.JSONDecodeError) as exc:
-        print(f"[workflow_resume] cannot read {label} {file}: {exc}", file=sys.stderr)
-        return None
-
-
-def parse_time(value: object):
-    if not isinstance(value, str) or not value.strip():
-        return None
-    try:
-        return datetime.fromisoformat(value.replace("Z", "+00:00")).astimezone(timezone.utc)
-    except ValueError:
-        return None
-
-
-def newest_time(file: Path, *values: object) -> datetime:
-    candidates = [parsed for value in values if (parsed := parse_time(value)) is not None]
-    try:
-        candidates.append(datetime.fromtimestamp(file.stat().st_mtime, tz=timezone.utc))
-    except OSError:
-        pass
-    return max(candidates, default=datetime.min.replace(tzinfo=timezone.utc))
-
-
-def load_checkpoint(file: Path):
-    checkpoint = read_json(file, "checkpoint")
-    if checkpoint is None:
+        value = json.loads(file.read_text(encoding="utf-8"))
+        datetime.fromisoformat(str(value.get("captured_at", "")).replace("Z", "+00:00"))
+    except (OSError, json.JSONDecodeError, ValueError, AttributeError) as exc:
+        print(f"[workflow_resume] cannot read checkpoint {file}: {exc}", file=sys.stderr)
         return None
-    if not isinstance(checkpoint, dict):
+    if (
+        not isinstance(value, dict)
+        or value.get("schema") != 2
+        or not isinstance(value.get("breadcrumb"), dict)
+        or not isinstance(value.get("rendered"), str)
+        or not value["rendered"].strip()
+    ):
         print(f"[workflow_resume] invalid checkpoint schema in {file}", file=sys.stderr)
         return None
-    captured_at = checkpoint.get("captured_at")
-    workflow = checkpoint.get("workflow")
-    if checkpoint.get("schema") != 1 or parse_time(captured_at) is None or not valid_workflow(workflow):
-        print(f"[workflow_resume] invalid checkpoint schema in {file}", file=sys.stderr)
-        return None
-    return checkpoint
-
-
-def restore_state(file: Path, state: dict) -> None:
-    file.parent.mkdir(parents=True, exist_ok=True)
-    fd, temp_name = tempfile.mkstemp(prefix="workflow-state.", suffix=".json", dir=file.parent)
-    try:
-        with os.fdopen(fd, "w", encoding="utf-8") as handle:
-            json.dump(state, handle, ensure_ascii=False, indent=2)
-            handle.write("\n")
-        os.replace(temp_name, file)
-    finally:
-        if os.path.exists(temp_name):
-            os.unlink(temp_name)
+    return "\n".join([
+        "[Ultra checkpoint advisory]",
+        "Live .ultra/state.db could not be read; this checkpoint is not authority.",
+        value["rendered"],
+        "Run ultra-doctor before mutation.",
+    ])
 
 
 def main() -> None:
@@ -88,72 +57,23 @@ def main() -> None:
     except json.JSONDecodeError as exc:
         print(f"[workflow_resume] invalid hook input: {exc}", file=sys.stderr)
         data = {}
-    start = Path(data.get("cwd") or Path.cwd()).resolve()
-    root = find_root(start)
-    if root is not None:
-        try:
-            breadcrumb = read_breadcrumb(root)
-        except (sqlite3.Error, OSError) as exc:
-            print(f"[workflow_resume] cannot inspect Context Spine: {exc}", file=sys.stderr)
-            breadcrumb = None
+    root = find_root(Path(data.get("cwd") or Path.cwd()).resolve())
+    if root is None:
+        print(json.dumps({}))
+        return
+    text = None
+    try:
+        breadcrumb = read_breadcrumb(root)
         if breadcrumb:
             text = render_breadcrumb(root, breadcrumb)
-            event = data.get("hook_event_name", "SessionStart")
-            if event == "SessionStart":
-                print(json.dumps({"hookSpecificOutput": {
-                    "hookEventName": "SessionStart",
-                    "additionalContext": text,
-                }}))
-            else:
-                print(json.dumps({"additionalContext": text}))
-            return
-    for root in (start, *start.parents):
-        state_file = root / ".ultra" / "workflow-state.json"
-        checkpoint_file = root / ".ultra" / "runtime" / "checkpoint.json"
-        if not state_file.is_file() and not checkpoint_file.is_file():
-            continue
-        live = read_json(state_file, "workflow state")
-        if live is not None and not valid_workflow(live):
-            print(f"[workflow_resume] invalid workflow state in {state_file}", file=sys.stderr)
-            live = None
-        if live is not None and live.get("status") in TERMINAL:
-            break
-        checkpoint = load_checkpoint(checkpoint_file)
-        checkpoint_state = checkpoint["workflow"] if checkpoint is not None else None
-        if checkpoint_state is not None and checkpoint_state.get("status") in TERMINAL:
-            checkpoint_state = None
-
-        source = ".ultra/workflow-state.json"
-        state = live
-        if checkpoint_state is not None:
-            checkpoint_time = newest_time(
-                checkpoint_file, checkpoint_state.get("ts"), checkpoint.get("captured_at")
-            )
-            live_time = newest_time(state_file, live.get("ts")) if live is not None else None
-            if live_time is None or checkpoint_time >= live_time:
-                state = checkpoint_state
-                source = ".ultra/runtime/checkpoint.json"
-                restore_state(state_file, state)
-        if state is None:
-            break
-        text = (
-            "[Ultra workflow resumed] "
-            f"command={state.get('command', 'unknown')}; "
-            f"task={state.get('task_id', state.get('task', 'unknown'))}; "
-            f"step={state.get('step', 'unknown')}; status={state.get('status', 'active')}. "
-            f"source={source}. Continue from the recovered workflow boundary and verify "
-            "task/session/change state through .ultra/state.db."
-        )
-        event = data.get("hook_event_name", "SessionStart")
-        if event == "SessionStart":
-            print(json.dumps({"hookSpecificOutput": {
-                "hookEventName": "SessionStart",
-                "additionalContext": text,
-            }}))
-        else:
-            print(json.dumps({"additionalContext": text}))
+    except ContextSpineError as exc:
+        print(f"[workflow_resume] cannot inspect Context Spine: {exc}", file=sys.stderr)
+        text = _checkpoint_advisory(root)
+    if not text:
+        print(json.dumps({}))
         return
-    print(json.dumps({}))
+    event = data.get("hook_event_name", "SessionStart")
+    print(json.dumps(_hook_output(event, text)))
 
 
 if __name__ == "__main__":

package/mcp-server/breadcrumb.cjs

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const runtime = fs.existsSync(path.join(__dirname, 'index.cjs'))
+  ? require('./index.cjs')
+  : require('./server.cjs');
+
+function main() {
+  const rootDir = path.resolve(process.argv[2] || process.cwd());
+  const breadcrumb = runtime.readProjectBreadcrumb(rootDir);
+  process.stdout.write(`${JSON.stringify({
+    breadcrumb,
+    text: breadcrumb ? runtime.renderProjectBreadcrumb(rootDir, breadcrumb) : null,
+  })}\n`);
+}
+
+if (require.main === module) main();
+
+module.exports = { main };

package/mcp-server/hook-event.cjs

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const runtime = fs.existsSync(path.join(__dirname, 'index.cjs'))
+  ? require('./index.cjs')
+  : require('./server.cjs');
+
+function main() {
+  const rootDir = path.resolve(process.argv[2] || process.cwd());
+  const action = process.argv[3];
+  let hookInput = {};
+  const raw = fs.readFileSync(0, 'utf8');
+  if (raw.trim()) {
+    hookInput = JSON.parse(raw);
+    if (!hookInput || typeof hookInput !== 'object' || Array.isArray(hookInput)) {
+      throw new Error('hook input must be a JSON object');
+    }
+  }
+  const result = runtime.appendHookLifecycleEvent({ rootDir, action, hookInput });
+  process.stdout.write(`${JSON.stringify(result)}\n`);
+}
+
+if (require.main === module) {
+  try { main(); }
+  catch (error) {
+    process.stderr.write(`hook lifecycle event failed: ${error.message}\n`);
+    process.exit(1);
+  }
+}
+
+module.exports = { main };

package/mcp-server/lib/archive-journal.cjs

@@ -31,6 +31,9 @@ function assertIntent(intent, rootDir) {
     || intent.schema_version !== INTENT_VERSION
     || typeof intent.change_id !== 'string' || !intent.change_id
     || !Array.isArray(intent.baseline_updates)
+    || typeof intent.reconciliation_path !== 'string' || !intent.reconciliation_path
+    || !/^[0-9a-f]{64}$/.test(String(intent.reconciliation_digest || ''))
+    || !intent.reconciliation_manifest || typeof intent.reconciliation_manifest !== 'object'
     || typeof intent.summary !== 'string' || intent.summary.trim().length < 3) {
     throw new ArchiveJournalError('ARCHIVE_INTENT_INVALID', 'archive intent shape is invalid');
   }
@@ -46,6 +49,7 @@ function assertIntent(intent, rootDir) {
     throw new ArchiveJournalError('ARCHIVE_INTENT_INVALID', 'archive intent destination is not the change archive root');
   }
   for (const update of intent.baseline_updates) resolveInside(rootDir, update, 'baseline update');
+  resolveInside(rootDir, intent.reconciliation_path, 'reconciliation path');
   if (intent.previous_summary !== null && typeof intent.previous_summary !== 'string') {
     throw new ArchiveJournalError('ARCHIVE_INTENT_INVALID', 'previous_summary must be string or null');
   }
@@ -77,16 +81,21 @@ function renderSummary(change, summary, baselineUpdates, noBaselineChangeReason)
   ].join('\n');
 }
 
-function sameOperation(intent, { change, summary, baselineUpdates, noBaselineChangeReason }) {
+function sameOperation(intent, {
+  change, summary, baselineUpdates, noBaselineChangeReason, reconciliationPath, reconciliationDigest,
+}) {
   return intent.change_id === change.id
     && intent.source === change.artifact_root
     && intent.summary === summary.trim()
     && JSON.stringify(intent.baseline_updates) === JSON.stringify(baselineUpdates)
-    && (intent.no_baseline_change_reason || null) === (noBaselineChangeReason || null);
+    && (intent.no_baseline_change_reason || null) === (noBaselineChangeReason || null)
+    && intent.reconciliation_path === reconciliationPath
+    && intent.reconciliation_digest === reconciliationDigest;
 }
 
 function prepareArchiveMove({
-  rootDir, change, summary, baselineUpdates, noBaselineChangeReason, now = new Date(),
+  rootDir, change, summary, baselineUpdates, noBaselineChangeReason,
+  reconciliationPath, reconciliationDigest, reconciliationManifest, now = new Date(),
 }) {
   const date = now.toISOString().slice(0, 10);
   const source = resolveInside(rootDir, change.artifact_root, 'source');
@@ -98,7 +107,7 @@ function prepareArchiveMove({
   if (!fs.existsSync(source) && fs.existsSync(destinationIntentFile)) {
     const resumed = readIntentFile(destinationIntentFile, rootDir);
     if (!sameOperation(resumed.intent, {
-      change, summary, baselineUpdates, noBaselineChangeReason,
+      change, summary, baselineUpdates, noBaselineChangeReason, reconciliationPath, reconciliationDigest,
     })) {
       throw new ArchiveJournalError('ARCHIVE_INTENT_CONFLICT', 'existing archive intent differs from retry input');
     }
@@ -115,7 +124,7 @@ function prepareArchiveMove({
   if (fs.existsSync(sourceIntentFile)) {
     prepared = readIntentFile(sourceIntentFile, rootDir);
     if (!sameOperation(prepared.intent, {
-      change, summary, baselineUpdates, noBaselineChangeReason,
+      change, summary, baselineUpdates, noBaselineChangeReason, reconciliationPath, reconciliationDigest,
     })) {
       throw new ArchiveJournalError('ARCHIVE_INTENT_CONFLICT', 'prepared archive intent differs from retry input');
     }
@@ -130,6 +139,9 @@ function prepareArchiveMove({
       summary: summary.trim(),
       baseline_updates: baselineUpdates,
       no_baseline_change_reason: noBaselineChangeReason || null,
+      reconciliation_path: reconciliationPath,
+      reconciliation_digest: reconciliationDigest,
+      reconciliation_manifest: reconciliationManifest,
       previous_summary: previousSummary,
       created_at: now.toISOString(),
     };