@creativeintelligence/abbie 0.1.0

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

@@ -0,0 +1,515 @@
+import { existsSync, readFileSync } from "node:fs";
+import { basename } from "node:path";
+import { api, getHttpClient } from "@abbie/sdk/convex";
+import { Flags } from "@oclif/core";
+import { getActiveSessionManager } from "../../../lib/active-sessions.js";
+import { telemetry } from "../../../lib/analytics.js";
+import { loadConfigFromPath } from "../../../lib/config-loader.js";
+import { validateOutputContract } from "../../../lib/contracts.js";
+import { getDeviceId } from "../../../lib/device.js";
+import { readSessionResult } from "../../../lib/session-result.js";
+import { extractProjectFromPath } from "../../../lib/tmux/map.js";
+import { AGENTS } from "../../../lib/types.js";
+import { BaseCommand } from "../../base-command.js";
+function hasExplicitSkillRouting(goal, skills) {
+    if (Array.isArray(skills) && skills.length > 0) {
+        return true;
+    }
+    // Explicit prompt-level invocation examples: "use convex-god skill"
+    if (/\buse\s+[\w/-]+\s+skill\b/i.test(goal)) {
+        return true;
+    }
+    // Skill XML block already present in goal payload.
+    if (/<skill\b[^>]*>[\s\S]*<\/skill>/i.test(goal)) {
+        return true;
+    }
+    // Backwards-compat with earlier wrapper format.
+    if (/<skill_routing>[\s\S]*<\/skill_routing>/i.test(goal)) {
+        return true;
+    }
+    return false;
+}
+const TRACE_URL_KEYS = ["traceUrl", "trace_url", "braintrustTraceUrl", "braintrust_trace_url"];
+const ENCODED_TRAILING_JUNK_RE = /(?:%22|%27|%7d|%7b|%3e|%3c|%29|%5d)+$/i;
+const RAW_TRAILING_JUNK_RE = /[),.;\]}>]+$/;
+const HTML_TRAILING_JUNK_RE = /(?:&quot;|&#34;|&#39;|&gt;|&lt;)+$/i;
+const TRAILING_SLASH_RE = /\/+$/;
+const TRACE_PATH_RE = /\/traces?\//i;
+const TRACE_ID_PATH_RE = /\/traces?\/([^/?#]+)/i;
+const TRACE_CANONICAL_PATH_RE = /(\/traces?\/[^/?#]+).*/i;
+const BRAINTRUST_OBJECT_PATH_RE = /\/object$/i;
+function trimTrailingJunk(value) {
+    let next = value.trim();
+    while (true) {
+        const trimmed = next
+            .replace(ENCODED_TRAILING_JUNK_RE, "")
+            .replace(HTML_TRAILING_JUNK_RE, "")
+            .replace(RAW_TRAILING_JUNK_RE, "");
+        if (trimmed === next) {
+            return trimmed;
+        }
+        next = trimmed;
+    }
+}
+function normalizeTraceUrl(candidate) {
+    const unescaped = candidate.replace(/\\\//g, "/").replace(/&amp;/gi, "&");
+    const trimmed = trimTrailingJunk(unescaped);
+    if (!trimmed) {
+        return undefined;
+    }
+    try {
+        const parsed = new URL(trimmed);
+        const hostname = parsed.hostname.toLowerCase();
+        const isBraintrustHost = hostname.includes("braintrust");
+        parsed.pathname = trimTrailingJunk(parsed.pathname).replace(TRAILING_SLASH_RE, "");
+        parsed.hash = "";
+        const traceMatch = parsed.pathname.match(TRACE_ID_PATH_RE);
+        if (!traceMatch?.[1]) {
+            if (isBraintrustHost && BRAINTRUST_OBJECT_PATH_RE.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;
+        }
+        if (!isBraintrustHost && !TRACE_PATH_RE.test(parsed.pathname)) {
+            return undefined;
+        }
+        parsed.search = "";
+        const canonicalPath = parsed.pathname.replace(TRACE_CANONICAL_PATH_RE, "$1");
+        parsed.pathname = canonicalPath;
+        return parsed.toString();
+    }
+    catch {
+        return undefined;
+    }
+}
+function extractUrlFromText(text) {
+    const haystack = text.replace(/\\\//g, "/");
+    // Some agents wrap long URLs across lines (e.g. ".../app\n  /test/traces/...").
+    // Fold any whitespace that appears between URL path separators.
+    let folded = haystack;
+    while (true) {
+        const next = folded.replace(/(https?:\/\/[^\s<>"')\]]+)\s+\/(?=[^<>\s])/gi, "$1/");
+        if (next === folded) {
+            break;
+        }
+        folded = next;
+    }
+    const matches = folded.match(/https?:\/\/[^\s<>"')\]]+/gi);
+    if (!matches) {
+        return undefined;
+    }
+    for (const match of matches) {
+        const normalized = normalizeTraceUrl(match);
+        if (normalized) {
+            return normalized;
+        }
+    }
+    return undefined;
+}
+function extractTraceUrl(value) {
+    const queue = [value];
+    const seen = new Set();
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (current === null || current === undefined) {
+            continue;
+        }
+        if (typeof current === "string") {
+            const traceUrl = extractUrlFromText(current);
+            if (traceUrl) {
+                return traceUrl;
+            }
+            continue;
+        }
+        if (typeof current !== "object") {
+            continue;
+        }
+        if (seen.has(current)) {
+            continue;
+        }
+        seen.add(current);
+        if (Array.isArray(current)) {
+            for (const item of current) {
+                queue.push(item);
+            }
+            continue;
+        }
+        const record = current;
+        for (const key of TRACE_URL_KEYS) {
+            const candidate = record[key];
+            if (typeof candidate !== "string") {
+                continue;
+            }
+            const traceUrl = extractUrlFromText(candidate);
+            if (traceUrl) {
+                return traceUrl;
+            }
+        }
+        for (const value of Object.values(record)) {
+            queue.push(value);
+        }
+    }
+    return undefined;
+}
+export default class SessionStart extends BaseCommand {
+    static description = "Start and spawn a new agent session";
+    static hidden = false;
+    static examples = [
+        '<%= config.bin %> session start --agent claude --project hostagent --goal "Implement ARBOR-123"',
+        '<%= config.bin %> session start --agent codex --project yuba --goal "Fix auth bug" --issue YUBA-42',
+        '<%= config.bin %> session start -a copilot -p arbor -g "Add unit tests" --json',
+        '<%= config.bin %> session start --explore -p arbor -g "map auth flow" --json',
+        "cat prompt.md | <%= config.bin %> session start --agent claude --project arbor",
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        agent: Flags.string({
+            char: "a",
+            description: "Agent type to spawn",
+            required: false,
+            options: [...AGENTS],
+        }),
+        explore: Flags.boolean({
+            description: "Explore mode - routes to Gemini and forces read-only",
+            default: false,
+        }),
+        project: Flags.string({
+            char: "p",
+            description: "Project name",
+            required: false,
+        }),
+        goal: Flags.string({
+            char: "g",
+            description: "Goal/task for the agent (can also be provided via stdin)",
+        }),
+        model: Flags.string({
+            char: "m",
+            description: "Model to use (overrides agent default)",
+        }),
+        issue: Flags.string({
+            char: "i",
+            description: "Linear issue reference (e.g., ARBOR-123)",
+        }),
+        parent: Flags.string({
+            description: "Parent session ID (for sub-session tracking)",
+        }),
+        reuse: Flags.string({
+            description: "Comma-separated prior session IDs to include as prompt context",
+        }),
+        "reuse-parent": Flags.boolean({
+            description: "Include the parent session artifact in prompt context",
+            default: false,
+        }),
+        "reinject-mode": Flags.string({
+            description: "How much prior session context to inject: off, summary, or full",
+            options: ["off", "summary", "full"],
+            default: "summary",
+        }),
+        cwd: Flags.string({
+            description: "Working directory for the agent",
+        }),
+        "prompt-file": Flags.string({
+            description: "Path to prompt file (instead of --goal)",
+        }),
+        "read-only": Flags.boolean({
+            char: "r",
+            description: "Read-only mode - inject contract forbidding writes",
+            default: false,
+        }),
+        "trace-id": Flags.string({
+            description: "Explicit trace ID for event correlation (defaults to AGENTS_TRACE_ID or generates new)",
+        }),
+        await: Flags.boolean({
+            description: "Wait for session to complete and return output",
+            default: false,
+        }),
+        headless: Flags.boolean({
+            description: "Run as headless subprocess (no terminal window). Default is terminal mode.",
+            default: false,
+        }),
+        "tmux-session": Flags.string({
+            description: 'Tmux session name for terminal mode (default: "abbie"). Prevents hijacking your personal tmux.',
+        }),
+        "auto-context": Flags.boolean({
+            description: "Inject recent file_activity from prior sessions as context (default: true)",
+            default: true,
+            allowNo: true,
+        }),
+        skills: Flags.string({
+            char: "s",
+            description: "Skill(s) to route the agent toward (repeatable, e.g. -s loop -s convex-god)",
+            multiple: true,
+        }),
+    };
+    /**
+     * Start an agent session.
+     *
+     * Supports goal via:
+     * - `--goal`
+     * - stdin (piped prompt)
+     * - both (combined as: `<goal>\n\n<stdin>`)
+     *
+     * With `--await`, blocks until completion and returns `{ session, await: { status, output } }`.
+     */
+    async execute() {
+        const { flags } = await this.parse(SessionStart);
+        this.parsedFlags = flags;
+        const manager = getActiveSessionManager();
+        // Get goal from flag, stdin, or both (combined)
+        // Skills often pipe a prompt AND pass -g for the task label
+        let goal = flags.goal || "";
+        const stdin = await this.readStdin();
+        if (stdin) {
+            // If both stdin and --goal provided, combine them
+            // This supports the skill pattern: cat prompt.md | abbie session start -g "task label"
+            if (goal) {
+                goal = `${goal}\n\n${stdin}`;
+            }
+            else {
+                goal = stdin;
+            }
+        }
+        if (!goal && !flags["prompt-file"]) {
+            this.error("Goal is required. Provide via --goal, stdin, or --prompt-file");
+        }
+        if (flags["reuse-parent"] && !flags.parent) {
+            this.error("--reuse-parent requires --parent");
+        }
+        const resolvedAgent = flags.explore ? "gemini" : flags.agent;
+        if (!resolvedAgent) {
+            this.error("Agent is required. Provide via --agent or use --explore");
+        }
+        // Explore mode is always read-only.
+        const resolvedReadOnly = flags["read-only"] || flags.explore;
+        const explicitSkillRouting = hasExplicitSkillRouting(goal, flags.skills);
+        if (!explicitSkillRouting) {
+            this.logWarn("Spawning without explicit skill routing. Recommended: pass -s <skill> or include `use <skill> skill` in the goal.");
+            telemetry.trackSession("skill-routing-missing", {
+                agent: resolvedAgent,
+                mode: resolvedReadOnly ? "read-only" : "full",
+            });
+        }
+        const resolvedCwd = flags.cwd ?? process.cwd();
+        // Infer project name if not explicitly provided.
+        // - Prefer .abbie/config.json "name" from nearest ancestor of cwd.
+        // - Otherwise, map to Luke's canonical directory structure:
+        //   ~/Developer/apps/{project}/... or ~/Developer/utils/{project}/...
+        // - Fallback: basename(cwd)
+        const resolvedProject = flags.project ||
+            (() => {
+                try {
+                    const loaded = loadConfigFromPath(resolvedCwd);
+                    if (loaded?.config?.name)
+                        return loaded.config.name;
+                }
+                catch {
+                    // ignore
+                }
+                return extractProjectFromPath(resolvedCwd) || basename(resolvedCwd) || "unknown";
+            })();
+        const reuseSessionIds = [
+            ...(flags.reuse?.split(",") ?? []),
+            ...(flags["reuse-parent"] && flags.parent ? [flags.parent] : []),
+        ]
+            .map((id) => id.trim())
+            .filter((id) => id.length > 0)
+            .filter((id, index, all) => all.indexOf(id) === index);
+        const requestedReinjectMode = flags["reinject-mode"];
+        const reinjectMode = reuseSessionIds.length === 0 ? "off" : requestedReinjectMode;
+        const result = await manager.start({
+            agent: resolvedAgent,
+            project: resolvedProject,
+            goal: goal || "",
+            issue: flags.issue,
+            parentSessionId: flags.parent,
+            reuseSessionIds,
+            reinjectMode,
+            cwd: resolvedCwd,
+            promptFile: flags["prompt-file"],
+            readOnly: resolvedReadOnly,
+            traceId: flags["trace-id"],
+            model: flags.model,
+            awaitCompletion: flags.await, // Use runner foreground mode for --await
+            headless: flags.headless,
+            tmuxSession: flags["tmux-session"], // Defaults to "abbie" if not specified
+            autoContext: flags["auto-context"],
+            skills: flags.skills,
+        });
+        if (result.status === "failed") {
+            telemetry.trackSession("blocked", {
+                agent: resolvedAgent,
+                blocker_type: "spawn_failed",
+            });
+            this.error(`Failed to start session: ${result.error}`);
+        }
+        // Track successful session spawn
+        telemetry.trackSession("started", {
+            agent: resolvedAgent,
+            mode: resolvedReadOnly ? "read-only" : "full",
+        });
+        // Best-effort: also write session record to the shared store (local JSON remains source of truth/fallback)
+        try {
+            const client = getHttpClient();
+            const session = manager.get(result.session_id);
+            await client.mutation(api.sessions.create, {
+                sessionId: result.session_id,
+                agent: resolvedAgent,
+                project: resolvedProject,
+                goal: goal || undefined,
+                issue: flags.issue,
+                status: session?.status ?? "running",
+                pid: result.pid || undefined,
+                cwd: session?.cwd ?? resolvedCwd,
+                deviceId: getDeviceId(),
+                parentSessionId: flags.parent,
+                traceId: result.trace_id,
+                promptPath: result.prompt_path,
+                outputPath: result.output_path,
+                metadata: {
+                    readOnly: resolvedReadOnly,
+                    reuseSessionIds,
+                    reinjectMode,
+                    resultPath: result.result_path,
+                },
+            });
+            // If --await completed the session already, also persist an endedAt timestamp.
+            if (session && session.status !== "running") {
+                await client.mutation(api.sessions.update, {
+                    sessionId: result.session_id,
+                    status: session.status,
+                    endedAt: Date.now(),
+                });
+            }
+        }
+        catch (error) {
+            this.logWarn(`Store write failed (continuing with local session files): ${error.message}`);
+        }
+        const isJson = flags.json || flags.format === "json";
+        if (!isJson) {
+            this.log(`Session started: ${result.session_id}`);
+            this.log(`Agent: ${resolvedAgent}`);
+            this.log(`PID: ${result.pid}`);
+            this.log(`Trace ID: ${result.trace_id}`);
+            if (result.read_only) {
+                this.log(`Mode: READ-ONLY`);
+            }
+            if (reuseSessionIds.length > 0 && reinjectMode !== "off") {
+                this.log(`Reinject: ${reinjectMode}`);
+                this.log(`Reuse sessions: ${reuseSessionIds.join(", ")}`);
+            }
+            this.log(`Prompt: ${result.prompt_path}`);
+            this.log(`Output: ${result.output_path}`);
+            this.log(`Result: ${result.result_path}`);
+            this.log("");
+            this.log(`Attach with: abbie session attach ${result.session_id}`);
+            this.log(`Stop with: abbie session stop ${result.session_id}`);
+        }
+        if (flags.await) {
+            // When awaitCompletion is true, manager.start() already blocked until completion.
+            // Read canonical result envelope (with legacy fallback for older sessions).
+            const session = manager.get(result.session_id);
+            const resultPath = session?.result_path || result.result_path;
+            const outputPath = session?.output_path || result.output_path;
+            let output;
+            let awaitStatus = "failed";
+            const sessionResult = resultPath ? readSessionResult(resultPath) : null;
+            if (sessionResult) {
+                output = sessionResult;
+                awaitStatus = sessionResult.status;
+            }
+            if (!sessionResult && session) {
+                if (session.status === "completed") {
+                    awaitStatus = "completed";
+                }
+                else if (session.status === "stopped") {
+                    awaitStatus = "stopped";
+                }
+                else {
+                    awaitStatus = "failed";
+                }
+            }
+            if (!sessionResult && outputPath && existsSync(outputPath)) {
+                const raw = readFileSync(outputPath, "utf-8").trim();
+                if (raw) {
+                    try {
+                        output = JSON.parse(raw);
+                    }
+                    catch {
+                        output = raw;
+                    }
+                }
+            }
+            // Validate output against contract schema (warn on invalid, don't block)
+            let contractValidation;
+            const contractCandidate = typeof output === "object" &&
+                output !== null &&
+                "output" in output &&
+                typeof output.output === "object" &&
+                output.output?.parsed !== undefined
+                ? output.output.parsed
+                : output;
+            if (typeof contractCandidate === "object" && contractCandidate !== null) {
+                const validation = validateOutputContract(contractCandidate);
+                contractValidation = { valid: validation.valid, errors: validation.errors };
+                if (!validation.valid && !isJson) {
+                    this.logWarn(`Output contract validation: ${validation.errors.join(", ")}`);
+                }
+            }
+            const sessionTraceUrl = normalizeTraceUrl(session?.trace_url ?? "");
+            const extractedTraceUrl = extractTraceUrl(contractCandidate) ?? extractTraceUrl(output);
+            const traceUrlToPersist = sessionTraceUrl ?? extractedTraceUrl;
+            if (traceUrlToPersist) {
+                try {
+                    const client = getHttpClient();
+                    await client.mutation(api.sessions.update, {
+                        sessionId: result.session_id,
+                        traceUrl: traceUrlToPersist,
+                        metadata: {
+                            trace_url: traceUrlToPersist,
+                            traceUrl: traceUrlToPersist,
+                            traceUrlSource: sessionTraceUrl ? "runner" : "output",
+                        },
+                    });
+                }
+                catch (error) {
+                    if (!isJson) {
+                        this.logWarn(`Failed to persist trace URL: ${error.message}`);
+                    }
+                }
+            }
+            const awaitResult = { status: awaitStatus, output, contractValidation };
+            const combined = { session: result, await: awaitResult };
+            if (isJson) {
+                return combined;
+            }
+            if (awaitResult.status === "stopped") {
+                this.logInfo(`Session ${result.session_id} was stopped`);
+            }
+            else if (awaitResult.status === "failed") {
+                this.logInfo(`Session ${result.session_id} failed`);
+            }
+            if (typeof awaitResult.output === "string") {
+                this.log(awaitResult.output);
+            }
+            else if (awaitResult.output !== undefined) {
+                this.log(JSON.stringify(awaitResult.output, null, 2));
+            }
+            return combined;
+        }
+        if (isJson) {
+            return result;
+        }
+        return result;
+    }
+}

package/dist/cli/commands/session/state/cleanup.d.ts

@@ -0,0 +1,16 @@
+import { BaseCommand } from "../../../base-command.js";
+export default class SessionStateCleanup extends BaseCommand {
+    static description: string;
+    static hidden: boolean;
+    static examples: string[];
+    static flags: {
+        "older-than": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        "dry-run": 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>;
+}
+//# sourceMappingURL=cleanup.d.ts.map

package/dist/cli/commands/session/state/cleanup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cleanup.d.ts","sourceRoot":"","sources":["../../../../../src/cli/commands/session/state/cleanup.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAEvD,MAAM,CAAC,OAAO,OAAO,mBAAoB,SAAQ,WAAW;IAC1D,OAAgB,WAAW,SAAmD;IAC9E,OAAgB,MAAM,UAAS;IAE/B,OAAgB,QAAQ,WAGtB;IAEF,OAAgB,KAAK;;;;;;;MAUnB;cAEc,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC;CAmC5C"}

package/dist/cli/commands/session/state/cleanup.js

@@ -0,0 +1,49 @@
+import { Flags } from "@oclif/core";
+import { SessionStateManager } from "../../../../lib/session-state.js";
+import { BaseCommand } from "../../../base-command.js";
+export default class SessionStateCleanup extends BaseCommand {
+    static description = "Clean up zombie and old session state records";
+    static hidden = false;
+    static examples = [
+        "<%= config.bin %> session state cleanup --older-than 7d --json",
+        "<%= config.bin %> session state cleanup --older-than 30d --dry-run --json",
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        "older-than": Flags.string({
+            description: "Delete ended sessions older than this duration (e.g., 7d, 12h, 30m)",
+            default: "7d",
+        }),
+        "dry-run": Flags.boolean({
+            description: "Show what would be changed without modifying the database",
+            default: false,
+        }),
+    };
+    async execute() {
+        const { flags } = await this.parse(SessionStateCleanup);
+        this.parsedFlags = flags;
+        const manager = new SessionStateManager();
+        const result = manager.cleanup({
+            olderThan: flags["older-than"],
+            dryRun: flags["dry-run"],
+        });
+        if (flags.json || flags.format === "json") {
+            return result;
+        }
+        const verb = result.dry_run ? "Would clean" : "Cleaned";
+        this.logInfo(`${verb} session state: ${result.zombies.length} zombies, ${result.deleted.length} deleted`);
+        if (result.zombies.length > 0) {
+            this.logInfo("\nZombies:");
+            for (const s of result.zombies) {
+                this.logInfo(`- ${s.session_id} (pid ${s.pid ?? "?"})`);
+            }
+        }
+        if (result.deleted.length > 0) {
+            this.logInfo("\nDeleted:");
+            for (const d of result.deleted) {
+                this.logInfo(`- ${d.session_id} (ended_at ${d.ended_at ?? "?"})`);
+            }
+        }
+        return result;
+    }
+}

package/dist/cli/commands/session/state/end.d.ts

@@ -0,0 +1,16 @@
+import { BaseCommand } from "../../../base-command.js";
+export default class SessionStateEnd extends BaseCommand {
+    static description: string;
+    static hidden: boolean;
+    static examples: string[];
+    static flags: {
+        session: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        status: 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>;
+    };
+    protected execute(): Promise<unknown>;
+}
+//# sourceMappingURL=end.d.ts.map

package/dist/cli/commands/session/state/end.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"end.d.ts","sourceRoot":"","sources":["../../../../../src/cli/commands/session/state/end.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAEvD,MAAM,CAAC,OAAO,OAAO,eAAgB,SAAQ,WAAW;IACtD,OAAgB,WAAW,SAAgC;IAC3D,OAAgB,MAAM,UAAS;IAE/B,OAAgB,QAAQ,WAGtB;IAEF,OAAgB,KAAK;;;;;;;MAUnB;cAEc,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC;CAqB5C"}

package/dist/cli/commands/session/state/end.js

@@ -0,0 +1,39 @@
+import { Flags } from "@oclif/core";
+import { SessionStateManager } from "../../../../lib/session-state.js";
+import { BaseCommand } from "../../../base-command.js";
+export default class SessionStateEnd extends BaseCommand {
+    static description = "End a session state record";
+    static hidden = false;
+    static examples = [
+        "<%= config.bin %> session state end --session test-123 --status completed --json",
+        "<%= config.bin %> session state end --session test-123 --status failed --json",
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        session: Flags.string({
+            description: "Session ID",
+            required: true,
+        }),
+        status: Flags.string({
+            description: "End status",
+            options: ["completed", "failed", "stopped"],
+        }),
+    };
+    async execute() {
+        const { flags } = await this.parse(SessionStateEnd);
+        this.parsedFlags = flags;
+        const manager = new SessionStateManager();
+        const record = manager.end({
+            sessionId: flags.session,
+            status: flags.status ?? "completed",
+        });
+        if (!record) {
+            this.error(`Session not found: ${flags.session}`);
+        }
+        if (flags.json || flags.format === "json") {
+            return record;
+        }
+        this.logInfo(`Ended session: ${record.session_id} (${record.status})`);
+        return record;
+    }
+}

package/dist/cli/commands/session/state/get.d.ts

@@ -0,0 +1,16 @@
+import { BaseCommand } from "../../../base-command.js";
+export default class SessionStateGet extends BaseCommand {
+    static description: string;
+    static hidden: boolean;
+    static examples: string[];
+    static flags: {
+        session: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        key: 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>;
+    };
+    protected execute(): Promise<unknown>;
+}
+//# sourceMappingURL=get.d.ts.map

package/dist/cli/commands/session/state/get.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get.d.ts","sourceRoot":"","sources":["../../../../../src/cli/commands/session/state/get.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAEvD,MAAM,CAAC,OAAO,OAAO,eAAgB,SAAQ,WAAW;IACtD,OAAgB,WAAW,SAA6D;IACxF,OAAgB,MAAM,UAAS;IAE/B,OAAgB,QAAQ,WAGtB;IAEF,OAAgB,KAAK;;;;;;;MASnB;cAEc,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC;CAwC5C"}