loadout-ai 0.8.0 → 0.9.1

package/dist/src/core/coordination/quick-start.js

@@ -0,0 +1,200 @@
+/**
+ * One-command coordination setup.
+ *
+ * `loadout coord start --agents claude-code,codex` detects the project
+ * structure, assigns file ownership, and prints a ready-to-go status —
+ * replacing the 6-command manual setup.
+ */
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { claimOwnership, getOwnership, snapshot, } from "./coordinator.js";
+/** Well-known directory groupings. Order matters — first match wins. */
+const SPLIT_PATTERNS = {
+    "backend/frontend": {
+        label: "backend / frontend",
+        groups: [
+            /^(server|backend|api|src\/api|src\/server|src\/backend|app\/api|packages\/api|packages\/server|packages\/backend|lib|services)/,
+            /^(client|frontend|web|app|src\/app|src\/web|src\/client|src\/frontend|src\/components|src\/pages|src\/views|packages\/web|packages\/client|packages\/frontend|components|pages|views|ui)/,
+        ],
+    },
+    "core/tests": {
+        label: "core / tests",
+        groups: [
+            /^(src|lib|app|packages)/,
+            /^(tests|test|__tests__|spec|specs|e2e|cypress)/,
+        ],
+    },
+};
+async function listTopDirs(projectRoot) {
+    const entries = await readdir(projectRoot, { withFileTypes: true });
+    const dirs = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (entry.name.startsWith(".") || entry.name === "node_modules")
+            continue;
+        if (["dist", "build", "out", "coverage", "test-results", ".next"].includes(entry.name))
+            continue;
+        dirs.push(entry.name);
+    }
+    // Also check src/ subdirectories since many projects keep everything under src/
+    try {
+        const srcEntries = await readdir(join(projectRoot, "src"), {
+            withFileTypes: true,
+        });
+        const nested = [];
+        for (const entry of srcEntries) {
+            if (entry.isDirectory() && !entry.name.startsWith(".")) {
+                nested.push(`src/${entry.name}`);
+            }
+        }
+        if (nested.length > 0) {
+            const srcIndex = dirs.indexOf("src");
+            if (srcIndex >= 0)
+                dirs.splice(srcIndex, 1);
+            dirs.push(...nested);
+        }
+    }
+    catch {
+        // No src/ directory — that's fine.
+    }
+    return dirs;
+}
+function collapsePaths(paths) {
+    const sorted = [...new Set(paths)].sort((a, b) => a.split("/").length - b.split("/").length || a.localeCompare(b));
+    return sorted.filter((path, index) => !sorted
+        .slice(0, index)
+        .some((parent) => path === parent || path.startsWith(`${parent}/`)));
+}
+export async function detectSplit(projectRoot, agents, preferredSplit) {
+    if (agents.some((agent) => !agent.trim()) || agents[0] === agents[1])
+        throw new Error("Coordination requires two distinct, non-empty agents");
+    if (preferredSplit && !SPLIT_PATTERNS[preferredSplit])
+        throw new Error(`Unknown split strategy '${preferredSplit}'`);
+    const dirs = await listTopDirs(projectRoot);
+    // Try preferred split first, then all patterns
+    const order = preferredSplit
+        ? [
+            preferredSplit,
+            ...Object.keys(SPLIT_PATTERNS).filter((k) => k !== preferredSplit),
+        ]
+        : Object.keys(SPLIT_PATTERNS);
+    for (const key of order) {
+        const pattern = SPLIT_PATTERNS[key];
+        if (!pattern)
+            continue;
+        const groupA = dirs.filter((d) => pattern.groups[0].test(d));
+        const groupB = dirs.filter((d) => pattern.groups[1].test(d));
+        if (groupA.length > 0 && groupB.length > 0) {
+            const assigned = new Set([...groupA, ...groupB]);
+            return {
+                assignments: new Map([
+                    [agents[0], collapsePaths(groupA)],
+                    [agents[1], collapsePaths(groupB)],
+                ]),
+                unassigned: dirs.filter((d) => !assigned.has(d)),
+                strategy: pattern.label,
+            };
+        }
+    }
+    // Fallback: even split by directory count
+    const sorted = [...dirs].sort();
+    const mid = Math.ceil(sorted.length / 2);
+    return {
+        assignments: new Map([
+            [agents[0], collapsePaths(sorted.slice(0, mid))],
+            [agents[1], collapsePaths(sorted.slice(mid))],
+        ]),
+        unassigned: [],
+        strategy: "even split (no recognized pattern)",
+    };
+}
+export async function quickStart(projectRoot, agents, options = {}) {
+    const split = await detectSplit(projectRoot, agents, options.split);
+    // Check existing ownership
+    const existing = await getOwnership(projectRoot);
+    const existingOwnership = existing.size > 0;
+    let ownershipClaimed = false;
+    if (!options.dryRun && !existingOwnership) {
+        // Claim ownership for each agent
+        for (const [agent, paths] of split.assignments) {
+            if (paths.length === 0)
+                continue;
+            const claimOptions = {
+                agent,
+                paths,
+                mode: "exclusive",
+                reason: `Auto-assigned by coord start (${split.strategy})`,
+            };
+            await claimOwnership(projectRoot, claimOptions);
+        }
+        ownershipClaimed = true;
+    }
+    // Get snapshot summary
+    const snap = await snapshot(projectRoot, agents[1]);
+    const lines = [];
+    if (snap.activeContracts.length > 0) {
+        lines.push(`${snap.activeContracts.length} contract(s): ${snap.activeContracts.map((c) => `${c.name} rev${c.revision}`).join(", ")}`);
+    }
+    if (snap.ownership.length > 0) {
+        lines.push(`${snap.ownership.length} owned path(s)`);
+    }
+    if (snap.unackedForAgent.length > 0) {
+        lines.push(`${snap.unackedForAgent.length} unacknowledged event(s)`);
+    }
+    return {
+        split,
+        ownershipClaimed,
+        existingOwnership,
+        snapshotSummary: lines.join(" · ") || "empty — ready for first events",
+    };
+}
+// ── Terminal formatting ─────────────────────────────────────────────
+export function formatQuickStart(result) {
+    const lines = [];
+    lines.push("\x1b[1m╔══════════════════════════════════════════╗\x1b[0m");
+    lines.push("\x1b[1m║       COORDINATION READY                 ║\x1b[0m");
+    lines.push("\x1b[1m╚══════════════════════════════════════════╝\x1b[0m");
+    lines.push("");
+    lines.push(`  Strategy: \x1b[36m${result.split.strategy}\x1b[0m`);
+    lines.push("");
+    for (const [agent, paths] of result.split.assignments) {
+        const color = agent.includes("claude") ? "\x1b[36m" : "\x1b[33m";
+        lines.push(`  ${color}${agent}\x1b[0m`);
+        for (const p of paths) {
+            lines.push(`    \x1b[90m└─\x1b[0m ${p}/`);
+        }
+        lines.push("");
+    }
+    if (result.split.unassigned.length > 0) {
+        lines.push("  \x1b[90mUnassigned (shared):\x1b[0m");
+        for (const p of result.split.unassigned) {
+            lines.push(`    \x1b[90m└─\x1b[0m ${p}/`);
+        }
+        lines.push("");
+    }
+    if (result.existingOwnership) {
+        lines.push("  \x1b[33m⚠ Existing ownership detected — skipped auto-assignment.\x1b[0m");
+        lines.push("    Run \x1b[90mloadout coord status\x1b[0m to see current ownership.");
+    }
+    else if (result.ownershipClaimed) {
+        lines.push("  \x1b[32m✓ Ownership claimed for both agents.\x1b[0m");
+    }
+    else {
+        lines.push("  \x1b[90mDry run — no ownership claimed. Add --yes to apply.\x1b[0m");
+    }
+    lines.push("");
+    lines.push("\x1b[90m─────────────────────────────────────────────\x1b[0m");
+    lines.push("");
+    lines.push("  \x1b[1mWhat each agent should do now:\x1b[0m");
+    lines.push("");
+    const agentList = [...result.split.assignments.keys()];
+    lines.push(`  1. Open \x1b[36m${agentList[0]}\x1b[0m → it checks its snapshot and starts working`);
+    lines.push(`  2. Open \x1b[33m${agentList[1]}\x1b[0m → it sees the ownership split and builds against contracts`);
+    lines.push("  3. When either creates/changes a shared interface → it publishes a contract");
+    lines.push("  4. The other agent sees the contract on its next snapshot check");
+    lines.push("");
+    lines.push("  The \x1b[90mloadout-handoff\x1b[0m skill handles steps 1-4 automatically.");
+    lines.push("  Just tell each agent what to build — it runs the coord commands for you.");
+    return lines.join("\n");
+}

package/dist/src/core/coordination/redaction.js

@@ -0,0 +1,85 @@
+/**
+ * Redact sensitive data from coordination event payloads.
+ *
+ * Applied on emit, before storage. Patterns match common secret formats
+ * (API keys, tokens, passwords, GitHub PATs, Stripe keys, JWTs, etc.).
+ */
+const REDACTION_MARKER = "[REDACTED]";
+const SENSITIVE_KEY = /^(?:api[_-]?key|access[_-]?token|auth(?:orization)?|bearer|client[_-]?secret|secret|token|password|passwd|pwd|credentials?)$/i;
+const SECRET_PATTERNS = [
+    // Key-value patterns: api_key=..., secret: "...", password='...'
+    /(?:api[_-]?key|apikey|secret|token|password|passwd|pwd|credentials?)\s*[:=]\s*['"]?([^\s'"]{12,})['"]?/gi,
+    // Stripe keys: sk_live_..., pk_test_..., rk_live_...
+    /(?:sk|pk|rk)[-_](?:live|test)[-_][a-zA-Z0-9]{10,}/g,
+    // GitHub PATs
+    /ghp_[a-zA-Z0-9]{36}/g,
+    /github_pat_[a-zA-Z0-9_]{22,}/g,
+    // OpenAI keys
+    /sk-[a-zA-Z0-9]{20,}/g,
+    // Anthropic keys
+    /sk-ant-[a-zA-Z0-9_-]{20,}/g,
+    // AWS keys
+    /AKIA[0-9A-Z]{16}/g,
+    // Bearer tokens
+    /Bearer\s+[a-zA-Z0-9._\-/+=]{20,}/gi,
+    // JWTs (three base64 segments separated by dots)
+    /eyJ[a-zA-Z0-9_-]{10,}\.eyJ[a-zA-Z0-9_-]{10,}\.[a-zA-Z0-9_-]{10,}/g,
+    // Generic long hex/base64 strings that look like secrets (40+ chars)
+    /(?:^|["'\s=:])([a-f0-9]{40,})(?:["'\s]|$)/gm,
+    // .env style: ENV_VAR=value on its own line
+    /^[A-Z][A-Z0-9_]{2,}_(?:KEY|SECRET|TOKEN|PASSWORD|CREDENTIAL)\s*=\s*(.+)$/gm,
+];
+export function redactString(input) {
+    let result = input;
+    for (const pattern of SECRET_PATTERNS) {
+        // Reset lastIndex for stateful regexes
+        pattern.lastIndex = 0;
+        result = result.replace(pattern, (match) => {
+            // Keep the key part, redact the value part
+            const eqIndex = match.search(/[:=]\s*/);
+            if (eqIndex !== -1) {
+                return match.slice(0, eqIndex + 1) + " " + REDACTION_MARKER;
+            }
+            return REDACTION_MARKER;
+        });
+    }
+    return result;
+}
+export function redactPayload(payload) {
+    const result = {};
+    for (const [key, value] of Object.entries(payload)) {
+        if (SENSITIVE_KEY.test(key) && typeof value === "string") {
+            result[key] = REDACTION_MARKER;
+        }
+        else if (typeof value === "string") {
+            result[key] = redactString(value);
+        }
+        else if (value !== null &&
+            typeof value === "object" &&
+            !Array.isArray(value)) {
+            result[key] = redactPayload(value);
+        }
+        else if (Array.isArray(value)) {
+            result[key] = value.map((item) => typeof item === "string"
+                ? redactString(item)
+                : item !== null && typeof item === "object"
+                    ? redactPayload(item)
+                    : item);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+export function redactDescription(description) {
+    return redactString(description);
+}
+export function redactCoordinationInput(input) {
+    return {
+        ...input,
+        description: redactString(input.description),
+        ...(input.context ? { context: redactString(input.context) } : {}),
+        ...(input.payload ? { payload: redactPayload(input.payload) } : {}),
+    };
+}

package/dist/src/core/coordination/replay.js

@@ -0,0 +1,188 @@
+/**
+ * Coordination replay — play back the full coordination timeline as a story.
+ *
+ * `loadout coord replay` reads the JSONL log and presents it as a formatted
+ * narrative timeline with timestamps, agent actions, and state transitions.
+ */
+import { readCoordLog, getContracts, getOwnership } from "./coordinator.js";
+const TYPE_EMOJI = {
+    task: "📋",
+    handoff: "🤝",
+    question: "❓",
+    done: "✅",
+    status: "📊",
+    error: "❌",
+    cancel: "🚫",
+    contract: "📜",
+    ownership: "🔒",
+    decision: "⚖️",
+    update: "📝",
+    ack: "👍",
+    discussion: "💬",
+};
+function eventHeadline(event) {
+    const payload = event.payload;
+    switch (event.type) {
+        case "contract": {
+            const name = payload?.name ?? "unknown";
+            const rev = payload?.revision ?? "?";
+            return `Published contract "${name}" rev${rev}`;
+        }
+        case "ownership": {
+            const paths = payload?.paths ?? [];
+            const mode = payload?.mode ?? "exclusive";
+            return `Claimed ${mode} ownership of ${paths.length} path(s): ${paths.slice(0, 3).join(", ")}${paths.length > 3 ? "..." : ""}`;
+        }
+        case "decision": {
+            const title = payload?.title ?? event.description;
+            return `Decision: ${title}`;
+        }
+        case "update": {
+            const note = payload?.note ?? event.description;
+            const files = payload?.files;
+            const filePart = files ? ` (${files.length} files)` : "";
+            return `${note}${filePart}`;
+        }
+        case "ack": {
+            const ackSeq = payload?.eventSeq ?? "?";
+            return `Acknowledged through seq ${ackSeq}`;
+        }
+        case "discussion": {
+            const threadId = payload?.threadId ?? "unknown";
+            const round = payload?.round ?? "?";
+            const kind = payload?.kind ?? "message";
+            return `Discussion ${threadId} · round ${round} · ${kind}`;
+        }
+        case "task":
+            return `Task: ${event.description}`;
+        case "handoff":
+            return `Handoff to ${event.to}: ${event.description}`;
+        case "done":
+            return `Completed: ${event.description}`;
+        case "error":
+            return `Error: ${event.description}`;
+        default:
+            return event.description;
+    }
+}
+function eventDetail(event) {
+    if (event.type !== "discussion" || !event.payload)
+        return event.context;
+    const payload = event.payload;
+    if (!payload.content)
+        return event.context;
+    return `${payload.content}${payload.replyTo ? ` (reply to ${payload.replyTo})` : ""}`;
+}
+function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    const seconds = Math.floor(ms / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ${seconds % 60}s`;
+    const hours = Math.floor(minutes / 60);
+    return `${hours}h ${minutes % 60}m`;
+}
+function relativeTimestamp(eventTime, startTime) {
+    const ms = eventTime.getTime() - startTime.getTime();
+    return `+${formatDuration(ms)}`;
+}
+/** Max events to include in a replay to prevent memory issues. */
+const MAX_REPLAY_EVENTS = 2000;
+/**
+ * Build the replay timeline from the coordination log.
+ * Bounded to the most recent MAX_REPLAY_EVENTS entries.
+ */
+export async function buildReplay(projectRoot) {
+    const log = await readCoordLog(projectRoot);
+    const contracts = await getContracts(projectRoot);
+    const ownership = await getOwnership(projectRoot);
+    if (log.events.length === 0) {
+        return {
+            entries: [],
+            agents: [],
+            startTime: "",
+            endTime: "",
+            duration: "0s",
+            contractCount: 0,
+            ownershipCount: 0,
+            totalEvents: 0,
+        };
+    }
+    // Bound to recent events
+    const bounded = log.events.length > MAX_REPLAY_EVENTS
+        ? log.events.slice(-MAX_REPLAY_EVENTS)
+        : log.events;
+    const startTime = new Date(bounded[0].timestamp);
+    const endTime = new Date(bounded[bounded.length - 1].timestamp);
+    const agents = [...new Set(bounded.map((e) => e.from))];
+    const entries = bounded.map((event) => ({
+        seq: event.seq,
+        timestamp: event.timestamp,
+        agent: event.from,
+        type: event.type,
+        emoji: TYPE_EMOJI[event.type] ?? "•",
+        headline: eventHeadline(event),
+        detail: eventDetail(event),
+        relativeTime: relativeTimestamp(new Date(event.timestamp), startTime),
+    }));
+    return {
+        entries,
+        agents,
+        startTime: bounded[0].timestamp,
+        endTime: bounded[bounded.length - 1].timestamp,
+        duration: formatDuration(endTime.getTime() - startTime.getTime()),
+        contractCount: contracts.size,
+        ownershipCount: ownership.size,
+        totalEvents: log.events.length,
+    };
+}
+/**
+ * Format replay timeline for terminal display.
+ */
+export function formatReplay(timeline) {
+    if (timeline.entries.length === 0) {
+        return "No coordination events to replay.";
+    }
+    const lines = [];
+    // Header
+    lines.push("\x1b[1m╔══════════════════════════════════════════╗\x1b[0m");
+    lines.push("\x1b[1m║       COORDINATION REPLAY                ║\x1b[0m");
+    lines.push("\x1b[1m╚══════════════════════════════════════════╝\x1b[0m");
+    lines.push("");
+    lines.push(`  Agents: ${timeline.agents.map((a) => `\x1b[36m${a}\x1b[0m`).join(", ")}`);
+    lines.push(`  Duration: ${timeline.duration}`);
+    lines.push(`  Events: ${timeline.totalEvents} · Contracts: ${timeline.contractCount} · Ownership claims: ${timeline.ownershipCount}`);
+    lines.push("");
+    lines.push("\x1b[90m─────────────────────────────────────────────\x1b[0m");
+    lines.push("");
+    // Assign colors to agents
+    const agentColors = ["\x1b[36m", "\x1b[33m", "\x1b[35m", "\x1b[34m"];
+    const colorMap = new Map();
+    timeline.agents.forEach((a, i) => {
+        colorMap.set(a, agentColors[i % agentColors.length]);
+    });
+    // Timeline entries
+    let lastAgent = "";
+    for (const entry of timeline.entries) {
+        const color = colorMap.get(entry.agent) ?? "\x1b[37m";
+        // Agent separator
+        if (entry.agent !== lastAgent) {
+            if (lastAgent)
+                lines.push("");
+            lastAgent = entry.agent;
+        }
+        const timeStr = `\x1b[90m${entry.relativeTime.padStart(8)}\x1b[0m`;
+        const agentStr = `${color}${entry.agent.padEnd(12)}\x1b[0m`;
+        lines.push(`  ${timeStr} ${entry.emoji} ${agentStr} ${entry.headline}`);
+        if (entry.detail) {
+            lines.push(`           \x1b[90m└─ ${entry.detail}\x1b[0m`);
+        }
+    }
+    lines.push("");
+    lines.push("\x1b[90m─────────────────────────────────────────────\x1b[0m");
+    lines.push(`  \x1b[32m✓\x1b[0m Replay complete · ${timeline.totalEvents} events`);
+    return lines.join("\n");
+}

package/dist/src/core/coordination/retention.js

@@ -0,0 +1,180 @@
+/**
+ * Retention and compaction for the coordination log.
+ *
+ * The JSONL audit log is never deleted. Compaction rewrites the working log
+ * with a summary event followed by recent events, keeping the active set
+ * bounded.
+ */
+import { readFile, writeFile, rename, stat, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { assertCoordinationEnabled, readCoordLog } from "./coordinator.js";
+import { withCoordinationLock } from "./lock.js";
+/** Event types whose latest value defines current system state. */
+const STATE_BEARING_TYPES = new Set(["ownership", "contract", "decision"]);
+const COORD_DIR = ".handoff";
+const COORD_LOG = "coordination.jsonl";
+export const DEFAULT_RETENTION = {
+    maxEvents: 10000,
+    maxAgeDays: 30,
+};
+export async function compact(projectRoot, config = DEFAULT_RETENTION) {
+    const dir = join(projectRoot, COORD_DIR);
+    await mkdir(dir, { recursive: true });
+    return withCoordinationLock(dir, async () => {
+        await assertCoordinationEnabled(projectRoot);
+        const log = await readCoordLog(projectRoot);
+        if (!Number.isSafeInteger(config.maxEvents) || config.maxEvents < 1) {
+            throw new Error("maxEvents must be a positive integer");
+        }
+        if (!Number.isFinite(config.maxAgeDays) || config.maxAgeDays < 0) {
+            throw new Error("maxAgeDays must be a non-negative number");
+        }
+        const cutoffDate = new Date();
+        cutoffDate.setDate(cutoffDate.getDate() - config.maxAgeDays);
+        const cutoffIso = cutoffDate.toISOString();
+        const firstFresh = log.events.findIndex((event) => event.timestamp >= cutoffIso);
+        const ageStart = firstFresh === -1 ? log.events.length : firstFresh;
+        const countStart = Math.max(0, log.events.length - config.maxEvents);
+        const keepStart = Math.max(ageStart, countStart);
+        const removable = log.events.slice(0, keepStart);
+        const keptByIndex = log.events.slice(keepStart);
+        // Preserve state-bearing events that would otherwise be lost.
+        const stateCheckpoints = extractStateCheckpoints(removable, keptByIndex);
+        const finalRetained = [...stateCheckpoints, ...keptByIndex];
+        const remove = removable.filter((e) => !stateCheckpoints.includes(e));
+        if (remove.length === 0) {
+            return {
+                before: log.events.length,
+                after: log.events.length,
+                removed: 0,
+                compacted: false,
+            };
+        }
+        // Build summary of what was compacted
+        const agents = new Set();
+        const types = new Map();
+        for (const e of remove) {
+            agents.add(e.from);
+            types.set(e.type, (types.get(e.type) ?? 0) + 1);
+        }
+        const summaryPayload = {
+            compactedCount: remove.length,
+            compactedRange: {
+                from: remove[0].seq,
+                to: remove[remove.length - 1].seq,
+            },
+            agents: [...agents],
+            typeCounts: Object.fromEntries(types),
+            compactedAt: new Date().toISOString(),
+        };
+        const logPath = join(projectRoot, COORD_DIR, COORD_LOG);
+        // Archival is the durability boundary: never rewrite if it fails.
+        const archivePath = `${logPath}.${Date.now()}.archive`;
+        const raw = await readFile(logPath, "utf-8");
+        await writeFile(archivePath, raw, {
+            encoding: "utf-8",
+            flag: "wx",
+            mode: 0o600,
+        });
+        // Write compacted log: summary event + retained events
+        const summaryLine = JSON.stringify({
+            id: `compaction-${Date.now()}`,
+            seq: remove[remove.length - 1].seq,
+            type: "status",
+            from: "loadout",
+            to: "*",
+            description: `Compacted ${remove.length} events (seq ${summaryPayload.compactedRange.from}–${summaryPayload.compactedRange.to})`,
+            timestamp: new Date().toISOString(),
+            payload: summaryPayload,
+        });
+        const lines = [
+            summaryLine,
+            ...finalRetained.map((e) => JSON.stringify(e)),
+        ].join("\n");
+        // Atomic write: write to temp, rename over
+        const tmpPath = `${logPath}.tmp`;
+        await writeFile(tmpPath, lines + "\n", {
+            encoding: "utf-8",
+            mode: 0o600,
+        });
+        await rename(tmpPath, logPath);
+        // Log corrupt lines if any were found
+        if (log.corrupt.length > 0) {
+            const corruptPath = `${logPath}.${Date.now()}.corrupt`;
+            const corruptData = log.corrupt.map((c) => JSON.stringify(c)).join("\n");
+            await writeFile(corruptPath, corruptData + "\n", {
+                encoding: "utf-8",
+                mode: 0o600,
+            }).catch(() => { });
+        }
+        return {
+            before: log.events.length,
+            after: finalRetained.length + 1, // +1 for summary
+            removed: remove.length,
+            compacted: true,
+        };
+    });
+}
+export async function logSize(projectRoot) {
+    const logPath = join(projectRoot, COORD_DIR, COORD_LOG);
+    try {
+        const s = await stat(logPath);
+        const log = await readCoordLog(projectRoot);
+        return { events: log.events.length, bytes: s.size };
+    }
+    catch (error) {
+        if (typeof error === "object" &&
+            error !== null &&
+            "code" in error &&
+            error.code === "ENOENT") {
+            return { events: 0, bytes: 0 };
+        }
+        throw error;
+    }
+}
+/**
+ * Extract the latest state-bearing events from the removable set that are not
+ * already represented in the kept set. Ownership, contracts, and decisions
+ * define current system state — losing them during compaction would silently
+ * drop ownership claims, contract revisions, or active decisions.
+ */
+function extractStateCheckpoints(removable, kept) {
+    const keptKeys = new Set();
+    for (const e of kept) {
+        const key = stateKey(e);
+        if (key)
+            keptKeys.add(key);
+    }
+    // Walk removable in reverse to find the *latest* event per state key.
+    const seen = new Set();
+    const checkpoints = [];
+    for (let i = removable.length - 1; i >= 0; i--) {
+        const e = removable[i];
+        const key = stateKey(e);
+        if (!key)
+            continue;
+        if (keptKeys.has(key) || seen.has(key))
+            continue;
+        seen.add(key);
+        checkpoints.push(e);
+    }
+    // Return in original chronological order.
+    return checkpoints.reverse();
+}
+function stateKey(event) {
+    if (!STATE_BEARING_TYPES.has(event.type) || !event.payload)
+        return undefined;
+    const p = event.payload;
+    switch (event.type) {
+        case "ownership":
+            // Key by agent + sorted paths — an ownership event replaces the previous
+            // one for the same agent/path combination.
+            return `ownership:${event.from}:${(p.paths ?? []).sort().join(",")}`;
+        case "contract":
+            return `contract:${p.name}`;
+        case "decision":
+            return `decision:${p.title}`;
+        default:
+            return undefined;
+    }
+}

package/dist/src/core/coordination/runtime.js

@@ -0,0 +1,21 @@
+/** Composition boundary for optional provider-driven coordination. */
+import { Codex } from "@openai/codex-sdk";
+import { ClaudeCodeAdapter } from "./adapters/claude-code.js";
+import { CodexAdapter } from "./adapters/codex.js";
+/**
+ * Build adapters backed by the provider-supported interfaces shipped with
+ * Loadout: Claude Code print-mode CLI and the OpenAI Codex SDK.
+ */
+export function createProviderAdapters() {
+    const codex = new Codex();
+    const codexDriver = {
+        runtimeVersion: "Codex SDK (bundled)",
+        startThread(options) {
+            return codex.startThread(options);
+        },
+        resumeThread(sessionId, options) {
+            return codex.resumeThread(sessionId, options);
+        },
+    };
+    return [new ClaudeCodeAdapter(), new CodexAdapter(codexDriver)];
+}