@polderlabs/bizar-omp 0.7.0 → 0.7.2

package/dist/src/omp/omb-sessions.d.ts

@@ -1,122 +0,0 @@
-import { type OmbSessionActivity } from "./session-activity.js";
-export declare const BIZAR_SESSION_PREFIX = "bizar-";
-/**
- * Connection and activity state of one Bizar-owned session.
- *
- * `working` and `waiting` describe what the agent is doing, `connected` and
- * `disconnected` describe whether an interactive client is attached to an idle
- * session, and `stopped` means no host is observed and the journal is silent.
- */
-export type OmbSessionState = "working" | "waiting" | "connected" | "disconnected" | "stopped";
-export interface OmbSessionInfo {
-    name: string;
-    cwd: string;
-    project: string;
-    id: string;
-    /**
-     * Human label for this row: the native OMP title when the session has one,
-     * otherwise a readable derivation (first prompt, generated session label, or
-     * project-scoped fallback). Every row carries it, so no renderer has to
-     * invent a name from `id`.
-     */
-    displayName?: string;
-    state: OmbSessionState;
-    /** Privacy-safe live activity, when the session journal exposes it. */
-    activity?: OmbSessionActivity;
-    /**
-     * True when tmux currently hosts this session.
-     *
-     * A live OMP process whose host `omb` never created, or whose host died
-     * while the agent kept working, has no attachable tmux session. Absent for
-     * synthetic records, which are treated as hosted.
-     */
-    hosted?: boolean;
-    command: string;
-    pid: string;
-    /** Native OMP session id, when its journal is available. */
-    nativeId?: string;
-    /** Native OMP session title, when configured or auto-generated. */
-    nativeName?: string;
-    /** First user prompt, used as a stable local fallback before auto-titling. */
-    firstMessage?: string;
-    /** True when this host has a Bizar-owned isolated native session directory. */
-    nativeSessionAvailable?: boolean;
-    /**
-     * True when tmux has a client attached to this session right now.
-     *
-     * Distinct from `state`: an attached session that is still working reports
-     * `working`, so only this field answers "would stopping it disconnect
-     * somebody?".
-     */
-    attached?: boolean;
-    createdAt?: number;
-    lastAttachedAt?: number;
-}
-export interface ListOmbSessionsOptions {
-    /** Include Bizar sessions whose tmux host exited and whose journal is silent. Defaults to false. */
-    includeStopped?: boolean;
-}
-/** Keep native OMP journals separate so each durable `omb` host has one exact session. */
-export declare function ombSessionDir(session: string, env?: NodeJS.ProcessEnv): string;
-/**
- * Whether a name is one of the sessions Bizar owns, and may therefore kill,
- * rename, tombstone, or adopt as its own native journal.
- */
-export declare function isOmbSessionName(session: string): boolean;
-/** Keep an intentionally removed session out of journal-based discovery. */
-export declare function markOmbSessionDeleted(session: string, env?: NodeJS.ProcessEnv): boolean;
-/** Reusing a session name makes its native journal discoverable again. */
-export declare function clearOmbSessionDeleted(session: string, env?: NodeJS.ProcessEnv): void;
-/** Native OMP title first, then a deterministic prompt/project fallback. */
-export declare function ombSessionDisplayName(session: Pick<OmbSessionInfo, "project" | "id" | "nativeName" | "firstMessage" | "nativeSessionAvailable">): string;
-/**
- * Resolve the tmux-compatible multiplexer binary. `BIZAR_TMUX_BIN` always
- * wins. On Windows, psmux is the supported native multiplexer (it ships a
- * `tmux` command alias, but resolving `tmux` on PATH could pick unrelated
- * binaries), so prefer `psmux` and fall back to the generic `tmux` name;
- * elsewhere the standard `tmux` binary is used.
- */
-export declare function resolveMultiplexerBin(env?: NodeJS.ProcessEnv): string;
-/**
- * Resolve the hub state from tmux liveness, client attachment, and journal
- * activity.
- *
- * Work wins over attachment: a detached client must never hide an agent that
- * is still processing, which is the failure this hub exists to prevent.
- * `waiting` refines an attached session that finished its turn, `connected`
- * covers an attached session with no structured activity yet, and
- * `disconnected` covers a live session with no client and no work in flight.
- */
-export declare function ombSessionState(input: {
-    dead: boolean;
-    attached: boolean;
-    activity?: OmbSessionActivity;
-}): OmbSessionState;
-/**
- * Session names whose journal the pane of one live tmux session writes.
- *
- * Deletion uses this before killing the session, because a renamed session's
- * journal lives in the directory it was started with rather than the one named
- * after the current tmux session.
- */
-export declare function ombSessionBoundNames(session: string, cwd: string, env?: NodeJS.ProcessEnv): Promise<string[]>;
-/**
- * Where this process runs from, as far as the multiplexer can tell.
- *
- * `omb stop` needs `unknown` to exist: when `TMUX` is set but the multiplexer
- * cannot answer, the hosting session is unidentified, and a kill verb must
- * assume that one of the sessions it is about to stop could be its own.
- */
-export type OmbHostSession = {
-    kind: "not-bizar";
-} | {
-    kind: "bizar";
-    name: string;
-} | {
-    kind: "unknown";
-};
-export declare function currentOmbHostSession(cwd?: string, env?: NodeJS.ProcessEnv): Promise<OmbHostSession>;
-/** Discover Bizar-owned tmux sessions without touching unrelated tmux sessions. */
-export declare function listOmbSessions(cwd?: string, env?: NodeJS.ProcessEnv, options?: ListOmbSessionsOptions): Promise<OmbSessionInfo[]>;
-/** Return the most recently attached live session for one exact project path. */
-export declare function findLastOmbSession(cwd: string, env?: NodeJS.ProcessEnv): Promise<OmbSessionInfo | undefined>;

package/dist/src/omp/omb-sessions.js

@@ -1,512 +0,0 @@
-import { spawn } from "node:child_process";
-import { access, readdir, stat } from "node:fs/promises";
-import { mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { basename, join, relative, resolve } from "node:path";
-import { homedir, tmpdir } from "node:os";
-import { deriveSessionActivity, listSessionJournals, readJournalHead, readJournalTail, } from "./session-activity.js";
-export const BIZAR_SESSION_PREFIX = "bizar-";
-/** Most recent stopped sessions to surface when stopped sessions are enabled. */
-const STOPPED_SESSION_LIMIT = 6;
-const DELETED_SESSION_MARKER = ".bizar-deleted";
-function nativeSessionRoot(env) {
-    const stateHome = env.XDG_STATE_HOME || join(env.HOME || homedir(), ".local", "state");
-    return join(stateHome, "bizar-omp", "native-sessions");
-}
-/** Keep native OMP journals separate so each durable `omb` host has one exact session. */
-export function ombSessionDir(session, env = process.env) {
-    return join(nativeSessionRoot(env), session);
-}
-/**
- * Whether a name is one of the sessions Bizar owns, and may therefore kill,
- * rename, tombstone, or adopt as its own native journal.
- */
-export function isOmbSessionName(session) {
-    return /^bizar-[A-Za-z0-9_.-]+$/.test(session);
-}
-function markDirectoryDeleted(directory) {
-    try {
-        mkdirSync(directory, { recursive: true, mode: 0o700 });
-        writeFileSync(join(directory, DELETED_SESSION_MARKER), `${Date.now()}\n`, { mode: 0o600 });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/** Keep an intentionally removed session out of journal-based discovery. */
-export function markOmbSessionDeleted(session, env = process.env) {
-    return isOmbSessionName(session) && markDirectoryDeleted(ombSessionDir(session, env));
-}
-/** Reusing a session name makes its native journal discoverable again. */
-export function clearOmbSessionDeleted(session, env = process.env) {
-    if (!isOmbSessionName(session))
-        return;
-    try {
-        rmSync(join(ombSessionDir(session, env), DELETED_SESSION_MARKER), { force: true });
-    }
-    catch { /* discovery remains conservative */ }
-}
-async function isOmbSessionDeleted(session, env) {
-    try {
-        await access(join(ombSessionDir(session, env), DELETED_SESSION_MARKER));
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function ompAgentDir(env) {
-    if (env.PI_CODING_AGENT_DIR)
-        return resolve(env.PI_CODING_AGENT_DIR);
-    return join(env.HOME || homedir(), env.PI_CONFIG_DIR || ".omp", "agent");
-}
-function defaultOmpSessionDir(cwd, env) {
-    const resolvedCwd = resolve(cwd);
-    const home = resolve(env.HOME || homedir());
-    const temp = resolve(tmpdir());
-    const encode = (value) => value.replace(/[\\/:]/g, "-");
-    const homeRelative = relative(home, resolvedCwd);
-    if (homeRelative === "" || (!homeRelative.startsWith("..") && !homeRelative.startsWith("/"))) {
-        return join(ompAgentDir(env), "sessions", homeRelative ? `-${encode(homeRelative)}` : "-");
-    }
-    const tempRelative = relative(temp, resolvedCwd);
-    if (tempRelative === "" || (!tempRelative.startsWith("..") && !tempRelative.startsWith("/"))) {
-        return join(ompAgentDir(env), "sessions", tempRelative ? `-tmp-${encode(tempRelative)}` : "-tmp");
-    }
-    return join(ompAgentDir(env), "sessions", `--${encode(resolvedCwd).replace(/^-/, "")}--`);
-}
-function cleanText(value) {
-    if (typeof value !== "string")
-        return undefined;
-    const cleaned = value
-        .split(/\r?\n/, 1)[0]
-        .replace(/[\x00-\x1F\x7F]/g, "")
-        .replace(/\s+/g, " ")
-        .trim();
-    return cleaned || undefined;
-}
-function asRecord(value) {
-    return typeof value === "object" && value !== null ? value : undefined;
-}
-/**
- * Parse one journal's session header, title, and first user prompt.
- *
- * Current journals open with a `title` entry that is rewritten in place, so
- * the session header is the first `session` entry rather than the first line.
- */
-async function readNativeSessionFile(journal) {
-    const content = await readJournalHead(journal);
-    if (!content)
-        return undefined;
-    let header;
-    const entries = [];
-    for (const line of content.split("\n")) {
-        const trimmed = line.trim();
-        if (!trimmed || trimmed[0] !== "{")
-            continue;
-        let entry;
-        try {
-            entry = JSON.parse(trimmed);
-        }
-        catch {
-            // A partially written final line must not hide the entries before it.
-            continue;
-        }
-        if (!header && entry.type === "session") {
-            header = entry;
-            continue;
-        }
-        entries.push(entry);
-    }
-    if (!header)
-        return undefined;
-    let latestTitle = cleanText(header.title);
-    let latestTitleAt = Number.NEGATIVE_INFINITY;
-    let firstMessage;
-    for (const entry of entries) {
-        if (entry.type === "title" || entry.type === "title_change") {
-            const title = cleanText(entry.title);
-            const raw = entry.updatedAt ?? entry.timestamp;
-            const at = typeof raw === "string" ? Date.parse(raw) : NaN;
-            // OMP rewrites the opening `title` entry in place and appends
-            // `title_change` history, so the newest timestamp — not file order —
-            // names the title the session currently has.
-            if (title && (!Number.isFinite(at) || at >= latestTitleAt)) {
-                latestTitle = title;
-                if (Number.isFinite(at))
-                    latestTitleAt = at;
-            }
-        }
-        if (firstMessage || entry.type !== "message")
-            continue;
-        const message = asRecord(entry.message);
-        if (message?.role !== "user")
-            continue;
-        if (typeof message.content === "string")
-            firstMessage = cleanText(message.content);
-        else if (Array.isArray(message.content)) {
-            firstMessage = cleanText(message.content
-                .filter(item => asRecord(item)?.type === "text")
-                .map(item => asRecord(item)?.text)
-                .filter((item) => typeof item === "string")
-                .join(" "));
-        }
-    }
-    const timestamp = typeof header.timestamp === "string" ? Date.parse(header.timestamp) : NaN;
-    return {
-        id: cleanText(header.id),
-        title: latestTitle,
-        cwd: cleanText(header.cwd),
-        firstMessage,
-        createdAt: Number.isFinite(timestamp) ? Math.floor(timestamp / 1000) : undefined,
-    };
-}
-/** Metadata plus live activity for a Bizar-owned native session directory. */
-async function readNativeSessionSnapshot(sessionDir, now) {
-    const journals = await listSessionJournals(sessionDir);
-    const newest = journals.at(-1);
-    if (!newest)
-        return {};
-    const [entries, modifiedAt, ...candidates] = await Promise.all([
-        readJournalTail(newest),
-        stat(newest).then(file => file.mtimeMs).catch(() => undefined),
-        ...journals.slice(-3).reverse().map(journal => readNativeSessionFile(journal)),
-    ]);
-    let metadata;
-    for (const candidate of candidates) {
-        if (candidate) {
-            metadata = candidate;
-            break;
-        }
-    }
-    return {
-        metadata,
-        activity: entries.length > 0 ? deriveSessionActivity(entries, { now, fallbackUpdatedAt: modifiedAt }) : undefined,
-    };
-}
-async function readLegacyNativeSessionMetadata(cwd, sessionCreatedAt, env) {
-    const sessionDir = defaultOmpSessionDir(cwd, env);
-    const journals = await listSessionJournals(sessionDir);
-    if (journals.length === 0)
-        return undefined;
-    const candidates = (await Promise.all(journals.map(async (journal) => {
-        const metadata = await readNativeSessionFile(journal);
-        return metadata ? { journal, metadata } : undefined;
-    }))).filter((candidate) => Boolean(candidate));
-    if (candidates.length === 0)
-        return undefined;
-    if (candidates.length === 1 || sessionCreatedAt === undefined)
-        return candidates[0]?.metadata;
-    candidates.sort((a, b) => Math.abs((a.metadata.createdAt ?? 0) - sessionCreatedAt) - Math.abs((b.metadata.createdAt ?? 0) - sessionCreatedAt));
-    return candidates[0]?.metadata;
-}
-function compactPrompt(prompt) {
-    const words = prompt.replace(/^[-*#>]+\s*/, "").split(/\s+/).filter(Boolean);
-    const compact = words.slice(0, 7).join(" ").replace(/[.!?]+$/, "");
-    return compact.length > 48 ? `${compact.slice(0, 47).trimEnd()}…` : compact;
-}
-function generatedSessionLabel(project, id) {
-    const match = id.match(/^s-(.+)-([a-z0-9]{4,})$/);
-    if (!match)
-        return undefined;
-    const stem = match[1];
-    const normalizedProject = project.toLocaleLowerCase().replace(/[^a-z0-9]+/g, "-");
-    if (stem === "session" || stem === normalizedProject || /^[a-z0-9]{7,}$/.test(stem))
-        return `New ${project} session`;
-    return `${project} · ${stem.replace(/-/g, " ")}`;
-}
-/** Session ids that carry no readable meaning on their own. */
-const OPAQUE_SESSION_ID = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}|[0-9a-f]{16,})$/i;
-/** Native OMP title first, then a deterministic prompt/project fallback. */
-export function ombSessionDisplayName(session) {
-    if (session.nativeName)
-        return session.nativeName;
-    if (session.firstMessage)
-        return compactPrompt(session.firstMessage);
-    const generatedLabel = generatedSessionLabel(session.project, session.id);
-    if (generatedLabel)
-        return generatedLabel;
-    if (session.nativeSessionAvailable)
-        return `New ${session.project} session`;
-    // A raw UUID (or another opaque token) is never a readable session name.
-    if (OPAQUE_SESSION_ID.test(session.id))
-        return `New ${session.project} session`;
-    return `${session.project}/${session.id || "main"}`;
-}
-/**
- * Resolve the tmux-compatible multiplexer binary. `BIZAR_TMUX_BIN` always
- * wins. On Windows, psmux is the supported native multiplexer (it ships a
- * `tmux` command alias, but resolving `tmux` on PATH could pick unrelated
- * binaries), so prefer `psmux` and fall back to the generic `tmux` name;
- * elsewhere the standard `tmux` binary is used.
- */
-export function resolveMultiplexerBin(env = process.env) {
-    if (env.BIZAR_TMUX_BIN)
-        return env.BIZAR_TMUX_BIN;
-    return process.platform === "win32" ? "psmux" : "tmux";
-}
-/**
- * Resolve the hub state from tmux liveness, client attachment, and journal
- * activity.
- *
- * Work wins over attachment: a detached client must never hide an agent that
- * is still processing, which is the failure this hub exists to prevent.
- * `waiting` refines an attached session that finished its turn, `connected`
- * covers an attached session with no structured activity yet, and
- * `disconnected` covers a live session with no client and no work in flight.
- */
-export function ombSessionState(input) {
-    if (input.dead)
-        return "stopped";
-    const activity = input.activity;
-    if (activity && activity.phase !== "unknown" && !activity.awaitingInput)
-        return "working";
-    if (!input.attached)
-        return "disconnected";
-    return activity?.awaitingInput ? "waiting" : "connected";
-}
-const STATE_RANK = {
-    working: 0,
-    waiting: 1,
-    connected: 2,
-    disconnected: 3,
-    stopped: 4,
-};
-function exitCode(code, signal) {
-    if (code !== null)
-        return code;
-    return signal ? 1 : 1;
-}
-function readTmux(command, args, cwd, env) {
-    const child = spawn(command, args, { cwd, env, stdio: ["ignore", "pipe", "ignore"] });
-    let output = "";
-    child.stdout?.setEncoding("utf8");
-    child.stdout?.on("data", chunk => { output += chunk; });
-    return new Promise((resolve, reject) => {
-        // A missing multiplexer binary means "no sessions", not a crash:
-        // discovery callers treat any nonzero code as an empty listing. Any
-        // other spawn failure (EACCES, EPERM, ...) is still a hard error.
-        child.once("error", (error) => {
-            if (error.code === "ENOENT" || error.code === "EINVAL")
-                resolve({ code: 127, output: "" });
-            else
-                reject(error);
-        });
-        child.once("close", (code, signal) => resolve({ code: exitCode(code, signal), output }));
-    });
-}
-function sessionId(name) {
-    const match = name.match(/-[a-f0-9]{10}(?:-(.*))?$/);
-    return match?.[1] || "main";
-}
-/** Project slug encoded in the Bizar session name, without the digest. */
-function sessionProject(name) {
-    const trimmed = name.slice(BIZAR_SESSION_PREFIX.length);
-    return trimmed.replace(/-[a-f0-9]{10}(?:-.*)?$/, "") || trimmed || "session";
-}
-/**
- * One pane's fields, including the command tmux started it with. Bizar launches
- * every host as `omp --session-dir <native root>/<session>`, so that command is
- * the only exact record of which journal a live row owns.
- */
-const PANE_FORMAT = "#{pane_dead}\t#{pane_current_path}\t#{pane_current_command}\t#{pane_pid}\t#{pane_start_command}";
-/**
- * Session whose native directory a pane command declares.
- *
- * A renamed tmux session keeps the directory its host was started with, so
- * discovery reads the binding from the pane instead of assuming the directory
- * matches the session name. Paths outside the Bizar native root, or names
- * Bizar does not own, are ignored so unrelated OMP hosts are never adopted.
- */
-function paneBoundSession(startCommand, env) {
-    const declared = startCommand?.match(/--session-dir(?:=|\s+)(?:"([^"]*)"|'([^']*)'|(\S+))/);
-    const value = declared?.[1] ?? declared?.[2] ?? declared?.[3];
-    if (!value)
-        return undefined;
-    const directory = relative(resolve(nativeSessionRoot(env)), resolve(value));
-    if (!directory || directory.startsWith("..") || directory.includes("/") || !isOmbSessionName(directory))
-        return undefined;
-    return directory;
-}
-function parsePane(output, env) {
-    const [line = ""] = output.trim().split("\n");
-    const [dead, cwd, command, pid, startCommand] = line.split("\t");
-    return {
-        dead: dead === "1",
-        cwd: cwd || "?",
-        command: command || "?",
-        pid: pid || "?",
-        bound: paneBoundSession(startCommand, env),
-    };
-}
-function parseSessionList(output) {
-    return output
-        .split("\n")
-        .map(line => line.trim())
-        .filter(Boolean)
-        .map(line => line.split("\t"))
-        .filter(parts => parts[0]?.startsWith(BIZAR_SESSION_PREFIX))
-        .map(parts => ({
-        name: parts[0],
-        createdAt: Number.isFinite(Number(parts[1])) ? Number(parts[1]) : undefined,
-        lastAttachedAt: Number.isFinite(Number(parts[2])) ? Number(parts[2]) : undefined,
-        attached: parts[3] !== "0",
-    }));
-}
-function sessionRecord(name, fields) {
-    const record = {
-        name,
-        project: fields.cwd === "?" ? sessionProject(name) : basename(fields.cwd),
-        id: sessionId(name),
-        ...fields,
-    };
-    return { ...record, displayName: ombSessionDisplayName(record) };
-}
-async function describeLiveSession(tmux, session, cwd, childEnv, env, now) {
-    const pane = await readTmux(tmux, ["list-panes", "-t", session.name, "-F", PANE_FORMAT], cwd, childEnv);
-    const details = parsePane(pane.output, env);
-    // Prefer the journal the pane command names: after a rename the tmux session
-    // and its native directory differ, and the host keeps writing the directory
-    // it was started with.
-    const declared = details.bound && details.bound !== session.name
-        ? await readNativeSessionSnapshot(ombSessionDir(details.bound, env), now)
-        : undefined;
-    const snapshot = declared?.metadata ? declared : await readNativeSessionSnapshot(ombSessionDir(session.name, env), now);
-    const native = snapshot.metadata ?? await readLegacyNativeSessionMetadata(details.cwd, session.createdAt, env);
-    return {
-        // A live session owns the directory its pane declared, so it must not also
-        // be listed from that directory as a second, unopenable session.
-        binding: declared?.metadata ? details.bound : undefined,
-        session: sessionRecord(session.name, {
-            cwd: details.cwd,
-            state: ombSessionState({ dead: details.dead, attached: session.attached, activity: snapshot.activity }),
-            attached: session.attached,
-            activity: snapshot.activity,
-            hosted: true,
-            command: details.command,
-            pid: details.pid,
-            nativeId: native?.id,
-            nativeName: native?.title,
-            firstMessage: native?.firstMessage,
-            nativeSessionAvailable: Boolean(snapshot.metadata || native),
-            createdAt: session.createdAt ?? native?.createdAt,
-            lastAttachedAt: session.lastAttachedAt,
-        }),
-    };
-}
-/**
- * Session names whose journal the pane of one live tmux session writes.
- *
- * Deletion uses this before killing the session, because a renamed session's
- * journal lives in the directory it was started with rather than the one named
- * after the current tmux session.
- */
-export async function ombSessionBoundNames(session, cwd, env = process.env) {
-    if (!isOmbSessionName(session))
-        return [];
-    const childEnv = { ...env, BIZAR_OMP_NO_TMUX: "1" };
-    const panes = await readTmux(resolveMultiplexerBin(env), ["list-panes", "-t", session, "-F", PANE_FORMAT], cwd, childEnv);
-    if (panes.code !== 0)
-        return [];
-    const bound = parsePane(panes.output, env).bound;
-    return bound && bound !== session ? [bound] : [];
-}
-/**
- * Bizar sessions that tmux no longer hosts.
- *
- * tmux removes a session as soon as its pane exits, so a terminated session
- * only remains discoverable through the native state directory that `omb`
- * gives every durable host. A journal written inside the stale window proves
- * the agent is still running — a host started outside `omb`, or one whose pane
- * died while the agent kept working — so those sessions stay live instead of
- * being reported as stopped.
- */
-async function listUnhostedSessions(env, claimed, now) {
-    let entries;
-    try {
-        entries = await readdir(nativeSessionRoot(env), { withFileTypes: true });
-    }
-    catch {
-        return [];
-    }
-    const unhosted = (await Promise.all(entries.map(async (entry) => {
-        if (!entry.isDirectory() || !entry.name.startsWith(BIZAR_SESSION_PREFIX) || claimed.has(entry.name) || await isOmbSessionDeleted(entry.name, env))
-            return undefined;
-        const snapshot = await readNativeSessionSnapshot(join(nativeSessionRoot(env), entry.name), now);
-        const metadata = snapshot.metadata;
-        // A directory with no readable session header holds no session: it is an
-        // emptied tombstone or a directory created before OMP journaled anything.
-        // Listing it would resurrect a session that is gone.
-        if (!metadata)
-            return undefined;
-        const activity = snapshot.activity;
-        const alive = Boolean(activity && !activity.stale);
-        return sessionRecord(entry.name, {
-            cwd: metadata.cwd ?? "?",
-            state: alive ? ombSessionState({ dead: false, attached: false, activity }) : "stopped",
-            attached: false,
-            activity,
-            hosted: false,
-            command: alive ? "unattached" : "exited",
-            pid: "?",
-            nativeId: metadata.id,
-            nativeName: metadata.title,
-            firstMessage: metadata.firstMessage,
-            nativeSessionAvailable: true,
-            createdAt: metadata.createdAt,
-        });
-    }))).filter((session) => Boolean(session));
-    unhosted.sort((a, b) => (b.activity?.updatedAt ?? 0) - (a.activity?.updatedAt ?? 0));
-    const live = unhosted.filter(session => session.state !== "stopped");
-    return [...live, ...unhosted.filter(session => session.state === "stopped").slice(0, STOPPED_SESSION_LIMIT)];
-}
-export async function currentOmbHostSession(cwd = process.cwd(), env = process.env) {
-    if (!env.TMUX)
-        return { kind: "not-bizar" };
-    const args = ["display-message", "-p"];
-    if (env.TMUX_PANE)
-        args.push("-t", env.TMUX_PANE);
-    args.push("#{session_name}");
-    let result;
-    try {
-        result = await readTmux(resolveMultiplexerBin(env), args, cwd, { ...env, BIZAR_OMP_NO_TMUX: "1" });
-    }
-    catch {
-        return { kind: "unknown" };
-    }
-    if (result.code !== 0)
-        return { kind: "unknown" };
-    const [name = ""] = result.output.trim().split("\n");
-    // A session Bizar does not own cannot be one of the sessions a stop targets.
-    return isOmbSessionName(name) ? { kind: "bizar", name } : { kind: "not-bizar" };
-}
-/** Discover Bizar-owned tmux sessions without touching unrelated tmux sessions. */
-export async function listOmbSessions(cwd = process.cwd(), env = process.env, options = {}) {
-    const tmux = resolveMultiplexerBin(env);
-    const childEnv = { ...env, BIZAR_OMP_NO_TMUX: "1" };
-    const now = Date.now();
-    const sessions = await readTmux(tmux, ["list-sessions", "-F", "#{session_name}\t#{session_created}\t#{session_last_attached}\t#{session_attached}"], cwd, childEnv);
-    const live = sessions.code === 0 ? parseSessionList(sessions.output) : [];
-    const described = await Promise.all(live.map(session => describeLiveSession(tmux, session, cwd, childEnv, env, now)));
-    // Every live session claims the directory its pane writes (its own, or the one
-    // a rename left behind), so one session is never listed twice under two names.
-    const claimed = new Set([
-        ...live.map(session => session.name),
-        ...described.map(item => item.binding).filter((name) => Boolean(name)),
-    ]);
-    const unhosted = await listUnhostedSessions(env, claimed, now);
-    const stopped = options.includeStopped ? unhosted.filter(session => session.state === "stopped") : [];
-    return [...described.map(item => item.session), ...unhosted.filter(session => session.state !== "stopped"), ...stopped].sort((a, b) => STATE_RANK[a.state] - STATE_RANK[b.state] ||
-        a.project.localeCompare(b.project) ||
-        a.name.localeCompare(b.name));
-}
-/** Return the most recently attached live session for one exact project path. */
-export async function findLastOmbSession(cwd, env = process.env) {
-    const sessions = await listOmbSessions(cwd, env);
-    return sessions
-        // Only a session tmux still hosts can be reattached. Resuming a live but
-        // unhosted session would put a second writer on its journal.
-        .filter(session => session.cwd === cwd && session.state !== "stopped" && session.hosted !== false)
-        .sort((a, b) => (b.lastAttachedAt ?? b.createdAt ?? 0) - (a.lastAttachedAt ?? a.createdAt ?? 0))[0];
-}
-//# sourceMappingURL=omb-sessions.js.map