loadout-ai 0.7.0 → 0.9.0

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,128 @@
+/**
+ * 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";
+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 remove = log.events.slice(0, keepStart);
+        const finalRetained = log.events.slice(keepStart);
+        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;
+    }
+}

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)];
+}