brane 0.0.2 → 0.3.0

package/dist/claude-live-session.js

@@ -0,0 +1,124 @@
+// The session a brane-spawned Claude Code is running *now*.
+//
+// The daemon assigns a claude narrative's session id at launch
+// (`--session-id`), but Claude Code can move to a new session without the
+// process ever exiting: `/clear` starts a fresh transcript under an id it mints
+// itself, and so does `/resume <other>` from inside a running session. Nothing
+// brane holds learns about it — the MCP bridge read `CLAUDE_CODE_SESSION_ID`
+// once when it started, and `/clear` doesn't restart MCP servers — so cost
+// kept reading a transcript that had stopped growing, and revive would resume
+// the conversation from before the `/clear`.
+//
+// Claude Code keeps a registry of its interactive processes at
+// `~/.claude/sessions/<pid>.json`, and rewrites its own entry's `sessionId`
+// when the session changes. The daemon reads it for the one process it knows
+// is the narrative's agent: the pane of tmux session `<nid>`, whose command
+// tmux exec'd, so its `pane_pid` *is* the claude process.
+//
+// That choice is what keeps this free of races. It is a pull, not a push: no
+// hook payload or bridge report is trusted, so a subagent (which runs
+// in-process and has no entry of its own), a nested `claude -p` in the agent's
+// Bash (a different pid, though it inherits the narrative's env and hooks),
+// and any number of MCP reconnects have no way to move the pointer. The
+// registry's one writer is the process it describes.
+import { execFileSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { resolveTmux } from "./tmux.js";
+/** Slack on `launchedAt`: the daemon stamps a launch just before tmux starts
+ *  the process, and the two clocks are the same machine's, so a few seconds
+ *  covers it with room to spare. */
+const LAUNCH_SLACK_MS = 60_000;
+/** Parse one registry entry and return its `sessionId` only if it provably
+ *  describes this narrative's current agent. Each guard answers a way a file
+ *  could be read that isn't: the registry keeps entries for exited processes,
+ *  so a recycled pid can point at a stranger's (`pid`, `tmux`, `cwd`), or at
+ *  this narrative's own previous launch (`startedAt`). Pure, for tests. */
+export function liveSessionFromRegistryEntry(rawJson, expect) {
+    let entry;
+    try {
+        entry = JSON.parse(rawJson);
+    }
+    catch {
+        return undefined;
+    }
+    if (!entry || typeof entry !== "object")
+        return undefined;
+    if (typeof entry.sessionId !== "string" || !entry.sessionId)
+        return undefined;
+    if (entry.pid !== expect.pid)
+        return undefined;
+    // `<session>:@<window>.%<pane>` — the name up to the first colon, exactly.
+    if (typeof entry.tmux !== "string" || entry.tmux.split(":")[0] !== expect.narrativeId)
+        return undefined;
+    if (typeof entry.cwd !== "string" || resolve(entry.cwd) !== resolve(expect.foldPath))
+        return undefined;
+    if (typeof entry.startedAt !== "number" || entry.startedAt < expect.launchedAt - LAUNCH_SLACK_MS)
+        return undefined;
+    if (entry.kind !== undefined && entry.kind !== "interactive")
+        return undefined;
+    return entry.sessionId;
+}
+/** Every tmux session's pane pid, from one `list-panes -a`. The cost tick asks
+ *  for each connected claude narrative in turn, and this runs on the daemon's
+ *  only thread, so one exec per tick rather than one per narrative; the short
+ *  memo spans a tick and nothing longer. */
+let paneMemo;
+const PANE_MEMO_MS = 1000;
+/** Parse `list-panes -a -F "#{session_name} #{pane_pid}"`. A session with
+ *  several panes has no single agent process, so it maps to nothing. Pure. */
+export function parsePanePids(out) {
+    const pids = new Map();
+    const ambiguous = new Set();
+    for (const line of out.split("\n")) {
+        const at = line.lastIndexOf(" ");
+        if (at <= 0)
+            continue;
+        const name = line.slice(0, at);
+        const pid = Number(line.slice(at + 1));
+        if (!Number.isInteger(pid) || pid <= 1)
+            continue;
+        if (pids.has(name))
+            ambiguous.add(name);
+        pids.set(name, pid);
+    }
+    for (const name of ambiguous)
+        pids.delete(name);
+    return pids;
+}
+function panePid(narrativeId) {
+    const now = Date.now();
+    if (!paneMemo || now - paneMemo.at > PANE_MEMO_MS) {
+        let out = "";
+        try {
+            out = execFileSync(resolveTmux(), ["list-panes", "-a", "-F", "#{session_name} #{pane_pid}"], {
+                encoding: "utf8",
+                stdio: ["ignore", "pipe", "ignore"],
+                timeout: 2000,
+            });
+        }
+        catch {
+            // No server, or no sessions: nothing is live.
+        }
+        paneMemo = { at: now, pids: parsePanePids(out) };
+    }
+    return paneMemo.pids.get(narrativeId);
+}
+/** Read the session id Claude Code's registry holds for this narrative's pane,
+ *  or undefined when there is no pane, no entry, or an entry that fails a
+ *  guard. Never throws. */
+export function readClaudeLiveSession(opts) {
+    const pid = panePid(opts.narrativeId);
+    if (!pid)
+        return undefined;
+    let raw;
+    try {
+        raw = readFileSync(join(homedir(), ".claude", "sessions", `${pid}.json`), "utf8");
+    }
+    catch {
+        return undefined;
+    }
+    return liveSessionFromRegistryEntry(raw, { ...opts, pid });
+}
+//# sourceMappingURL=claude-live-session.js.map

package/dist/cli.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { defineCommand, runMain } from "citty";
+import { foldCommand } from "./commands/fold.js";
+import { daemonCommand } from "./commands/daemon.js";
+import { spawnCommand } from "./commands/spawn.js";
+import { listCommand } from "./commands/list.js";
+import { attachCommand } from "./commands/attach.js";
+import { reviveCommand } from "./commands/revive.js";
+import { costCommand } from "./commands/cost.js";
+import { tokenCommand } from "./commands/token.js";
+import { memoryCommand } from "./commands/memory.js";
+import { mcpCommand } from "./commands/mcp.js";
+import { meldCommand } from "./commands/meld.js";
+import { configCommand } from "./commands/config.js";
+import { certifyCommand } from "./commands/certify.js";
+import { absorbCommand } from "./commands/absorb.js";
+import { doctorCommand } from "./commands/doctor.js";
+// dist/cli.js sits one level below package.json both in the checkout and in
+// the published tarball, so the version the CLI reports is the version that
+// was published rather than a string that has to be bumped by hand.
+const packageJson = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), "..", "package.json"), "utf8"));
+const main = defineCommand({
+    meta: {
+        name: "brane",
+        version: packageJson.version,
+        description: packageJson.description,
+    },
+    subCommands: {
+        fold: foldCommand,
+        daemon: daemonCommand,
+        spawn: spawnCommand,
+        list: listCommand,
+        attach: attachCommand,
+        revive: reviveCommand,
+        cost: costCommand,
+        token: tokenCommand,
+        memory: memoryCommand,
+        mcp: mcpCommand,
+        meld: meldCommand,
+        config: configCommand,
+        certify: certifyCommand,
+        doctor: doctorCommand,
+        absorb: absorbCommand,
+    },
+});
+runMain(main);
+//# sourceMappingURL=cli.js.map

package/dist/codex-tool-log.js

@@ -0,0 +1,144 @@
+import { closeSync, openSync, readSync, statSync } from "node:fs";
+import { findCodexRollout, codexSessionsRoot } from "./agents.js";
+import { readToolUse, recordToolUse } from "./db/tool-uses.js";
+export function newCodexLogCursor() {
+    return { offset: 0, pending: Buffer.alloc(0), names: new Map() };
+}
+/** Codex's `custom_tool_call_output` carries an array of content parts rather
+ *  than a string. Flatten the text so the stored row reads as output instead of
+ *  as a serialized wire envelope; anything else passes through untouched for
+ *  `prepareCaptureText` to serialize. */
+function flattenOutput(output) {
+    if (!Array.isArray(output))
+        return output;
+    const parts = output
+        .map((p) => p?.text)
+        .filter((t) => typeof t === "string");
+    return parts.length === output.length ? parts.join("") : output;
+}
+/** Translate one rollout record into the common row shape, or undefined if it
+ *  isn't a tool call. Pure, so the mapping is pinned by tests rather than
+ *  reachable only through a filesystem fixture.
+ *
+ *  `names` supplies the fallback for an output whose call line was consumed in
+ *  an earlier read. It is only ever a fallback: the upsert never overwrites
+ *  `name`, so an already-recorded call keeps its real one regardless. */
+export function toolUseFromCodexRecord(record, names) {
+    if (typeof record !== "object" || record === null)
+        return undefined;
+    const outer = record;
+    if (outer.type !== "response_item")
+        return undefined;
+    if (typeof outer.payload !== "object" || outer.payload === null)
+        return undefined;
+    const payload = outer.payload;
+    const callId = payload.call_id;
+    if (typeof callId !== "string")
+        return undefined;
+    if (payload.type === "function_call" || payload.type === "custom_tool_call") {
+        const name = typeof payload.name === "string" ? payload.name : "unknown";
+        names?.set(callId, name);
+        return {
+            dedupKey: callId,
+            name,
+            // `function_call` carries `arguments`, `custom_tool_call` carries `input`.
+            input: payload.arguments ?? payload.input,
+            status: "pending",
+            source: "session_log",
+            agentType: "codex",
+        };
+    }
+    if (payload.type === "function_call_output" || payload.type === "custom_tool_call_output") {
+        return {
+            dedupKey: callId,
+            name: names?.get(callId) ?? "unknown",
+            output: flattenOutput(payload.output),
+            status: "completed",
+            source: "session_log",
+            agentType: "codex",
+        };
+    }
+    return undefined;
+}
+/** Whether writing this record would tell the database anything new.
+ *
+ *  Every `recordToolUse` bumps the row's `rev`, and `rev` is the client sync
+ *  cursor, so a redundant write is not free — it re-pushes the row to every
+ *  connected client. That matters when a cursor starts cold (a daemon restart,
+ *  or a revived narrative) and replays a rollout already recorded in full:
+ *  without this, every restart would restate hundreds of unchanged rows as a
+ *  sync storm.
+ *
+ *  A `pending` record is skipped against any existing row, because it can only
+ *  restate or regress what is stored. The upsert already refuses the
+ *  regression; this avoids paying a `rev` for the refusal. */
+function wouldChangeNothing(db, narrativeId, toolUse) {
+    const existing = readToolUse(db, narrativeId, toolUse.dedupKey);
+    if (!existing)
+        return false;
+    return toolUse.status === "pending" || existing.status === toolUse.status;
+}
+/** Ingest every tool call codex has written since this cursor last ran, and
+ *  return the rows actually written so the caller can push them.
+ *
+ *  Driven from two directions over one cursor — a timer, and the agent's own
+ *  MCP calls — which is safe because the cursor is a byte offset: whichever
+ *  runs first advances it and the other finds nothing. See
+ *  `startCodexToolSampler` in the daemon.
+ *
+ *  Errors are swallowed and logged: this is telemetry, and an unreadable log
+ *  must never surface as a tool error on the agent's own call. */
+export function pollCodexToolLog(db, narrativeId, sessionId, cursor, sessionsRoot = codexSessionsRoot()) {
+    const path = findCodexRollout(sessionId, sessionsRoot);
+    if (!path)
+        return [];
+    try {
+        const size = statSync(path).size;
+        if (size < cursor.offset) {
+            // The file shrank, so it was replaced or truncated and the offset no
+            // longer means anything. Start over rather than read garbage.
+            cursor.offset = 0;
+            cursor.pending = Buffer.alloc(0);
+            cursor.names.clear();
+        }
+        if (size === cursor.offset)
+            return [];
+        const fd = openSync(path, "r");
+        let chunk = Buffer.allocUnsafe(size - cursor.offset);
+        try {
+            const n = readSync(fd, chunk, 0, chunk.length, cursor.offset);
+            chunk = chunk.subarray(0, n);
+            cursor.offset += n;
+        }
+        finally {
+            closeSync(fd);
+        }
+        const buf = cursor.pending.length ? Buffer.concat([cursor.pending, chunk]) : chunk;
+        const lastNewline = buf.lastIndexOf(0x0a);
+        if (lastNewline === -1) {
+            cursor.pending = buf; // no complete line yet — hold it all for next time
+            return [];
+        }
+        cursor.pending = buf.subarray(lastNewline + 1);
+        const written = [];
+        for (const line of buf.subarray(0, lastNewline).toString("utf8").split("\n")) {
+            if (!line)
+                continue;
+            try {
+                const toolUse = toolUseFromCodexRecord(JSON.parse(line), cursor.names);
+                if (!toolUse || wouldChangeNothing(db, narrativeId, toolUse))
+                    continue;
+                written.push(recordToolUse(db, narrativeId, toolUse));
+            }
+            catch {
+                // A malformed record cannot prevent later well-formed entries.
+            }
+        }
+        return written;
+    }
+    catch (err) {
+        console.error(`[codex-log] reading ${path} for ${narrativeId} failed: ${err}`);
+        return [];
+    }
+}
+//# sourceMappingURL=codex-tool-log.js.map

package/dist/commands/absorb.js

@@ -0,0 +1,291 @@
+/** CLI command: brane absorb <provider> <path> — a client of POST /api/absorb.
+ *
+ *  The import itself runs in the daemon (`src/absorb/run.ts`): payloads, the
+ *  organelle search.db and the niche registry all resolve against the
+ *  daemon's HOME, the same reason `brane cost backfill` delegates. What is
+ *  left here is terminal-shaped: resolving the operator's relative paths
+ *  against *this* shell's cwd, and printing the daemon's NDJSON stream —
+ *  the pre-flight report, a `\r` progress line, the summary — as it arrives.
+ */
+import { resolve } from "node:path";
+import { defineCommand, showUsage } from "citty";
+import { resolveDaemonEndpoint, daemonRequest, daemonStream, warnIfVersionMismatch } from "../daemon/client.js";
+import { listProviders } from "../absorb/index.js";
+/** A path the operator typed, made meaningful to a daemon whose cwd is not
+ *  this shell's: `~/…` is left for the daemon to expand (it is portable
+ *  by definition), anything else is resolved here. */
+function absolutize(p, cwd) {
+    return p.startsWith("~") ? p : resolve(cwd, p);
+}
+/** The request body for `POST /api/absorb`. Only what the operator said is
+ *  sent, so the daemon's defaults (organelle's `~/.organelle`, the derived
+ *  brane id, the niche path as fold) stay in charge of everything else. */
+export function buildAbsorbBody(args, cwd) {
+    return {
+        provider: args.provider,
+        ...(args.path ? { path: absolutize(args.path, cwd) } : {}),
+        ...(args.fold ? { fold: absolutize(args.fold, cwd) } : {}),
+        ...(args.identity ? { identity: args.identity } : {}),
+        ...(args.brane ? { brane: args.brane } : {}),
+        ...(args.dryRun ? { dry_run: true } : {}),
+        ...(args.since ? { since: args.since } : {}),
+        ...(args.session ? { session: args.session } : {}),
+        ...(args.rebuild ? { rebuild: true } : {}),
+    };
+}
+export const absorbCommand = defineCommand({
+    meta: {
+        name: "absorb",
+        description: "Absorb conversation history: from LLM provider exports, or from agent session stores on this machine. `brane absorb survey` lists what this machine has.",
+    },
+    args: {
+        provider: {
+            type: "positional",
+            required: false,
+            description: `Source: ${listProviders().join(", ")} — or "survey" to list the session stores on this machine without reading them`,
+        },
+        path: {
+            type: "positional",
+            required: false,
+            description: "Path to an extracted export directory (chatgpt), a niche directory (organelle, default ~/.organelle), or a session store (claude, default ~/.claude/projects).",
+        },
+        fold: {
+            type: "string",
+            description: "Target fold for absorbed conversations (required for chatgpt; defaults to the niche path for organelle). For a local source (claude) it is a filter: only sessions run in this directory.",
+        },
+        since: {
+            type: "string",
+            description: "Local sources only: sessions active in the last 30m/12h/7d/2w, or since an ISO date",
+        },
+        session: {
+            type: "string",
+            description: "Local sources only: a single session, by id or id prefix",
+        },
+        rebuild: {
+            type: "boolean",
+            description: "Local sources only: for sessions already absorbed into the target brane, drop their events and tool rows and import the file again (same narrative id; seqs renumbered). A narrative someone has signalled or narrated into is not rebuilt, only appended to. Composes with --fold, --since, --session, --dry-run.",
+            default: false,
+        },
+        identity: {
+            type: "string",
+            description: "User identity label (e.g. email). Auto-detected when available.",
+        },
+        brane: {
+            type: "string",
+            description: 'Target brane ID. Use "self" for home brane. Default: auto-generated from provider+identity.',
+        },
+        dryRun: {
+            type: "boolean",
+            alias: ["dry-run", "n"],
+            description: "Parse and summarize without writing to the database",
+            default: false,
+        },
+    },
+    async run({ args }) {
+        if (!args.provider) {
+            // Usage, not a survey: a bare `brane absorb` should say what it can do
+            // (claude-xiy9e8wq:15), and the survey is one of the things it names.
+            await showUsage(absorbCommand);
+            return;
+        }
+        if (args.provider === "survey") {
+            try {
+                const endpoint = await resolveDaemonEndpoint();
+                warnIfVersionMismatch(endpoint);
+                const survey = await daemonRequest(endpoint, "/api/absorb/survey");
+                for (const l of formatSurvey(survey))
+                    console.log(l);
+            }
+            catch (err) {
+                console.error(err instanceof Error ? err.message : String(err));
+                process.exit(1);
+            }
+            return;
+        }
+        const dryRun = args.dryRun;
+        const body = buildAbsorbBody({
+            provider: args.provider,
+            path: args.path,
+            fold: args.fold,
+            identity: args.identity,
+            brane: args.brane,
+            dryRun,
+            since: args.since,
+            session: args.session,
+            rebuild: args.rebuild,
+        }, process.cwd());
+        let failed = false;
+        let progressShown = false;
+        const clearProgress = () => {
+            if (!progressShown)
+                return;
+            process.stdout.write("\r" + " ".repeat(80) + "\r");
+            progressShown = false;
+        };
+        try {
+            const endpoint = await resolveDaemonEndpoint();
+            warnIfVersionMismatch(endpoint);
+            await daemonStream(endpoint, "/api/absorb", { method: "POST", body }, (line) => {
+                switch (line.type) {
+                    case "info":
+                        console.log(line.message);
+                        break;
+                    case "progress":
+                        // A carriage-returned line only means something to a terminal;
+                        // piped or captured (a `!` command in an agent session), every
+                        // frame of it lands in the output ahead of the summary.
+                        if (!process.stdout.isTTY)
+                            break;
+                        process.stdout.write(formatProgress(line.done, line.title, dryRun));
+                        progressShown = true;
+                        break;
+                    case "summary":
+                        clearProgress();
+                        for (const l of formatSummary(line.summary, line.dry_run))
+                            console.log(l);
+                        if (line.dry_run) {
+                            console.log(`\nRe-run without --dry-run to absorb these conversations.`);
+                        }
+                        else {
+                            for (const l of nextSteps(line.provider))
+                                console.log(l);
+                        }
+                        break;
+                    case "error":
+                        clearProgress();
+                        console.error(line.error);
+                        failed = true;
+                        break;
+                }
+            });
+        }
+        catch (err) {
+            clearProgress();
+            console.error(err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+        if (failed)
+            process.exit(1);
+    },
+});
+/** The one-line, carriage-returned progress display. */
+export function formatProgress(done, title, dryRun) {
+    const displayTitle = title
+        ? title.length > 50
+            ? title.slice(0, 47) + "..."
+            : title
+        : "(untitled)";
+    return `\r  ${done} ${dryRun ? "scanned" : "absorbed"}: ${displayTitle}`.padEnd(80);
+}
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    if (bytes < 1024 * 1024 * 1024)
+        return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+}
+export function formatSummary(summary, dryRun) {
+    const lines = [];
+    const verb = dryRun ? "Would absorb" : "Absorbed";
+    const total = summary.conversations + summary.skipped + summary.appended;
+    lines.push(`${verb}: ${summary.conversations} conversations, ${summary.messages} messages (${total} total parsed)`);
+    if (summary.appended > 0) {
+        const aVerb = dryRun ? "Would update" : "Updated";
+        lines.push(`${aVerb}: ${summary.appended} (new messages to append)`);
+    }
+    if (summary.skipped > 0) {
+        lines.push(`Skipped: ${summary.skipped} (already absorbed)`);
+    }
+    if (summary.toolCalls) {
+        lines.push(`Tool calls: ${summary.toolCalls}${dryRun ? " (would be recorded)" : ""}`);
+    }
+    if (summary.managed) {
+        lines.push(`Managed by brane: ${summary.managed} (live narratives own these sessions; left alone)`);
+    }
+    if (summary.unchanged) {
+        lines.push(`Unchanged: ${summary.unchanged} (not read; same size and mtime as last absorb)`);
+    }
+    if (summary.rebuilt) {
+        lines.push(`${dryRun ? "Would rebuild" : "Rebuilt"}: ${summary.rebuilt} (events re-derived from source; narrative ids kept, seqs renumbered)`);
+    }
+    if (summary.locked) {
+        lines.push(`${dryRun ? "Would not rebuild" : "Not rebuilt"}: ${summary.locked} (hold signals or narrations no import wrote; read as an ordinary re-run)`);
+    }
+    if (summary.assets > 0 || summary.unresolvedAssets > 0) {
+        const totalAssets = summary.assets + summary.unresolvedAssets;
+        const aVerb = dryRun ? "Would copy" : "Copied";
+        lines.push(`Assets: ${summary.assets}/${totalAssets} resolved (${formatBytes(summary.assetsBytes)})${dryRun ? ` — ${aVerb.toLowerCase()} to ~/.brane/payloads/` : ""}`);
+        if (summary.unresolvedAssets > 0) {
+            lines.push(`  Unresolved: ${summary.unresolvedAssets} (files not included in export)`);
+        }
+    }
+    if (summary.oldest) {
+        lines.push(`Oldest: ${new Date(summary.oldest.time).toISOString().slice(0, 10)} ${JSON.stringify(summary.oldest.title)}`);
+    }
+    if (summary.newest) {
+        lines.push(`Newest: ${new Date(summary.newest.time).toISOString().slice(0, 10)} ${JSON.stringify(summary.newest.title)}`);
+    }
+    const modelEntries = Object.entries(summary.models).sort(([, a], [, b]) => b - a);
+    if (modelEntries.length > 0) {
+        const modelStr = modelEntries.map(([m, c]) => `${m} (${c})`).join(", ");
+        lines.push(`${summary.provider === "organelle" ? "Agent types" : "Models"}: ${modelStr}`);
+    }
+    return lines;
+}
+/** The bare `brane absorb` inventory: what this machine has, what an import
+ *  would do with it, and what brane recognised but cannot read yet. */
+export function formatSurvey(survey) {
+    const lines = [];
+    lines.push(`Session stores under ${survey.home}:`);
+    lines.push("");
+    const supported = survey.sources.filter((s) => s.supported);
+    const probes = survey.sources.filter((s) => !s.supported && s.found);
+    for (const s of supported) {
+        if (!s.found || !s.sessions) {
+            lines.push(`  ${s.label.padEnd(36)} not found (${s.path})`);
+            continue;
+        }
+        const n = s.sessions;
+        const parts = [];
+        if (n.new > 0)
+            parts.push(`${n.new} new`);
+        if (n.changed > 0)
+            parts.push(`${n.changed} changed`);
+        if (n.reparse > 0)
+            parts.push(`${n.reparse} to re-read (newer parser)`);
+        if (n.unchanged > 0)
+            parts.push(`${n.unchanged} unchanged`);
+        if (n.managed > 0)
+            parts.push(`${n.managed} managed by brane`);
+        lines.push(`  ${s.label.padEnd(36)} ${n.total} sessions, ${formatBytes(n.bytes)}, ${n.folds} director${n.folds === 1 ? "y" : "ies"}  (${s.path})`);
+        if (parts.length > 0)
+            lines.push(`  ${"".padEnd(36)} ${parts.join(", ")}`);
+        if (n.oldest !== null && n.newest !== null) {
+            lines.push(`  ${"".padEnd(36)} ${new Date(n.oldest).toISOString().slice(0, 10)} … ${new Date(n.newest).toISOString().slice(0, 10)}`);
+        }
+        if (n.new + n.changed + n.reparse > 0) {
+            lines.push(`  ${"".padEnd(36)} brane absorb ${s.name} --dry-run`);
+        }
+    }
+    if (probes.length > 0) {
+        lines.push("");
+        lines.push("Found, no extractor yet:");
+        for (const s of probes)
+            lines.push(`  ${s.label.padEnd(36)} ${s.path}`);
+    }
+    lines.push("");
+    lines.push("Nothing was read or imported. An import reads the store and writes ~/.brane/brane.db; nothing leaves this machine.");
+    return lines;
+}
+function nextSteps(provider) {
+    return [
+        "",
+        "Next:",
+        `  brane meld                                      View in the app`,
+        `  brane memory index                              Index for semantic search`,
+        `  brane memory search "that thing we discussed"   Search your ${provider} history`,
+    ];
+}
+//# sourceMappingURL=absorb.js.map

package/dist/commands/attach.js

@@ -0,0 +1,31 @@
+import { defineCommand } from "citty";
+import { execFileSync } from "node:child_process";
+import { resolveTmux } from "../tmux.js";
+export const attachCommand = defineCommand({
+    meta: {
+        name: "attach",
+        description: "Attach to a tmux session",
+    },
+    args: {
+        id: {
+            type: "positional",
+            required: true,
+            description: "Session/narrative ID to attach to",
+        },
+    },
+    run({ args }) {
+        // Check session exists
+        try {
+            execFileSync(resolveTmux(), ["has-session", "-t", args.id], { stdio: "ignore" });
+        }
+        catch {
+            console.error(`No tmux session found: ${args.id}`);
+            process.exit(1);
+        }
+        // Replace current process with tmux attach
+        execFileSync(resolveTmux(), ["attach-session", "-t", args.id], {
+            stdio: "inherit",
+        });
+    },
+});
+//# sourceMappingURL=attach.js.map