codehere 0.5.0-alpha.6 → 0.6.0

package/dist/infrastructure/hooks/mirror-tool-call-to-audit.js

@@ -0,0 +1,43 @@
+/**
+ * Cross-vendor tool-call audit mirror — #110 slice 2 (Codex first).
+ *
+ * When non-Claude adapters emit a tool-call event, we can't BLOCK
+ * (no synchronous pre-tool intercept yet) but we CAN mirror the
+ * call into the audit log post-hoc. Closes the audit-trail-parity
+ * gap: every adapter's tool calls land in the same hook-events.jsonl
+ * the per-tool Claude hook writes to.
+ *
+ * Future slices (per-adapter blocking) replace the post-hoc mirror
+ * with pre-call intercepts. For now: visibility today, blocking next.
+ */
+import { scanPayload, calculateRiskScore, appendAuditLog } from './claude-sdk-hook.js';
+export function mirrorToolCallToAudit(rec) {
+    // Run the same pattern bank the per-tool hook uses, so post-hoc
+    // findings show up in /history with the same severity calibration.
+    const findings = scanPayload(rec.toolInput);
+    const riskScore = calculateRiskScore(findings);
+    const truncated = rec.toolInput.length > 500 ? rec.toolInput.slice(0, 500) + '…' : rec.toolInput;
+    const entry = {
+        timestamp: new Date().toISOString(),
+        sessionId: rec.sessionId,
+        toolName: rec.toolName,
+        toolInput: JSON.stringify({
+            agent: rec.agent,
+            input: truncated,
+            cwd: rec.cwd ?? null,
+            inputLength: rec.toolInput.length,
+            mirrored: true, // marks post-hoc vs the synchronous Claude hook
+        }),
+        riskScore,
+        blocked: false, // post-hoc — can't block, only log
+        findings: findings.length,
+        criticalFindings: findings.filter((f) => f.severity === 'critical').length,
+    };
+    try {
+        appendAuditLog(entry);
+    }
+    catch {
+        // Audit-write failures don't propagate — the agent's already running.
+    }
+}
+//# sourceMappingURL=mirror-tool-call-to-audit.js.map

package/dist/infrastructure/hooks/pre-prompt-scan.js

@@ -0,0 +1,122 @@
+/**
+ * Pre-prompt safety scan — cross-vendor parity, task #110.
+ *
+ * The substrate the FAQ landing claims for v0.5.x → v0.6: "per-tool
+ * blocking parity for Codex / Aider / OpenCode / Gemini." Today, only
+ * Claude Code has a per-tool PreToolUse hook. The other 4 adapters
+ * spawn raw — every Bash/Edit they make goes unscanned.
+ *
+ * Closing that gap fully needs per-adapter pre-tool intercepts (huge
+ * scope per-adapter — different IPC + lifecycle for each CLI). This
+ * module ships the FIRST cross-vendor slice: scan the user's PROMPT
+ * before spawn. Catches the prompt-side leaks (API key in prompt,
+ * injection-pattern poisoning, credential paste) for ALL 5 adapters
+ * with one piece of code.
+ *
+ * Posture follows getHookMode():
+ *   block    → high+ severity findings refuse spawn (throw)
+ *   advisory → findings logged + warning event, spawn proceeds
+ *   log-only → findings logged, spawn proceeds, no warning
+ *   off      → no scan, spawn proceeds
+ *
+ * Every scan writes one audit-log entry with synthetic toolName
+ * 'pre_prompt' so the existing /history feed + hash chain pick it up
+ * without surface changes.
+ */
+import { scanPayload, calculateRiskScore, appendAuditLog, } from './claude-sdk-hook.js';
+import { getHookMode } from './hook-mode.js';
+import { filterAllowed } from '../security/permissions-config.js';
+/**
+ * Scan a user prompt before spawn. Always writes one audit-log entry.
+ * Returns allowed=false ONLY when mode === 'block' AND there's a
+ * high-or-critical finding. Other modes always allow but still log.
+ */
+export function scanPromptBeforeSpawn(input) {
+    const rawFindings = scanPayload(input.prompt);
+    // P18 slice 1 — filter against the cwd's permissions.yaml allow-list.
+    // Allow-listed findings are dropped from the BLOCK calculation but
+    // still recorded in the audit-log allowed-list field so a forensic
+    // reviewer can see what was suppressed and why.
+    const { surviving, allowed } = input.cwd
+        ? filterAllowed(rawFindings, input.cwd)
+        : { surviving: rawFindings, allowed: [] };
+    const findings = surviving;
+    const riskScore = calculateRiskScore(findings);
+    const mode = (() => {
+        try {
+            return getHookMode();
+        }
+        catch {
+            return 'off';
+        }
+    })();
+    // Severity gate: only critical/high findings can refuse a spawn.
+    // Medium/low findings get logged but never block — they're flagged
+    // for visibility, not enforcement. Matches the per-tool hook's
+    // existing severity-to-action policy.
+    const hardFindings = findings.filter((f) => f.severity === 'critical' || f.severity === 'high');
+    const wouldBlock = hardFindings.length > 0;
+    const blocked = mode === 'block' && wouldBlock;
+    // Audit entry — written for every scan, regardless of mode. Synthetic
+    // toolName 'pre_prompt' lets /history filter chips group these
+    // separately from per-tool entries (existing chip filters on tool).
+    const entry = {
+        timestamp: new Date().toISOString(),
+        sessionId: input.sessionId,
+        toolName: 'pre_prompt',
+        // Truncate the prompt for the audit record — full prompts can be
+        // 10K+ chars and we don't want the audit log to balloon.
+        toolInput: JSON.stringify({
+            agent: input.agent,
+            prompt: input.prompt.length > 500 ? input.prompt.slice(0, 500) + '…' : input.prompt,
+            cwd: input.cwd ?? null,
+            promptLength: input.prompt.length,
+            // P18 slice 1 — record what got allow-listed for forensic audit.
+            // Empty array when no permissions.yaml exists in the cwd.
+            ...(allowed.length > 0
+                ? {
+                    allowedByPermissions: allowed.map((a) => ({
+                        category: a.finding.category,
+                        matched: a.finding.matched,
+                        reason: a.entry.reason ?? '(no reason given)',
+                    })),
+                }
+                : {}),
+        }),
+        riskScore,
+        blocked,
+        findings: findings.length,
+        criticalFindings: findings.filter((f) => f.severity === 'critical').length,
+        // Mode-driven override marker so the audit reader knows WHY a
+        // would-block finding wasn't enforced. Reuses the existing
+        // OverrideReason 'log_only_mode' for log-only AND advisory + off
+        // (all three skip the block; 'log_only_mode' is the closest
+        // shared semantic — the entry's mode field can be added as a new
+        // OverrideReason later without breaking the audit chain).
+        ...(wouldBlock && !blocked ? { overrideReason: 'log_only_mode' } : {}),
+    };
+    try {
+        appendAuditLog(entry);
+    }
+    catch {
+        // Audit-write failure should NOT itself block a spawn — that would
+        // be a denial-of-service vector (fill the log dir → no spawns).
+        // The audit infra has its own failure-mode logging.
+    }
+    // Compose a block reason from the worst findings. Used by the
+    // session-manager to throw an actionable error.
+    let blockReason = '';
+    if (blocked) {
+        const top = hardFindings.slice(0, 3);
+        const summary = top.map((f) => `[${f.severity}] ${f.description}`).join('; ');
+        blockReason = `pre-prompt scan blocked: ${summary}`;
+    }
+    return {
+        allowed: !blocked,
+        blocked,
+        riskScore,
+        findings,
+        blockReason,
+    };
+}
+//# sourceMappingURL=pre-prompt-scan.js.map

package/dist/infrastructure/orchestration/aider-adapter.js

@@ -17,6 +17,7 @@ import { EventEmitter } from 'events';
 import { randomUUID } from 'crypto';
 import { ProgressAggregator } from './progress-aggregator.js';
 import { applyMemoryPrefix } from './memory-injector.js';
+import { mirrorToolCallToAudit } from '../hooks/mirror-tool-call-to-audit.js';
 import { snapshotCwd, extractArtifacts } from './artifacts-extractor.js';
 const HEADLESS_FLAGS = [
     '--yes-always', // auto-accept all file-edit confirmations
@@ -99,6 +100,32 @@ export function spawnAider(prompt, options = {}) {
         if (event.type === 'stdout' && event.data?.line) {
             const line = String(event.data.line);
             textAccum += line + '\n';
+            // #110 slice 3 — mirror aider tool calls to the audit log. Match
+            // the same stdout patterns the aggregator parses (per
+            // learning_aider.md): "Running <cmd>" → Bash, "Applied edit to
+            // <path>" → Edit, "Creating empty file <path>" → Write.
+            // Strip ANSI as defense-in-depth (HEADLESS_FLAGS already includes
+            // --no-pretty but extraArgs could override).
+            const stripAnsi = (s) => s.replace(/\[[0-9;]*m/g, '');
+            const clean = stripAnsi(line).trim();
+            let toolName = '';
+            let input = '';
+            let mirrorMatch;
+            if ((mirrorMatch = clean.match(/^Running\s+(.+)$/))) {
+                toolName = 'Bash';
+                input = mirrorMatch[1];
+            }
+            else if ((mirrorMatch = clean.match(/^Applied edit to\s+(.+)$/))) {
+                toolName = 'Edit';
+                input = mirrorMatch[1];
+            }
+            else if ((mirrorMatch = clean.match(/^Creating empty file\s+(.+)$/))) {
+                toolName = 'Write';
+                input = mirrorMatch[1];
+            }
+            if (toolName && input) {
+                mirrorToolCallToAudit({ sessionId, agent: 'aider', toolName, toolInput: input, cwd });
+            }
             // Aider emits a cost summary like:
             //   "Tokens: 1.2k sent, 412 received. Cost: $0.01 request, $0.01 session."
             const m = line.match(/Tokens:\s*([\d.]+)([kM]?)\s*sent,\s*([\d.]+)([kM]?)\s*received/i);
@@ -330,6 +357,7 @@ export function spawnAider(prompt, options = {}) {
 export const AiderAdapter = {
     id: 'aider',
     label: 'Aider',
+    description: 'Best when you already know which file to change and what to change in it. Tight, focused edits — no plan-then-explore phase.',
     processPattern: /(?:^|\/)aider(?:\s|$)/,
     isInstalled() {
         try {

package/dist/infrastructure/orchestration/artifacts-extractor.js

@@ -9,11 +9,81 @@
  *
  * Agent-agnostic on purpose. Both Claude and Codex mutate the filesystem;
  * git tells the truth regardless of which tool did the write.
+ *
+ * v0.6.x: dirty-baseline subtraction. Without it, files the user had
+ * uncommitted at spawn time would falsely appear in artifacts even though
+ * the agent never touched them — git diff vs spawn-HEAD includes EVERYTHING
+ * dirty in the working tree, not just what changed during the session.
+ * Now snapshotCwd captures `git status --porcelain` + per-file mtime/size at
+ * spawn time. extractArtifacts filters out files whose stat is unchanged
+ * since spawn — they were dirty before, not by this session. Files that were
+ * dirty at spawn AND further modified during the session still appear.
+ *
+ * Limitation: cannot distinguish concurrent human writes from agent writes
+ * during the session window. True PID-level attribution would require
+ * fanotify/audit subsystem. The dirty-baseline filter eliminates the most
+ * common false-positive (pre-existing uncommitted work) without that.
  */
 import { execFileSync } from 'child_process';
 import { existsSync, readFileSync, statSync } from 'fs';
 import { join, isAbsolute } from 'path';
 import { scoreFile } from '../security/trust-scorer.js';
+/** Capture mtime + size for a single path. Returns null if stat fails. */
+function statBaseline(fullPath) {
+    try {
+        const st = statSync(fullPath);
+        return { mtimeMs: st.mtimeMs, size: st.size };
+    }
+    catch {
+        return null;
+    }
+}
+/** Read `git status --porcelain` and stat every dirty path. Best-effort.
+ *  Paths are git-relative (i.e. relative to repoRoot, not cwd). */
+function captureDirtyBaseline(cwd, repoRoot) {
+    const baseline = new Map();
+    try {
+        const out = execFileSync('git', ['status', '--porcelain', '-z'], {
+            cwd,
+            encoding: 'utf-8',
+            timeout: 5000,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        // Porcelain -z separates entries by NUL. First two chars are status, then space, then path.
+        // Renames have an extra NUL-separated old path which we don't need here.
+        for (const entry of out.split('\0')) {
+            if (!entry)
+                continue;
+            // Strip the 2-char status prefix + 1 separator (3 chars total)
+            const path = entry.slice(3);
+            if (!path)
+                continue;
+            const full = isAbsolute(path) ? path : join(repoRoot, path);
+            const b = statBaseline(full);
+            if (b)
+                baseline.set(path, b);
+        }
+    }
+    catch {
+        /* best-effort — empty baseline means no filtering, status-quo behavior */
+    }
+    return baseline;
+}
+/** Get repo root via `git rev-parse --show-toplevel`. Returns null if not in a repo. */
+function getRepoRoot(cwd) {
+    try {
+        const out = execFileSync('git', ['rev-parse', '--show-toplevel'], {
+            cwd,
+            encoding: 'utf-8',
+            timeout: 2000,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim();
+        return out.length > 0 ? out : null;
+    }
+    catch {
+        return null;
+    }
+}
 /** Take a baseline so Layer 3 can diff against it on exit. Cheap; ~5ms. */
 export function snapshotCwd(cwd) {
     const spawnedAtMs = Date.now();
@@ -24,10 +94,26 @@ export function snapshotCwd(cwd) {
             timeout: 2000,
             stdio: ['ignore', 'pipe', 'ignore'],
         }).trim();
-        return { cwd, head: out, isGitRepo: out.length > 0, spawnedAtMs };
+        const isGitRepo = out.length > 0;
+        const repoRoot = isGitRepo ? (getRepoRoot(cwd) ?? cwd) : cwd;
+        return {
+            cwd,
+            head: out,
+            isGitRepo,
+            spawnedAtMs,
+            repoRoot,
+            dirtyBaseline: isGitRepo ? captureDirtyBaseline(cwd, repoRoot) : new Map(),
+        };
     }
     catch {
-        return { cwd, head: null, isGitRepo: false, spawnedAtMs };
+        return {
+            cwd,
+            head: null,
+            isGitRepo: false,
+            spawnedAtMs,
+            repoRoot: cwd,
+            dirtyBaseline: new Map(),
+        };
     }
 }
 /** Collect {path, +, -} from git diff (numstat) + untracked files (wc -l). */
@@ -69,9 +155,10 @@ function changedFiles(snap) {
         for (const rel of untracked.split('\n')) {
             if (!rel.trim())
                 continue;
-            // Count lines in the new file
+            // Count lines in the new file. Untracked paths come from git relative
+            // to repoRoot — must join with repoRoot, not cwd, when cwd is a subdir.
             try {
-                const full = isAbsolute(rel) ? rel : join(snap.cwd, rel);
+                const full = isAbsolute(rel) ? rel : join(snap.repoRoot, rel);
                 if (!existsSync(full))
                     continue;
                 const size = statSync(full).size;
@@ -125,7 +212,9 @@ function parseTestSummary(stdout) {
 function annotateTrust(snap, files) {
     return files.map((f) => {
         try {
-            const full = isAbsolute(f.path) ? f.path : join(snap.cwd, f.path);
+            // Git-relative path: join with repoRoot, not cwd (matters when cwd is
+            // a subdirectory of the repo).
+            const full = isAbsolute(f.path) ? f.path : join(snap.repoRoot, f.path);
             if (!existsSync(full))
                 return f;
             const size = statSync(full).size;
@@ -154,7 +243,8 @@ function filterByMtime(snap, files) {
     const grace = 1000; // ms; allow clock skew between git's touch and our Date.now()
     return files.filter((f) => {
         try {
-            const full = isAbsolute(f.path) ? f.path : join(snap.cwd, f.path);
+            // Git-relative path: join with repoRoot, not cwd.
+            const full = isAbsolute(f.path) ? f.path : join(snap.repoRoot, f.path);
             if (!existsSync(full))
                 return true; // file was deleted — keep it
             const { mtimeMs } = statSync(full);
@@ -165,10 +255,40 @@ function filterByMtime(snap, files) {
         }
     });
 }
+/**
+ * Drop files that were dirty at spawn time and have NOT been further modified
+ * since. The git-diff-vs-spawn-HEAD path picks up the user's pre-existing
+ * uncommitted changes; without this filter, those files get mis-attributed to
+ * the agent's task. A file is considered "further modified" if its mtime OR
+ * size changed since the spawn snapshot — content-level tampering with same
+ * mtime/size is rare enough to ignore.
+ */
+function filterBySpawnBaseline(snap, files) {
+    if (snap.dirtyBaseline.size === 0)
+        return files;
+    return files.filter((f) => {
+        const baseline = snap.dirtyBaseline.get(f.path);
+        if (!baseline)
+            return true; // wasn't dirty at spawn — definitely a session change
+        try {
+            // Git-relative path: join with repoRoot, not cwd.
+            const full = isAbsolute(f.path) ? f.path : join(snap.repoRoot, f.path);
+            if (!existsSync(full))
+                return true; // deleted during session — that's a change
+            const { mtimeMs, size } = statSync(full);
+            // Further-modified if either mtime advanced or size differs from baseline.
+            return mtimeMs > baseline.mtimeMs || size !== baseline.size;
+        }
+        catch {
+            return true; // stat failed — be permissive (don't drop files we can't verify)
+        }
+    });
+}
 export function extractArtifacts(snap, collectedStdout) {
     const raw = changedFiles(snap);
-    const mine = filterByMtime(snap, raw);
-    const files = annotateTrust(snap, mine);
+    const sessionScoped = filterByMtime(snap, raw);
+    const agentLikely = filterBySpawnBaseline(snap, sessionScoped);
+    const files = annotateTrust(snap, agentLikely);
     const tests = parseTestSummary(collectedStdout);
     return { files, tests };
 }

package/dist/infrastructure/orchestration/claude-code-adapter.js

@@ -407,6 +407,7 @@ export function spawnClaudeCode(prompt, options = {}) {
 export const ClaudeCodeAdapter = {
     id: 'claude-code',
     label: 'Claude Code',
+    description: 'Good default for editing code, running tests, and shell commands. Strongest safety net: codehere can stop risky actions before they run, not just record them after.',
     processPattern: /(?:^|\/)claude(?:\s|$)/,
     isInstalled() {
         try {

package/dist/infrastructure/orchestration/codex-adapter.js

@@ -19,6 +19,7 @@ import { randomUUID } from 'crypto';
 import { ProgressAggregator } from './progress-aggregator.js';
 import { snapshotCwd, extractArtifacts } from './artifacts-extractor.js';
 import { applyMemoryPrefix } from './memory-injector.js';
+import { mirrorToolCallToAudit } from '../hooks/mirror-tool-call-to-audit.js';
 const HEADLESS_FLAGS = [
     'exec',
     '--json',
@@ -103,6 +104,18 @@ export function spawnCodex(prompt, options = {}) {
                 textAccum += item.aggregated_output + '\n';
             if (item?.type === 'agent_message' && item.text)
                 textAccum += item.text + '\n';
+            // #110 slice 2 — mirror tool calls to the audit log so codex
+            // gets the same audit-trail surface as Claude's per-tool hook.
+            // Post-hoc only (no block); pre-tool intercept is a future slice.
+            if (item?.type === 'command_execution' && typeof item.command === 'string' && item.command) {
+                mirrorToolCallToAudit({
+                    sessionId,
+                    agent: 'codex',
+                    toolName: 'Bash',
+                    toolInput: item.command,
+                    cwd,
+                });
+            }
         }
         // Accumulate token usage across all turns (one turn.completed per turn).
         if (event.type === 'turn.completed') {
@@ -358,6 +371,7 @@ export function spawnCodex(prompt, options = {}) {
 export const CodexAdapter = {
     id: 'codex',
     label: 'Codex',
+    description: 'OpenAI\'s coding agent. Good when the task needs reading a lot of code first, then changing several files together.',
     processPattern: /(?:^|\/)codex(?:\s|$)/,
     isInstalled() {
         try {

package/dist/infrastructure/orchestration/context-handoff.js

@@ -0,0 +1,143 @@
+/**
+ * context-handoff — structured cross-session context handoff protocol (P2).
+ *
+ * Bridges P0's auto-failover trigger with P1's graphify-ts context packs.
+ * When a session fails over (or a new session spawns), the handoff loader
+ * finds the most relevant context pack from recent session logs and injects
+ * it as a system hint so the replacement agent inherits continuity.
+ *
+ * Protocol:
+ *   1. loadHandoffContext(cwd, { fromSessionId?, sessionId?, maxAgeMs? })
+ *      — scans .codehere/context-packs.jsonl for the most relevant pack
+ *   2. enrichPromptWithHandoff(prompt, cwd, handoff)
+ *      — merges the handoff context into a prompt string
+ *   3. session handoff is automatic during failover (wired in session-manager)
+ *
+ * Handoff format (injected as system hint):
+ *   [handoff: previous agent=<agent>, completed=<status>, pack=<packId>]
+ *   Previous work summary: <pack.payloadPreview or compiled summary>
+ *   ---
+ *   <original prompt>
+ */
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+// ── Constants ──────────────────────────────────────────────────────────────────
+const CONTEXT_PACKS_DIR = '.codehere';
+const CONTEXT_PACKS_FILE = 'context-packs.jsonl';
+const DEFAULT_MAX_AGE_MS = 24 * 60 * 60 * 1000; // 24 hours
+const DEFAULT_MIN_NODES = 5;
+// ── Session log scanning ───────────────────────────────────────────────────────
+/**
+ * Load all recent context packs from disk, sorted by timestamp (newest first).
+ */
+function loadAllPacks(cwd) {
+    const packsFile = join(cwd, CONTEXT_PACKS_DIR, CONTEXT_PACKS_FILE);
+    if (!existsSync(packsFile)) {
+        return [];
+    }
+    try {
+        const content = readFileSync(packsFile, 'utf-8');
+        const lines = content.split('\n').filter(Boolean);
+        return lines.map((line) => JSON.parse(line)).reverse();
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Find the most relevant handoff context from previous sessions.
+ *
+ * Priority:
+ *   1. Same workspace, same prompt keywords (most recent pack)
+ *   2. Same workspace, any pack (most recent)
+ *   3. Fallback: no handoff
+ */
+export function loadHandoffContext(cwd, { fromSessionId, maxAgeMs = DEFAULT_MAX_AGE_MS, minNodes = DEFAULT_MIN_NODES } = {}) {
+    const now = Date.now();
+    const packs = loadAllPacks(cwd);
+    // Filter by age
+    const recent = packs.filter((p) => {
+        const ts = p.timestamp;
+        return ts && (now - ts) < maxAgeMs;
+    });
+    // Prefer packs with enough graph structure to be useful
+    const structured = recent.filter((p) => {
+        const nodes = p.nodeCount ?? 0;
+        return nodes >= minNodes;
+    });
+    if (structured.length === 0)
+        return null;
+    const last = structured[0];
+    return {
+        packId: String(last.packId ?? ''),
+        agent: String(last.agent ?? 'unknown'),
+        prompt: String(last.prompt ?? ''),
+        status: String(last.status ?? 'unknown'),
+        timestamp: last.timestamp,
+        nodeCount: last.nodeCount,
+        edgeCount: last.edgeCount,
+        task: String(last.task ?? 'explain'),
+        payloadPreview: String(last.payloadPreview ?? ''),
+    };
+}
+// ── Prompt enrichment ──────────────────────────────────────────────────────────
+/**
+ * Inject handoff context into a prompt.
+ *
+ * Returns the enriched prompt string with the handoff as a system hint
+ * prepended before the original prompt. Returns the original prompt
+ * if no handoff is available.
+ */
+export function enrichPromptWithHandoff(prompt, handoff) {
+    if (!handoff)
+        return prompt;
+    const handoffLine = `[handoff: agent=${handoff.agent}, pack=${handoff.packId}, ${handoff.nodeCount} nodes, ${handoff.edgeCount} edges]`;
+    const preview = handoff.payloadPreview ? ` ${handoff.payloadPreview.slice(0, 800)}` : '';
+    return [
+        `[Previous session context — ${handoffLine}]`,
+        `This workspace has recent structural context from a prior session.`,
+        `For details, refer to the knowledge graph at the workspace root.`,
+        `---`,
+        prompt,
+    ].join('\n');
+}
+// ── Failover handoff (P2 integration point) ────────────────────────────────────
+/**
+ * Build a handoff context for a failover target.
+ *
+ * When session A fails and session B auto-spawns as replacement,
+ * this loads the most recent pack from the same workspace and
+ * merges it into the prompt so B has continuity with A's work.
+ */
+export function buildFailoverHandoff(cwd, { failedAgent, failedPrompt }) {
+    // Load most recent pack from workspace
+    const pack = loadHandoffContext(cwd, { maxAgeMs: DEFAULT_MAX_AGE_MS, minNodes: 3 });
+    if (!pack)
+        return null;
+    // Enrich the prompt with the handoff
+    const enrichedPrompt = enrichPromptWithHandoff(failedPrompt, {
+        ...pack,
+        agent: failedAgent,
+        status: 'failed',
+    });
+    return {
+        ...pack,
+        agent: failedAgent,
+        prompt: enrichedPrompt,
+        status: 'failed',
+    };
+}
+// ── Handoff summary (for UI / API) ─────────────────────────────────────────────
+/**
+ * Generate a human-readable handoff summary for the dashboard.
+ */
+export function formatHandoffSummary(handoff) {
+    const ageMs = Date.now() - handoff.timestamp;
+    const ageStr = ageMs < 60_000
+        ? `${Math.round(ageMs / 1000)}s ago`
+        : ageMs < 3600_000
+            ? `${Math.round(ageMs / 60_000)}m ago`
+            : `${Math.round(ageMs / 3600_000)}h ago`;
+    return `Previous session (${handoff.agent}) completed ${ageStr}. ${handoff.nodeCount} nodes, ${handoff.edgeCount} edges in workspace graph.`;
+}
+//# sourceMappingURL=context-handoff.js.map