@creativeintelligence/abbie 0.1.0

package/dist/cli/commands/session/list.js

@@ -0,0 +1,252 @@
+import { spawnSync } from "node:child_process";
+import { getHttpClient, api } from "@abbie/sdk/convex";
+import { Flags } from "@oclif/core";
+import { getActiveSessionManager } from "../../../lib/active-sessions.js";
+import { getDeviceId } from "../../../lib/device.js";
+import { BaseCommand } from "../../base-command.js";
+export default class SessionList extends BaseCommand {
+    static description = "List agent sessions (spawned via session start)";
+    static hidden = false;
+    static examples = [
+        "<%= config.bin %> session list",
+        "<%= config.bin %> session list --running",
+        "<%= config.bin %> session list --active",
+        "<%= config.bin %> session list --project hostagent",
+        "<%= config.bin %> session list --all",
+        "<%= config.bin %> session list --json",
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        project: Flags.string({
+            char: "p",
+            description: "Filter by project",
+        }),
+        running: Flags.boolean({
+            char: "r",
+            description: "Show only running sessions",
+            default: false,
+        }),
+        active: Flags.boolean({
+            description: "Alias for --running (compat with older docs/skills)",
+            default: false,
+        }),
+        completed: Flags.boolean({
+            description: "Show only completed sessions",
+            default: false,
+        }),
+        failed: Flags.boolean({
+            description: "Show only failed sessions",
+            default: false,
+        }),
+        all: Flags.boolean({
+            char: "a",
+            description: "Show all sessions (default shows recent 20)",
+            default: false,
+        }),
+        limit: Flags.integer({
+            char: "n",
+            description: "Maximum sessions to show",
+            default: 20,
+        }),
+    };
+    async execute() {
+        const { flags } = await this.parse(SessionList);
+        this.parsedFlags = flags;
+        // Determine status filter
+        let statusFilter;
+        if (flags.running || flags.active)
+            statusFilter = "running";
+        else if (flags.completed)
+            statusFilter = "completed";
+        else if (flags.failed)
+            statusFilter = "failed";
+        let sessions = [];
+        const deviceId = getDeviceId();
+        const queryLimit = flags.all ? 500 : Math.max(flags.limit, 50);
+        const client = getHttpClient();
+        let storeSessions = [];
+        try {
+            const rawSessions = await client.query(api.sessions.list, { deviceId, limit: queryLimit });
+            storeSessions = rawSessions;
+        }
+        catch (error) {
+            this.logWarn(`Store read failed: ${error.message}`);
+        }
+        const toActiveSession = (s) => {
+            const status = s.status === "spawned" ? "running" : s.status;
+            return {
+                session_id: s.sessionId,
+                agent: s.agent,
+                project: s.project,
+                goal: s.goal ?? "",
+                issue: s.issue ?? undefined,
+                cwd: s.cwd,
+                pid: s.pid ?? 0,
+                started_at: new Date(s.startedAt).toISOString(),
+                status,
+                prompt_path: s.promptPath ?? undefined,
+                output_path: s.outputPath ?? undefined,
+                trace_id: s.traceId ?? undefined,
+                parent_session_id: s.parentSessionId ?? undefined,
+                read_only: s.metadata?.readOnly ?? undefined,
+            };
+        };
+        const applyFilters = (s) => {
+            if (flags.project && s.project !== flags.project)
+                return false;
+            if (statusFilter && s.status !== statusFilter)
+                return false;
+            return true;
+        };
+        sessions = storeSessions
+            .map(toActiveSession)
+            .filter(applyFilters)
+            .sort((a, b) => new Date(b.started_at).getTime() - new Date(a.started_at).getTime());
+        // Detect and mark stale "running" sessions whose process/pane is dead.
+        // Cross-reference local active-sessions JSON which mark-done updates.
+        const manager = getActiveSessionManager();
+        for (const session of sessions) {
+            if (session.status !== "running")
+                continue;
+            // Check if local JSON already has a terminal status (mark-done ran but store wasn't updated)
+            const localSession = manager.get(session.session_id);
+            if (localSession && localSession.status !== "running") {
+                session.status = localSession.status;
+                session.exit_code = localSession.exit_code;
+                try {
+                    await client.mutation(api.sessions.update, {
+                        sessionId: session.session_id,
+                        status: localSession.status === "stopped" ? "stopped" : localSession.status,
+                        endedAt: Date.now(),
+                    });
+                }
+                catch { }
+                continue;
+            }
+            // Process/pane liveness check
+            let dead = false;
+            if (session.pid > 0) {
+                try {
+                    process.kill(session.pid, 0);
+                }
+                catch {
+                    dead = true;
+                }
+            }
+            else if (localSession?.pane_id && localSession.spawn_mode === "terminal") {
+                const result = spawnSync("tmux", ["list-panes", "-t", localSession.pane_id], {
+                    stdio: ["ignore", "ignore", "ignore"],
+                });
+                if (result.status !== 0) {
+                    dead = true;
+                }
+            }
+            else if (localSession && localSession.pid <= 0 && !localSession.pane_id) {
+                // No PID and no pane — cannot verify liveness
+                dead = true;
+            }
+            if (dead) {
+                session.status = "failed";
+                try {
+                    await client.mutation(api.sessions.update, {
+                        sessionId: session.session_id,
+                        status: "failed",
+                        endedAt: Date.now(),
+                    });
+                }
+                catch { }
+                if (localSession && localSession.status === "running") {
+                    localSession.status = "failed";
+                    const { writeFileSync } = await import("node:fs");
+                    const { join } = await import("node:path");
+                    const { homedir } = await import("node:os");
+                    const sessionPath = join(homedir(), ".abbie", "active-sessions", `${session.session_id}.json`);
+                    writeFileSync(sessionPath, JSON.stringify(localSession, null, 2));
+                }
+            }
+        }
+        // Apply limit unless --all
+        if (!flags.all && sessions.length > flags.limit) {
+            sessions = sessions.slice(0, flags.limit);
+        }
+        // JSON output
+        if (flags.json || flags.format === "json") {
+            return sessions;
+        }
+        // NDJSON output
+        if (this.ndjsonEnabled()) {
+            this.outputNdjson(sessions);
+            return sessions;
+        }
+        // Text output
+        if (sessions.length === 0) {
+            this.logInfo("No sessions found");
+            return [];
+        }
+        const total = storeSessions.length;
+        const showing = sessions.length;
+        const limitNote = !flags.all && total > showing ? ` (showing ${showing}/${total}, use --all for more)` : "";
+        this.logInfo(`Sessions${limitNote}:\n`);
+        for (const session of sessions) {
+            const statusIcon = this.getStatusIcon(session.status);
+            const duration = this.getDuration(session);
+            const age = this.getAge(session.started_at);
+            this.log(`${statusIcon} ${session.session_id}`);
+            this.log(`   Agent: ${session.agent}`);
+            this.log(`   Project: ${session.project}`);
+            this.log(`   Goal: ${this.truncate(session.goal, 60)}`);
+            if (session.issue) {
+                this.log(`   Issue: ${session.issue}`);
+            }
+            this.log(`   Status: ${session.status}${session.exit_code !== undefined ? ` (exit ${session.exit_code})` : ""}`);
+            this.log(`   Started: ${age}${duration ? ` (${duration})` : ""}`);
+            this.log(`   PID: ${session.pid}`);
+            this.log("");
+        }
+        return sessions;
+    }
+    getStatusIcon(status) {
+        switch (status) {
+            case "running":
+                return "🟢";
+            case "completed":
+                return "✅";
+            case "failed":
+                return "❌";
+            case "stopped":
+                return "⏹️";
+            default:
+                return "⚪";
+        }
+    }
+    getAge(timestamp) {
+        const ms = Date.now() - new Date(timestamp).getTime();
+        const seconds = Math.floor(ms / 1000);
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+        const days = Math.floor(hours / 24);
+        if (days > 0) {
+            return `${days}d ${hours % 24}h ago`;
+        }
+        if (hours > 0) {
+            return `${hours}h ${minutes % 60}m ago`;
+        }
+        if (minutes > 0) {
+            return `${minutes}m ago`;
+        }
+        return `${seconds}s ago`;
+    }
+    getDuration(session) {
+        if (session.status === "running") {
+            return null;
+        }
+        // Estimate from started_at to now for completed sessions
+        // (we don't have completed_at in the interface, could add later)
+        return null;
+    }
+    truncate(str, maxLength) {
+        if (str.length <= maxLength)
+            return str;
+        return `${str.slice(0, maxLength - 3)}...`;
+    }
+}

package/dist/cli/commands/session/mark-done.d.ts

@@ -0,0 +1,20 @@
+import { BaseCommand } from "../../base-command.js";
+export default class SessionMarkDone extends BaseCommand {
+    static description: string;
+    static hidden: boolean;
+    static args: {
+        sessionId: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        exitCode: import("@oclif/core/interfaces").Arg<number, {
+            max?: number;
+            min?: number;
+        }>;
+    };
+    static flags: {
+        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=mark-done.d.ts.map

package/dist/cli/commands/session/mark-done.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mark-done.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/session/mark-done.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEpD,MAAM,CAAC,OAAO,OAAO,eAAgB,SAAQ,WAAW;IACtD,OAAgB,WAAW,SAAsE;IACjG,OAAgB,MAAM,UAAQ;IAE9B,OAAgB,IAAI;;;;;;MAGlB;IAEF,OAAgB,KAAK;;;;;MAEnB;cAEc,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC;CA2G5C"}

package/dist/cli/commands/session/mark-done.js

@@ -0,0 +1,116 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { getHttpClient, api } from "@abbie/sdk/convex";
+import { Args } from "@oclif/core";
+import { getActiveSessionManager } from "../../../lib/active-sessions.js";
+import { createEvent, EventStore } from "../../../lib/events.js";
+import { SessionArtifactStore } from "../../../lib/session-artifacts.js";
+import { BaseCommand } from "../../base-command.js";
+export default class SessionMarkDone extends BaseCommand {
+    static description = "Mark a terminal-spawned session as done (called by tmux wrapper)";
+    static hidden = true;
+    static args = {
+        sessionId: Args.string({ description: "Session ID", required: true }),
+        exitCode: Args.integer({ description: "Exit code from agent process", required: true }),
+    };
+    static flags = {
+        ...BaseCommand.baseFlags,
+    };
+    async execute() {
+        const { args } = await this.parse(SessionMarkDone);
+        const manager = getActiveSessionManager();
+        const session = manager.get(args.sessionId);
+        if (!session) {
+            this.error(`Session not found: ${args.sessionId}`);
+        }
+        const status = args.exitCode === 0 ? "completed" : "failed";
+        // Try to extract error reason from stderr log (captured via tee in terminal mode)
+        let errorReason;
+        if (status === "failed" && session.output_path) {
+            const stderrPath = session.output_path.replace(/\.json$/, "-stderr.log");
+            if (existsSync(stderrPath)) {
+                try {
+                    const stderr = readFileSync(stderrPath, "utf-8").trim();
+                    // Extract the last meaningful error line (skip empty lines and noise)
+                    const lines = stderr.split("\n").filter((l) => l.trim().length > 0);
+                    const errorLine = lines
+                        .reverse()
+                        .find((l) => l.includes("error") ||
+                        l.includes("Error") ||
+                        l.includes("failed") ||
+                        l.includes("limit") ||
+                        l.includes("429"));
+                    errorReason =
+                        errorLine?.trim().slice(0, 500) || lines.slice(-3).join(" | ").slice(0, 500);
+                }
+                catch {
+                    // Best-effort
+                }
+            }
+        }
+        const updatedSession = {
+            ...session,
+            status: status,
+            exit_code: args.exitCode,
+            ...(errorReason ? { error_reason: errorReason } : {}),
+        };
+        const sessionPath = join(homedir(), ".abbie", "active-sessions", `${args.sessionId}.json`);
+        writeFileSync(sessionPath, JSON.stringify(updatedSession, null, 2));
+        try {
+            const artifacts = new SessionArtifactStore();
+            artifacts.markComplete(args.sessionId, {
+                status: status,
+                exitCode: args.exitCode,
+                outputPath: session.output_path,
+            });
+        }
+        catch {
+            // Best-effort: active session files remain source of truth.
+        }
+        // Log event
+        const eventStore = new EventStore();
+        if (status === "completed") {
+            eventStore.append(createEvent.complete(args.sessionId, session.agent, {
+                summary: "Terminal session completed",
+                artifacts: [],
+                duration_ms: Date.now() - new Date(session.started_at).getTime(),
+            }));
+        }
+        else {
+            eventStore.append({
+                type: "session:failed",
+                session_id: args.sessionId,
+                agent: session.agent,
+                data: {
+                    reason: errorReason || `Exit code ${args.exitCode}`,
+                    exit_code: args.exitCode,
+                },
+            });
+        }
+        // Update the store so session list shows correct status
+        try {
+            const client = getHttpClient();
+            await client.mutation(api.sessions.update, {
+                sessionId: args.sessionId,
+                status,
+                endedAt: Date.now(),
+            });
+        }
+        catch {
+            // Store update is best-effort — local JSON is the source of truth
+        }
+        // Clean up the tmux pane so zombie windows don't linger
+        if (session.pane_id) {
+            spawnSync("tmux", ["kill-pane", "-t", session.pane_id], {
+                stdio: ["ignore", "ignore", "ignore"],
+            });
+        }
+        const isJson = this.parsedFlags?.json || this.parsedFlags?.format === "json";
+        if (!isJson) {
+            this.log(`Session ${args.sessionId} marked as ${status} (exit code: ${args.exitCode})`);
+        }
+        return { session_id: args.sessionId, status, exit_code: args.exitCode };
+    }
+}

package/dist/cli/commands/session/mine.d.ts

@@ -0,0 +1,22 @@
+import { BaseCommand } from "../../base-command.js";
+export default class SessionMine extends BaseCommand {
+    static description: string;
+    static hidden: boolean;
+    static examples: string[];
+    static flags: {
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        agent: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        since: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        issue: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        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>;
+    private parseSince;
+    private getAgentIcon;
+    private getAge;
+}
+//# sourceMappingURL=mine.d.ts.map

package/dist/cli/commands/session/mine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mine.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/session/mine.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEpD,MAAM,CAAC,OAAO,OAAO,WAAY,SAAQ,WAAW;IAClD,OAAgB,WAAW,SAA4D;IACvF,OAAgB,MAAM,UAAS;IAE/B,OAAgB,QAAQ,WAOtB;IAEF,OAAgB,KAAK;;;;;;;;;;MAyBnB;cAEc,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC;IAwE3C,OAAO,CAAC,UAAU;IAqClB,OAAO,CAAC,YAAY;IAepB,OAAO,CAAC,MAAM;CAkBf"}

package/dist/cli/commands/session/mine.js

@@ -0,0 +1,160 @@
+import { Flags } from "@oclif/core";
+import { AgentSessionMiner } from "../../../lib/agent-sessions.js";
+import { AGENTS } from "../../../lib/types.js";
+import { BaseCommand } from "../../base-command.js";
+export default class SessionMine extends BaseCommand {
+    static description = "Mine sessions from all agents (Claude, Codex, Copilot)";
+    static hidden = false;
+    static examples = [
+        "<%= config.bin %> session mine",
+        "<%= config.bin %> session mine --project hostagent",
+        "<%= config.bin %> session mine --agent claude",
+        "<%= config.bin %> session mine --since 24h",
+        "<%= config.bin %> session mine --issue ZO-123",
+        "<%= config.bin %> session mine --json",
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        project: Flags.string({
+            char: "p",
+            description: "Filter by project",
+        }),
+        agent: Flags.string({
+            char: "a",
+            description: "Filter by agent type",
+            options: [...AGENTS],
+        }),
+        since: Flags.string({
+            char: "s",
+            description: "Filter by time (e.g., 24h, 7d, 2024-01-01)",
+            default: "24h",
+        }),
+        issue: Flags.string({
+            char: "i",
+            description: "Filter by issue reference",
+        }),
+        limit: Flags.integer({
+            char: "l",
+            description: "Limit number of results",
+            default: 20,
+        }),
+    };
+    async execute() {
+        const { flags } = await this.parse(SessionMine);
+        this.parsedFlags = flags;
+        const miner = new AgentSessionMiner();
+        const since = this.parseSince(flags.since);
+        let sessions;
+        if (flags.issue) {
+            sessions = miner.getSessionsByIssue(flags.issue);
+        }
+        else {
+            sessions = miner.mineAll({
+                since,
+                project: flags.project,
+            });
+        }
+        // Filter by agent if specified
+        if (flags.agent) {
+            sessions = sessions.filter((s) => s.agent === flags.agent);
+        }
+        // Limit results
+        sessions = sessions.slice(0, flags.limit);
+        if (flags.json || flags.format === "json") {
+            return sessions;
+        }
+        if (sessions.length === 0) {
+            this.logInfo("No sessions found");
+            this.logInfo("\nTip: Try expanding the time range with --since 7d");
+            return [];
+        }
+        this.logInfo(`Found ${sessions.length} session(s):\n`);
+        for (const session of sessions) {
+            const agentIcon = this.getAgentIcon(session.agent);
+            const age = this.getAge(session.last_activity);
+            this.log(`${agentIcon} ${session.id}`);
+            this.log(`   Agent: ${session.agent}`);
+            if (session.project) {
+                this.log(`   Project: ${session.project}`);
+            }
+            if (session.issue) {
+                this.log(`   Issue: ${session.issue}`);
+            }
+            if (session.summary) {
+                this.log(`   Summary: ${session.summary.slice(0, 80)}${session.summary.length > 80 ? "..." : ""}`);
+            }
+            if (session.files_modified && session.files_modified.length > 0) {
+                this.log(`   Files: ${session.files_modified.slice(0, 3).join(", ")}${session.files_modified.length > 3 ? ` +${session.files_modified.length - 3}` : ""}`);
+            }
+            if (session.commits && session.commits.length > 0) {
+                this.log(`   Commits: ${session.commits.slice(0, 3).join(", ")}${session.commits.length > 3 ? ` +${session.commits.length - 3}` : ""}`);
+            }
+            this.log(`   Last activity: ${age}`);
+            this.log("");
+        }
+        return sessions;
+    }
+    parseSince(since) {
+        if (!since)
+            return undefined;
+        // Parse relative time
+        const match = since.match(/^(\d+)([hdwm])$/);
+        if (match) {
+            const value = parseInt(match[1], 10);
+            const unit = match[2];
+            const date = new Date();
+            switch (unit) {
+                case "h":
+                    date.setHours(date.getHours() - value);
+                    break;
+                case "d":
+                    date.setDate(date.getDate() - value);
+                    break;
+                case "w":
+                    date.setDate(date.getDate() - value * 7);
+                    break;
+                case "m":
+                    date.setMonth(date.getMonth() - value);
+                    break;
+            }
+            return date;
+        }
+        // Parse absolute date
+        const parsed = new Date(since);
+        if (!Number.isNaN(parsed.getTime())) {
+            return parsed;
+        }
+        return undefined;
+    }
+    getAgentIcon(agent) {
+        switch (agent) {
+            case "claude":
+                return "🐙";
+            case "codex":
+                return "🦉";
+            case "copilot":
+                return "🐕";
+            case "gemini":
+                return "🦊";
+            default:
+                return "🤖";
+        }
+    }
+    getAge(timestamp) {
+        const ms = Date.now() - new Date(timestamp).getTime();
+        const seconds = Math.floor(ms / 1000);
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+        const days = Math.floor(hours / 24);
+        if (days > 0) {
+            return `${days}d ${hours % 24}h ago`;
+        }
+        if (hours > 0) {
+            return `${hours}h ${minutes % 60}m ago`;
+        }
+        if (minutes > 0) {
+            return `${minutes}m ago`;
+        }
+        return `${seconds}s ago`;
+    }
+}

package/dist/cli/commands/session/replay.d.ts

@@ -0,0 +1,84 @@
+import { BaseCommand } from "../../base-command.js";
+/**
+ * Unified timeline event from any source.
+ */
+interface TimelineEvent {
+    timestamp: string;
+    source: "session_state" | "events" | "reports" | "git" | "active" | "mined";
+    type: string;
+    summary: string;
+    data?: Record<string, unknown>;
+}
+/**
+ * Replay result containing session info and unified timeline.
+ */
+interface ReplayResult {
+    session: {
+        id: string;
+        agent: string;
+        project: string | null;
+        status: string;
+        started_at: string;
+        ended_at: string | null;
+        duration_ms?: number;
+    } | null;
+    timeline: TimelineEvent[];
+    sources: {
+        session_state: boolean;
+        events: number;
+        reports: number;
+        git: number;
+        active: boolean;
+        mined: boolean;
+    };
+    correlations: {
+        issue?: string;
+        branch?: string;
+        commits?: string[];
+        files?: string[];
+    };
+}
+export default class SessionReplay extends BaseCommand {
+    static description: string;
+    static summary: string;
+    static hidden: boolean;
+    static examples: string[];
+    static args: {
+        session_id: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        last: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        agent: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        sources: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        since: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        verbose: 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<ReplayResult>;
+    private findMostRecentSession;
+    private getSessionState;
+    private getEvents;
+    private parseSinceToMs;
+    private getReportEvents;
+    private getGitCommits;
+    private getActiveSession;
+    private getMinedSession;
+    private buildTimeline;
+    private summarizeEvent;
+    private buildCorrelations;
+    private buildSessionSummary;
+    private renderTextOutput;
+    private getStatusIcon;
+    private getAgentIcon;
+    private getSourceIcon;
+    private formatTime;
+    private formatTimeShort;
+    private formatDuration;
+}
+export {};
+//# sourceMappingURL=replay.d.ts.map

package/dist/cli/commands/session/replay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replay.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/session/replay.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEpD;;GAEG;AACH,UAAU,aAAa;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,eAAe,GAAG,QAAQ,GAAG,SAAS,GAAG,KAAK,GAAG,QAAQ,GAAG,OAAO,CAAC;IAC5E,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC;AAED;;GAEG;AACH,UAAU,YAAY;IACpB,OAAO,EAAE;QACP,EAAE,EAAE,MAAM,CAAC;QACX,KAAK,EAAE,MAAM,CAAC;QACd,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;QACvB,MAAM,EAAE,MAAM,CAAC;QACf,UAAU,EAAE,MAAM,CAAC;QACnB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;QACxB,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB,GAAG,IAAI,CAAC;IACT,QAAQ,EAAE,aAAa,EAAE,CAAC;IAC1B,OAAO,EAAE;QACP,aAAa,EAAE,OAAO,CAAC;QACvB,MAAM,EAAE,MAAM,CAAC;QACf,OAAO,EAAE,MAAM,CAAC;QAChB,GAAG,EAAE,MAAM,CAAC;QACZ,MAAM,EAAE,OAAO,CAAC;QAChB,KAAK,EAAE,OAAO,CAAC;KAChB,CAAC;IACF,YAAY,EAAE;QACZ,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;QACnB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;KAClB,CAAC;CACH;AAED,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,WAAW;IACpD,OAAgB,WAAW,SAC8C;IACzE,OAAgB,OAAO,SAA4B;IACnD,OAAgB,MAAM,UAAS;IAE/B,OAAgB,QAAQ,WAQtB;IAEF,OAAgB,IAAI;;MAKlB;IAEF,OAAgB,KAAK;;;;;;;;;;;;MAmCnB;cAEc,OAAO,IAAI,OAAO,CAAC,YAAY,CAAC;YAuFlC,qBAAqB;IAsBnC,OAAO,CAAC,eAAe;IAKvB,OAAO,CAAC,SAAS;IAKjB,OAAO,CAAC,cAAc;YAwBR,eAAe;IAmB7B,OAAO,CAAC,aAAa;YAgCP,gBAAgB;IAK9B,OAAO,CAAC,eAAe;IAYvB,OAAO,CAAC,aAAa;IA+FrB,OAAO,CAAC,cAAc;IAYtB,OAAO,CAAC,iBAAiB;IA8BzB,OAAO,CAAC,mBAAmB;IAwD3B,OAAO,CAAC,gBAAgB;IAiExB,OAAO,CAAC,aAAa;IAgBrB,OAAO,CAAC,YAAY;IAepB,OAAO,CAAC,aAAa;IAmBrB,OAAO,CAAC,UAAU;IAKlB,OAAO,CAAC,eAAe;IASvB,OAAO,CAAC,cAAc;CAavB"}