@creativeintelligence/abbie 0.1.0

package/dist/cli/commands/status.js

@@ -0,0 +1,200 @@
+/**
+ * abbie status — config + content sync health overview.
+ *
+ * Reads local sync state + sidecar manifest, reports:
+ * - Last successful sync time
+ * - Per-agent managed keys + drift detection
+ * - Content sync (rules/skills/hooks) status
+ * - Convex reachability
+ * - Pending changes
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { isConvexConfigured } from "@abbie/sdk/convex";
+import { getStoredClerkId } from "@abbie/sdk/config";
+import { getAdapter, getSyncDir } from "../../lib/config-sync/index.js";
+import { getLatestBackup } from "../../lib/config-sync/writer.js";
+import { BaseCommand } from "../base-command.js";
+export default class StatusCommand extends BaseCommand {
+    static summary = "Config sync health overview";
+    static description = `Shows the current state of MCP config sync:
+- Authentication status
+- Last successful sync time
+- Per-agent managed keys and drift detection
+- Backup availability`;
+    static examples = [
+        "$ abbie status",
+        "$ abbie status --json --quiet",
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+    };
+    async execute() {
+        const { flags } = await this.parse(StatusCommand);
+        this.parsedFlags = flags;
+        const syncDir = getSyncDir();
+        const statePath = `${syncDir}/config-sync-state.json`;
+        const manifestPath = `${syncDir}/managed-sections.json`;
+        // Load state
+        let state = {
+            lastHash: "",
+            lastSuccessAt: 0,
+            consecutiveFailures: 0,
+            nextRetryAt: 0,
+        };
+        if (existsSync(statePath)) {
+            try {
+                state = JSON.parse(readFileSync(statePath, "utf-8"));
+            }
+            catch {
+                // ignore
+            }
+        }
+        // Load manifest
+        let manifest = {};
+        if (existsSync(manifestPath)) {
+            try {
+                manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
+            }
+            catch {
+                // ignore
+            }
+        }
+        const authenticated = !!getStoredClerkId();
+        const convexConfigured = isConvexConfigured();
+        // Build per-agent status
+        const AGENTS = ["claude", "codex", "copilot", "gemini", "opencode"];
+        const agents = AGENTS.map((agent) => {
+            const adapter = getAdapter(agent);
+            const manifestEntry = manifest[agent];
+            const configPath = adapter?.configPath() ?? "(unknown)";
+            const configFileExists = adapter?.configExists() ?? false;
+            const managedKeys = manifestEntry?.managedKeys ?? [];
+            const lastAgentSyncAt = manifestEntry?.lastSyncAt ?? null;
+            const hasBackup = !!getLatestBackup(agent);
+            // Drift detection: check if managed keys in the file match manifest
+            let drift = false;
+            if (adapter && configFileExists && managedKeys.length > 0 && agent !== "opencode") {
+                try {
+                    const current = adapter.read();
+                    // For JSON adapters, check if managed keys are present
+                    const mcpServers = current.mcpServers;
+                    if (mcpServers) {
+                        for (const key of managedKeys) {
+                            if (!(key in mcpServers)) {
+                                drift = true;
+                                break;
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // Can't read — count as drift
+                    drift = true;
+                }
+            }
+            return {
+                agent,
+                configPath,
+                configExists: configFileExists,
+                managedKeys,
+                lastSyncAt: lastAgentSyncAt,
+                hasBackup,
+                drift,
+            };
+        });
+        // Load content sync state
+        const contentStatePath = `${syncDir}/content-sync-state.json`;
+        const contentManifestPath = `${syncDir}/content-manifest.json`;
+        let contentState = {
+            lastHash: "",
+            lastSuccessAt: 0,
+            consecutiveFailures: 0,
+            nextRetryAt: 0,
+        };
+        if (existsSync(contentStatePath)) {
+            try {
+                contentState = JSON.parse(readFileSync(contentStatePath, "utf-8"));
+            }
+            catch {
+                // ignore
+            }
+        }
+        let contentManifest = {};
+        if (existsSync(contentManifestPath)) {
+            try {
+                contentManifest = JSON.parse(readFileSync(contentManifestPath, "utf-8"));
+            }
+            catch {
+                // ignore
+            }
+        }
+        const content = {
+            lastSyncAt: contentState.lastSuccessAt || null,
+            consecutiveFailures: contentState.consecutiveFailures,
+            rules: {
+                managed: contentManifest.rules?.managedFiles ?? [],
+                lastSyncAt: contentManifest.rules?.lastSyncAt ?? null,
+            },
+            skills: {
+                managed: contentManifest.skills?.managedDirs ?? [],
+                lastSyncAt: contentManifest.skills?.lastSyncAt ?? null,
+            },
+            hooks: {
+                managed: contentManifest.hooks?.managedFiles ?? [],
+                lastSyncAt: contentManifest.hooks?.lastSyncAt ?? null,
+            },
+        };
+        const result = {
+            authenticated,
+            convexConfigured,
+            lastSyncAt: state.lastSuccessAt || null,
+            consecutiveFailures: state.consecutiveFailures,
+            agents,
+            content,
+        };
+        // Format output
+        const isJson = flags.json || flags.format === "json";
+        if (!isJson) {
+            this.log(`  auth: ${authenticated ? "✓" : "✗ (run abbie login)"}`);
+            this.log(`  convex: ${convexConfigured ? "✓" : "✗ (not configured)"}`);
+            if (state.lastSuccessAt) {
+                const ago = Math.round((Date.now() - state.lastSuccessAt) / 1000);
+                this.log(`  last config sync: ${ago}s ago`);
+            }
+            else {
+                this.log("  last config sync: never");
+            }
+            if (state.consecutiveFailures > 0) {
+                this.log(`  config failures: ${state.consecutiveFailures} consecutive`);
+            }
+            this.log("");
+            this.log("  config sync (MCP connections → agent configs):");
+            for (const a of agents) {
+                const status = a.configExists ? "✓" : "·";
+                const keys = a.managedKeys.length > 0 ? ` [${a.managedKeys.join(", ")}]` : "";
+                const driftMark = a.drift ? " ⚠ drift" : "";
+                const backupMark = a.hasBackup ? "" : " (no backup)";
+                this.log(`    ${status} ${a.agent}: ${a.configPath}${keys}${driftMark}${backupMark}`);
+            }
+            this.log("");
+            this.log("  content sync (Convex → ~/.abbie/ rules/skills/hooks):");
+            if (content.lastSyncAt) {
+                const ago = Math.round((Date.now() - content.lastSyncAt) / 1000);
+                this.log(`    last sync: ${ago}s ago`);
+            }
+            else {
+                this.log("    last sync: never");
+            }
+            if (content.consecutiveFailures > 0) {
+                this.log(`    failures: ${content.consecutiveFailures} consecutive`);
+            }
+            const rulesCount = content.rules.managed.length;
+            const skillsCount = content.skills.managed.length;
+            const hooksCount = content.hooks.managed.length;
+            this.log(`    rules: ${rulesCount} managed${rulesCount > 0 ? ` [${content.rules.managed.join(", ")}]` : ""}`);
+            this.log(`    skills: ${skillsCount} managed${skillsCount > 0 ? ` [${content.skills.managed.join(", ")}]` : ""}`);
+            this.log(`    hooks: ${hooksCount} managed${hooksCount > 0 ? ` [${content.hooks.managed.join(", ")}]` : ""}`);
+        }
+        return result;
+    }
+}

package/dist/cli/commands/sync.d.ts

@@ -0,0 +1,38 @@
+/**
+ * abbie sync — on-demand sync from Convex to local files.
+ *
+ * Syncs both:
+ * 1. MCP connections → local agent config files (claude, codex, copilot, gemini)
+ * 2. Rules/skills/hooks → ~/.abbie/ local files
+ *
+ * Default: dry-run showing planned changes.
+ * --apply: write changes.
+ * --force: skip hash comparison.
+ * --agent: sync specific agent only (config sync only).
+ * --type: sync specific content type only (content sync only).
+ */
+import { type SyncTickResult } from "../../lib/config-sync/index.js";
+import type { ContentSyncTickResult } from "../../lib/content-sync/types.js";
+import { BaseCommand } from "../base-command.js";
+type CombinedSyncResult = {
+    config: SyncTickResult;
+    content: ContentSyncTickResult;
+};
+export default class SyncCommand extends BaseCommand {
+    static summary: string;
+    static description: string;
+    static examples: string[];
+    static flags: {
+        apply: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        agent: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        type: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        format: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "json-errors": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        ndjson: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    execute(): Promise<CombinedSyncResult>;
+}
+export {};
+//# sourceMappingURL=sync.d.ts.map

package/dist/cli/commands/sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/sync.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAKH,OAAO,EAA0C,KAAK,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAE7G,OAAO,KAAK,EAAE,qBAAqB,EAAe,MAAM,iCAAiC,CAAC;AAC1F,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEjD,KAAK,kBAAkB,GAAG;IACxB,MAAM,EAAE,cAAc,CAAC;IACvB,OAAO,EAAE,qBAAqB,CAAC;CAChC,CAAC;AAEF,MAAM,CAAC,OAAO,OAAO,WAAY,SAAQ,WAAW;IAClD,OAAgB,OAAO,SAAyD;IAEhF,OAAgB,WAAW,SASe;IAE1C,OAAgB,QAAQ,WAOtB;IAEF,OAAgB,KAAK;;;;;;;;;MAqBnB;IAEI,OAAO,IAAI,OAAO,CAAC,kBAAkB,CAAC;CAoG7C"}

package/dist/cli/commands/sync.js

@@ -0,0 +1,153 @@
+/**
+ * abbie sync — on-demand sync from Convex to local files.
+ *
+ * Syncs both:
+ * 1. MCP connections → local agent config files (claude, codex, copilot, gemini)
+ * 2. Rules/skills/hooks → ~/.abbie/ local files
+ *
+ * Default: dry-run showing planned changes.
+ * --apply: write changes.
+ * --force: skip hash comparison.
+ * --agent: sync specific agent only (config sync only).
+ * --type: sync specific content type only (content sync only).
+ */
+import { Flags } from "@oclif/core";
+import { api, getHttpClient, isConvexConfigured } from "@abbie/sdk/convex";
+import { getStoredClerkId } from "@abbie/sdk/config";
+import { ConfigSyncRunner } from "../../lib/config-sync/index.js";
+import { ContentSyncRunner } from "../../lib/content-sync/index.js";
+import { BaseCommand } from "../base-command.js";
+export default class SyncCommand extends BaseCommand {
+    static summary = "Sync Convex state to local config and content files";
+    static description = `Syncs two pipelines from Convex to local:
+
+1. Config sync: MCP connections → agent config files
+   (~/.claude/.mcp.json, ~/.codex/config.toml, etc.)
+
+2. Content sync: rules/skills/hooks → ~/.abbie/ files
+   (~/.abbie/rules/*.md, ~/.abbie/skills/*/SKILL.md, ~/.abbie/hooks/*)
+
+Default mode is dry-run — shows what would change without writing.
+Use --apply to actually write the changes.`;
+    static examples = [
+        "$ abbie sync",
+        "$ abbie sync --apply",
+        "$ abbie sync --force --apply",
+        "$ abbie sync --agent claude --apply",
+        "$ abbie sync --type rules --apply",
+        "$ abbie sync --json --quiet",
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        apply: Flags.boolean({
+            description: "Apply changes (default is dry-run)",
+            default: false,
+        }),
+        force: Flags.boolean({
+            char: "f",
+            description: "Skip hash comparison, force re-sync",
+            default: false,
+        }),
+        agent: Flags.string({
+            char: "a",
+            description: "Sync specific agent only (config sync)",
+            options: ["claude", "codex", "copilot", "gemini", "opencode"],
+        }),
+        type: Flags.string({
+            char: "t",
+            description: "Sync specific content type only (content sync)",
+            options: ["rules", "skills", "hooks"],
+        }),
+    };
+    async execute() {
+        const { flags } = await this.parse(SyncCommand);
+        this.parsedFlags = flags;
+        if (!isConvexConfigured()) {
+            this.logWarn("Convex not configured. Run `abbie login` first.");
+            return {
+                config: { ok: false, reason: "convex-not-configured", changes: [] },
+                content: { ok: false, reason: "convex-not-configured", changes: [] },
+            };
+        }
+        const clerkId = getStoredClerkId();
+        if (!clerkId) {
+            this.logWarn("Not authenticated. Run `abbie login` first.");
+            return {
+                config: { ok: false, reason: "not-authenticated", changes: [] },
+                content: { ok: false, reason: "not-authenticated", changes: [] },
+            };
+        }
+        const dryRun = !flags.apply;
+        const agents = flags.agent ? [flags.agent] : undefined;
+        const types = flags.type ? [flags.type] : undefined;
+        // Set up decrypt function using @lnittman/convex-encryption
+        let decryptFn;
+        try {
+            const { decryptIfEncrypted } = await import("@lnittman/convex-encryption");
+            decryptFn = async (v) => {
+                const result = await decryptIfEncrypted(v);
+                return result ?? v;
+            };
+        }
+        catch {
+            // Encryption package not available — pass through
+        }
+        const client = getHttpClient();
+        // Config sync (MCP connections → agent config files)
+        const configRunner = new ConfigSyncRunner({
+            fetchSnapshot: async () => {
+                return await client.query(api.configSync.getSnapshot, { clerkId });
+            },
+            decrypt: decryptFn,
+            agents,
+        });
+        const configResult = await configRunner.tick({ force: flags.force, dryRun });
+        // Content sync (rules/skills/hooks → ~/.abbie/)
+        const contentRunner = new ContentSyncRunner({
+            fetchSnapshot: async () => {
+                return await client.query(api.contentSync.getSnapshot, { clerkId });
+            },
+            types,
+        });
+        const contentResult = await contentRunner.tick({ force: flags.force, dryRun });
+        // Format output
+        const isJson = flags.json || flags.format === "json";
+        if (!isJson) {
+            if (dryRun) {
+                this.logInfo("dry-run (use --apply to write changes)");
+            }
+            // Config sync results
+            this.log("");
+            this.log("  config sync (MCP → agent configs):");
+            if (configResult.reason === "unchanged") {
+                this.log("    no changes");
+            }
+            else {
+                for (const change of configResult.changes) {
+                    const icon = change.action === "error" ? "✗" : change.action === "skipped" ? "·" : "✓";
+                    const added = change.keysAdded.length > 0 ? ` +${change.keysAdded.join(",")}` : "";
+                    const removed = change.keysRemoved.length > 0 ? ` -${change.keysRemoved.join(",")}` : "";
+                    const err = change.error ? ` (${change.error})` : "";
+                    this.log(`    ${icon} ${change.agent}: ${change.action}${added}${removed}${err}`);
+                }
+            }
+            // Content sync results
+            this.log("");
+            this.log("  content sync (Convex → ~/.abbie/):");
+            if (contentResult.reason === "unchanged") {
+                this.log("    no changes");
+            }
+            else if (contentResult.changes.length === 0) {
+                this.log("    no content in Convex");
+            }
+            else {
+                for (const change of contentResult.changes) {
+                    const icon = change.action === "error" ? "✗" : change.action === "unchanged" ? "·" : "✓";
+                    const err = change.error ? ` (${change.error})` : "";
+                    this.log(`    ${icon} ${change.type}/${change.name}: ${change.action}${err}`);
+                }
+            }
+        }
+        return { config: configResult, content: contentResult };
+    }
+}

package/dist/cli/commands/trace/export.d.ts

@@ -0,0 +1,22 @@
+import { BaseCommand } from "../../base-command.js";
+export default class TraceExport extends BaseCommand {
+    static description: string;
+    static hidden: boolean;
+    static examples: string[];
+    static args: {
+        sessionId: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        last: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        output: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        validate: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        format: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "json-errors": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        ndjson: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    protected execute(): Promise<unknown>;
+    private findLastSession;
+    private collectSessionData;
+}
+//# sourceMappingURL=export.d.ts.map

package/dist/cli/commands/trace/export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/trace/export.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAkDpD,MAAM,CAAC,OAAO,OAAO,WAAY,SAAQ,WAAW;IAClD,OAAgB,WAAW,SACkD;IAC7E,OAAgB,MAAM,UAAS;IAE/B,OAAgB,QAAQ,WAKtB;IAEF,OAAgB,IAAI;;MAKlB;IAEF,OAAgB,KAAK;;;;;;;;MAenB;cAEc,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC;YAwD7B,eAAe;YAgBf,kBAAkB;CAqFjC"}

package/dist/cli/commands/trace/export.js

@@ -0,0 +1,212 @@
+import { execSync } from "node:child_process";
+import { writeFileSync } from "node:fs";
+import { Args, Flags } from "@oclif/core";
+import { getActiveSessionManager } from "../../../lib/active-sessions.js";
+import { AgentSessionMiner } from "../../../lib/agent-sessions.js";
+import { mapToAgentTrace, validateAgentTrace, } from "../../../lib/agent-trace.js";
+import { SessionStateManager } from "../../../lib/session-state.js";
+import { BaseCommand } from "../../base-command.js";
+function normalizeTraceUrl(candidate) {
+    if (!candidate) {
+        return undefined;
+    }
+    const normalized = candidate.replace(/\\\//g, "/").replace(/&/gi, "&").trim();
+    if (!normalized) {
+        return undefined;
+    }
+    try {
+        const parsed = new URL(normalized);
+        const isBraintrustHost = parsed.hostname.toLowerCase().includes("braintrust");
+        parsed.pathname = parsed.pathname
+            .replace(/(?:%22|%27|%7d|%7b|%3e|%3c|%29|%5d)+$/i, "")
+            .replace(/\/+$/, "");
+        parsed.hash = "";
+        const traceMatch = parsed.pathname.match(/\/traces?\/([^/?#]+)/i);
+        if (traceMatch?.[1]) {
+            parsed.search = "";
+            parsed.pathname = parsed.pathname.replace(/(\/traces?\/[^/?#]+).*/i, "$1");
+            return parsed.toString();
+        }
+        if (isBraintrustHost && /\/object$/i.test(parsed.pathname)) {
+            const objectType = parsed.searchParams.get("object_type");
+            const objectId = parsed.searchParams.get("object_id");
+            const id = parsed.searchParams.get("id");
+            if (!objectType || !objectId || !id) {
+                return undefined;
+            }
+            const searchParams = new URLSearchParams();
+            searchParams.set("object_type", objectType);
+            searchParams.set("object_id", objectId);
+            searchParams.set("id", id);
+            parsed.search = `?${searchParams.toString()}`;
+            return parsed.toString();
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export default class TraceExport extends BaseCommand {
+    static description = "Export a session as an Agent Trace v0.1 record (interoperability format)";
+    static hidden = false;
+    static examples = [
+        "<%= config.bin %> trace export SESSION_ID",
+        "<%= config.bin %> trace export SESSION_ID --json --quiet",
+        "<%= config.bin %> trace export SESSION_ID --output trace.json",
+        "<%= config.bin %> trace export --last",
+    ];
+    static args = {
+        sessionId: Args.string({
+            description: "Session ID to export (or use --last for most recent)",
+            required: false,
+        }),
+    };
+    static flags = {
+        ...BaseCommand.baseFlags,
+        last: Flags.boolean({
+            description: "Export the most recent session",
+            default: false,
+        }),
+        output: Flags.string({
+            char: "o",
+            description: "Write trace to file instead of stdout",
+        }),
+        validate: Flags.boolean({
+            description: "Validate output against Agent Trace schema",
+            default: true,
+            allowNo: true,
+        }),
+    };
+    async execute() {
+        const { args, flags } = await this.parse(TraceExport);
+        this.parsedFlags = flags;
+        const isJson = flags.json || flags.format === "json";
+        // Resolve session ID
+        let sessionId = args.sessionId;
+        if (flags.last && !sessionId) {
+            sessionId = await this.findLastSession();
+        }
+        if (!sessionId) {
+            this.error("Provide a session ID or use --last");
+        }
+        // Collect session data from all sources
+        const sessionData = await this.collectSessionData(sessionId);
+        if (!sessionData) {
+            this.error(`No session found for: ${sessionId}`);
+        }
+        // Map to Agent Trace
+        const trace = mapToAgentTrace(sessionData);
+        // Validate
+        if (flags.validate) {
+            const errors = validateAgentTrace(trace);
+            if (errors.length > 0) {
+                if (!isJson) {
+                    this.logWarn(`Validation warnings: ${errors.join("; ")}`);
+                }
+            }
+        }
+        // Output
+        const json = JSON.stringify(trace, null, 2);
+        if (flags.output) {
+            writeFileSync(flags.output, json);
+            if (!isJson && !flags.quiet) {
+                this.logInfo(`Wrote Agent Trace to ${flags.output}`);
+            }
+        }
+        if (isJson) {
+            return trace;
+        }
+        if (!flags.output) {
+            this.log(json);
+        }
+        return trace;
+    }
+    async findLastSession() {
+        const manager = getActiveSessionManager();
+        const sessions = await manager.listAsync();
+        // Prefer completed sessions, then any
+        const completed = sessions.filter((s) => s.status === "completed");
+        const target = completed.length > 0 ? completed : sessions;
+        if (target.length === 0)
+            return undefined;
+        // Sort by started_at descending
+        target.sort((a, b) => new Date(b.started_at).getTime() - new Date(a.started_at).getTime());
+        return target[0].session_id;
+    }
+    async collectSessionData(sessionId) {
+        // Source 1: Active sessions (store-first with local fallback)
+        const manager = getActiveSessionManager();
+        const active = await manager.getAsync(sessionId);
+        // Source 2: Session state (SQLite)
+        let sessionState = null;
+        try {
+            const stateManager = new SessionStateManager();
+            sessionState = stateManager.get(sessionId);
+        }
+        catch {
+            // SQLite not available
+        }
+        // Source 3: Mined sessions (agent-specific session files)
+        const miner = new AgentSessionMiner();
+        let mined = null;
+        try {
+            const allMined = miner.mineAll();
+            mined = allMined.find((s) => s.id === sessionId) ?? null;
+        }
+        catch {
+            // Mining failed
+        }
+        // Source 4: Git commits during session window
+        let gitCommits = [];
+        const cwd = active?.cwd || sessionState?.metadata?.cwd;
+        if (cwd) {
+            const startedAt = active?.started_at || sessionState?.started_at;
+            if (startedAt) {
+                try {
+                    const out = execSync(`git log --format=%H --since="${startedAt}" 2>/dev/null`, {
+                        cwd,
+                        encoding: "utf-8",
+                        stdio: ["pipe", "pipe", "pipe"],
+                    }).trim();
+                    if (out)
+                        gitCommits = out.split("\n").map((h) => h.slice(0, 7));
+                }
+                catch {
+                    // Not a git repo
+                }
+            }
+        }
+        // Merge all sources
+        const agent = active?.agent || sessionState?.agent || "unknown";
+        const project = active?.project || sessionState?.project || null;
+        const metadata = sessionState?.metadata;
+        const metadataTraceUrl = (typeof metadata?.traceUrl === "string" ? metadata.traceUrl : undefined) ||
+            (typeof metadata?.trace_url === "string" ? metadata.trace_url : undefined) ||
+            (typeof metadata?.braintrust === "object" &&
+                metadata?.braintrust !== null &&
+                typeof metadata.braintrust.trace_url === "string"
+                ? metadata.braintrust.trace_url
+                : undefined);
+        const traceUrl = normalizeTraceUrl(active?.trace_url || metadataTraceUrl);
+        if (!active && !sessionState) {
+            return null;
+        }
+        return {
+            sessionId,
+            agent,
+            project,
+            status: active?.status || sessionState?.status || "unknown",
+            startedAt: active?.started_at || sessionState?.started_at || new Date().toISOString(),
+            endedAt: sessionState?.ended_at || null,
+            traceId: active?.trace_id || sessionState?.metadata?.trace_id,
+            traceUrl,
+            issue: active?.issue || sessionState?.metadata?.issue,
+            branch: sessionState?.metadata?.git_branch,
+            commits: gitCommits.length > 0 ? gitCommits : mined?.commits,
+            filesModified: mined?.files_modified,
+            model: sessionState?.metadata?.model,
+            cwd,
+        };
+    }
+}

package/dist/cli/commands/triage/claim.d.ts

@@ -0,0 +1,23 @@
+import { BaseCommand } from "../../base-command.js";
+export default class TriageClaim extends BaseCommand {
+    static description: string;
+    static hidden: boolean;
+    static examples: string[];
+    static flags: {
+        "source-workspace": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        "source-team": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        "tracking-workspace": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        "tracking-team": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        agent: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        assignee: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        state: import("@oclif/core/interfaces").OptionFlag<string[], import("@oclif/core/interfaces").CustomOptions>;
+        "dry-run": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        limit: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        format: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "json-errors": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        ndjson: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    protected execute(): Promise<unknown>;
+}
+//# sourceMappingURL=claim.d.ts.map

package/dist/cli/commands/triage/claim.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claim.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/triage/claim.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEpD,MAAM,CAAC,OAAO,OAAO,WAAY,SAAQ,WAAW;IAClD,OAAgB,WAAW,SACqE;IAChG,OAAgB,MAAM,UAAS;IAE/B,OAAgB,QAAQ,WAKtB;IAEF,OAAgB,KAAK;;;;;;;;;;;;;;MA4CnB;cAEc,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC;CA0I5C"}