@phnx-labs/agents-cli 1.22.120 → 1.22.121

package/dist/lib/session/fork.d.ts

@@ -1,60 +1,20 @@
-/**
- * Session forking — branch an existing conversation into a new, independent
- * sibling that continues the work, leaving the original untouched.
- *
- * `resume` continues the SAME conversation (same id, same file — it appends).
- * `fork` launches a NEW same-harness session, load-balanced, seeded with a
- * recap of the source so it picks up where the original left off. This is the
- * "git branch" of conversations.
- *
- * The recap — not a transcript copy — is what makes fork work across every
- * device and every REPL harness: the sibling is handed plain text as its opening
- * input, so it never has to reach a transcript that may live on another box. The
- * source is resolved cross-fleet by the same resolver `preview` uses; this module
- * owns only the pure recap text the resolved data folds into.
- */
-import type { SessionMeta } from './types.js';
-/** File-change tally as `sessions preview --json` serializes it (digest.changes). */
+import type { SessionMeta } from '@phnx-labs/sessions-cli/reader';
 interface ForkRecapChanges {
     created: number;
     modified: number;
     deleted: number;
 }
-/** Everything the recap seed is built from — resolved cross-fleet before launch. */
 interface ForkRecapInput {
-    /** Source harness id — the sibling launches the same one. */
     agent: string;
-    /** Display label for the source (label → topic → short id, resolved by the caller). */
     label: string;
-    /** Source working directory, so the sibling re-roots itself. */
     cwd?: string;
-    /** Linear/GitHub ticket the source was bound to, if any. */
     ticketId?: string;
-    /** Device that owns the source transcript, for the `/continue` escape hatch. */
     machine?: string;
-    /** Short + full id, so the sibling can pull full history with `/continue <id>`. */
     shortId: string;
     id: string;
-    /** The source's last assistant line — the single best "where it left off" signal. */
     lastAssistant?: string;
-    /** Changed-files tally so far. */
     changes?: ForkRecapChanges;
 }
-/**
- * Resolve the human display label the caller passes in from a raw SessionMeta.
- *
- * Pass the session WHOLE. A caller that re-lists fields into an object literal
- * can legally omit the optional `generatedTitle` — the type system does not
- * flag a missing optional property — and the headline then silently degrades to
- * `topic`. That is what the fork call site did (PHNX-3797); the rebuilt-literal
- * shape is caught by `title.ladder-completeness.test.ts`.
- */
 export declare function forkLabelFor(session: Pick<SessionMeta, 'label' | 'generatedTitle' | 'topic' | 'shortId'>): string;
-/**
- * Build the recap-seed prompt handed to the forked sibling as its opening input.
- *
- * Pure and deterministic (unit-tested) — no filesystem, no spawn — so the launch
- * orchestration in `commands/fork.ts` stays the only side-effecting layer.
- */
 export declare function buildForkRecap(input: ForkRecapInput): string;
 export {};

package/dist/lib/session/fork.js

@@ -1,33 +1,14 @@
 import { sessionHeadline } from './title.js';
-/** Longest last-assistant excerpt carried into the seed — enough to convey intent
- * without pasting a wall of text (decision: Recap, not Full digest). */
 const LAST_LINE_CAP = 400;
-/** Collapse whitespace and cap length so a multi-paragraph final message becomes
- * one scannable recap line. */
 function trimLastLine(text) {
     const collapsed = text.replace(/\s+/g, ' ').trim();
     if (collapsed.length <= LAST_LINE_CAP)
         return collapsed;
     return `${collapsed.slice(0, LAST_LINE_CAP).trimEnd()}…`;
 }
-/**
- * Resolve the human display label the caller passes in from a raw SessionMeta.
- *
- * Pass the session WHOLE. A caller that re-lists fields into an object literal
- * can legally omit the optional `generatedTitle` — the type system does not
- * flag a missing optional property — and the headline then silently degrades to
- * `topic`. That is what the fork call site did (PHNX-3797); the rebuilt-literal
- * shape is caught by `title.ladder-completeness.test.ts`.
- */
 export function forkLabelFor(session) {
     return sessionHeadline(session) || session.shortId;
 }
-/**
- * Build the recap-seed prompt handed to the forked sibling as its opening input.
- *
- * Pure and deterministic (unit-tested) — no filesystem, no spawn — so the launch
- * orchestration in `commands/fork.ts` stays the only side-effecting layer.
- */
 export function buildForkRecap(input) {
     const lines = [];
     lines.push(`Continue a prior ${input.agent} session ("${input.label}"). Pick up where it left off — do not restart it.`);

package/dist/lib/session/ghostty-tabs.d.ts

@@ -1,33 +1,9 @@
-/**
- * Best-effort Ghostty tab-number detection for `agents sessions --active`.
- *
- * Ghostty (macOS) exposes read-only AppleScript: every tab has an `index` and a
- * `name` (title); every surface a `working directory`. It exposes NO per-tab env
- * var and NO tty/pid on a surface — so a session is matched to its tab by
- * `working directory` (with title as a tiebreak). This is display sugar only:
- * one bounded, non-fatal osascript call, run by the renderer, never on the
- * discovery / --json / --waiting path. Any failure (Ghostty not running,
- * Automation permission denied, timeout) degrades silently to no tab number.
- */
 import type { ActiveSession } from './active.js';
-/** One Ghostty surface (terminal), flattened from window -> tab -> surface. */
 export interface GhosttySurface {
     windowIndex: number;
     tabIndex: number;
     cwd: string;
     title: string;
 }
-/**
- * Enumerate every Ghostty surface (window/tab/cwd/title) via one read-only
- * osascript call. Returns [] on ANY failure — Ghostty not running, Automation
- * permission not granted, timeout, or a parse miss. Never throws, never prompts.
- */
 export declare function enumerateGhosttyTabs(timeoutMs?: number): Promise<GhosttySurface[]>;
-/**
- * Assign a Ghostty tab number to each `host === 'ghostty'` session by matching
- * its cwd to a surface's working directory; ties (same cwd) are broken by title
- * containment against the session's label/topic/kind. Deliberately conservative:
- * a session that can't be uniquely resolved gets NO number — a wrong jump target
- * is worse than none. Pure and unit-tested.
- */
 export declare function assignGhosttyTabs(sessions: ActiveSession[], surfaces: GhosttySurface[]): Map<ActiveSession, number>;

package/dist/lib/session/ghostty-tabs.js

@@ -1,20 +1,6 @@
-/**
- * Best-effort Ghostty tab-number detection for `agents sessions --active`.
- *
- * Ghostty (macOS) exposes read-only AppleScript: every tab has an `index` and a
- * `name` (title); every surface a `working directory`. It exposes NO per-tab env
- * var and NO tty/pid on a surface — so a session is matched to its tab by
- * `working directory` (with title as a tiebreak). This is display sugar only:
- * one bounded, non-fatal osascript call, run by the renderer, never on the
- * discovery / --json / --waiting path. Any failure (Ghostty not running,
- * Automation permission denied, timeout) degrades silently to no tab number.
- */
 import { execFile } from 'child_process';
 import { promisify } from 'util';
 const execFileAsync = promisify(execFile);
-// Field delimiter: ASCII Unit Separator (0x1F). AppleScript's `tab` keyword does
-// not resolve to a tab byte via `osascript -e`, but `character id 31` does — and
-// 0x1F never appears in a cwd or a tab title, so parsing is unambiguous.
 const ENUM_SCRIPT = `tell application "Ghostty"
   set fd to (character id 31)
   set out to ""
@@ -30,11 +16,6 @@ const ENUM_SCRIPT = `tell application "Ghostty"
   end repeat
   return out
 end tell`;
-/**
- * Enumerate every Ghostty surface (window/tab/cwd/title) via one read-only
- * osascript call. Returns [] on ANY failure — Ghostty not running, Automation
- * permission not granted, timeout, or a parse miss. Never throws, never prompts.
- */
 export async function enumerateGhosttyTabs(timeoutMs = 1500) {
     if (process.platform !== 'darwin')
         return [];
@@ -65,26 +46,12 @@ export async function enumerateGhosttyTabs(timeoutMs = 1500) {
     }
     return out;
 }
-/** Trailing-slash-insensitive cwd key. */
 function cwdKey(p) {
     return (p ?? '').replace(/\/+$/, '');
 }
-/**
- * Normalize a tab title / hint for containment matching: drop a leading run of
- * non-alphanumerics (Ghostty prefixes the title with a spinner glyph like `⠐ `
- * or `✳ ` while the agent runs) and lowercase. Without this, a title that starts
- * with the session's exact topic still fails a substring test.
- */
 function normText(s) {
     return s.replace(/^[^\p{L}\p{N}]+/u, '').toLowerCase().trim();
 }
-/**
- * Assign a Ghostty tab number to each `host === 'ghostty'` session by matching
- * its cwd to a surface's working directory; ties (same cwd) are broken by title
- * containment against the session's label/topic/kind. Deliberately conservative:
- * a session that can't be uniquely resolved gets NO number — a wrong jump target
- * is worse than none. Pure and unit-tested.
- */
 export function assignGhosttyTabs(sessions, surfaces) {
     const result = new Map();
     if (surfaces.length === 0)
@@ -108,9 +75,6 @@ export function assignGhosttyTabs(sessions, surfaces) {
             result.set(sess, candidates[0].tabIndex);
             continue;
         }
-        // Tie: break by title containment (glyph-stripped, lowercased). Hints are
-        // what the session knows about itself; a good hint is >=8 chars so short
-        // fragments don't cause spurious matches.
         const hints = [sess.label, sess.topic, sess.preview]
             .filter((h) => !!h && normText(h).length >= 8)
             .map(normText);
@@ -118,7 +82,6 @@ export function assignGhosttyTabs(sessions, surfaces) {
             const title = normText(c.title);
             return title.length >= 8 && hints.some(h => title.includes(h) || h.includes(title));
         });
-        // Only assign when the tiebreak is unambiguous (exactly one title match).
         if (matches.length === 1)
             result.set(sess, matches[0].tabIndex);
     }

package/dist/lib/session/glance-files.d.ts

@@ -0,0 +1,19 @@
+import type { SessionEvent, SessionSubagent } from '@phnx-labs/sessions-cli/reader';
+import type { ActiveSession } from './active.js';
+export declare function resolvedSubAgentCount(children: readonly string[] | undefined, toolCount: number): number;
+export declare function claudeSubagentFiles(sessionFile: string): string[] | undefined;
+export declare function readSessionSubagents(sessionFile: string, parentLive: boolean, failedCalls?: readonly string[], nowMs?: number): SessionSubagent[] | undefined;
+export declare function hasOpenInlineImage(sessionId: string): boolean;
+export declare function dropOpenInlineImage(sessionId: string): void;
+export declare function appendInlineImage(sessionId: string, chunk: string, mediaType: string): void;
+export declare function finishInlineImage(sessionId: string, root?: string): void;
+export declare function takePendingImagePaths(sessionId: string): {
+    path: string;
+    size: number;
+}[];
+export declare function cacheInlineImage(sessionId: string, data: string, mediaType: string, root?: string): {
+    path: string;
+    size: number;
+} | undefined;
+export declare function materializeInlineImages(events: SessionEvent[], sessionId: string, root?: string): void;
+export declare function enrichGlanceFiles(rows: ActiveSession[], nowMs?: number): void;

package/dist/lib/session/glance-files.js

@@ -0,0 +1,258 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { createHash } from 'node:crypto';
+import { getUserAgentsDir } from '../state.js';
+import { indexArtifactSidecars, mergeArtifacts, parseClaudeContent, sanitizeEvents } from '@phnx-labs/sessions-cli/reader';
+const directoryCache = new Map();
+const childFolds = new Map();
+const MAX_CHILD_BYTES_PER_READ = 256 * 1024;
+const MAX_CHILD_PENDING_BYTES = 1024 * 1024;
+export function resolvedSubAgentCount(children, toolCount) {
+    return children && children.length > 0 ? Math.min(30, children.length) : toolCount;
+}
+export function claudeSubagentFiles(sessionFile) {
+    const dir = path.resolve(sessionFile.replace(/\.jsonl$/, ''), 'subagents');
+    try {
+        const { mtimeMs } = fs.statSync(dir);
+        let cached = directoryCache.get(dir);
+        if (!cached || cached.mtimeMs !== mtimeMs) {
+            const files = fs.readdirSync(dir, { withFileTypes: true })
+                .filter(entry => entry.isFile() && /^agent-.+\.jsonl$/.test(entry.name))
+                .map(entry => path.join(dir, entry.name));
+            cached = { mtimeMs, files };
+            if (directoryCache.size >= 512)
+                directoryCache.clear();
+            directoryCache.set(dir, cached);
+        }
+        return cached.files;
+    }
+    catch {
+        return undefined;
+    }
+}
+function foldChildEvents(fold, events) {
+    for (const event of events) {
+        const atMs = Date.parse(event.timestamp);
+        if (Number.isFinite(atMs)) {
+            fold.startedAtMs = Math.min(fold.startedAtMs ?? atMs, atMs);
+            fold.endedAtMs = Math.max(fold.endedAtMs ?? atMs, atMs);
+        }
+        if (event.type === 'tool_use' && !event._local)
+            fold.toolCount++;
+        if (event.type === 'message' && event.role === 'assistant' && event.content) {
+            fold.resultExcerpt = event.content.slice(0, 200);
+        }
+    }
+}
+function advanceChild(file, fold, size) {
+    if (size < fold.offset) {
+        fold.offset = 0;
+        fold.pending = '';
+        fold.toolCount = 0;
+        fold.startedAtMs = undefined;
+        fold.endedAtMs = undefined;
+        fold.resultExcerpt = undefined;
+    }
+    const end = Math.min(size, fold.offset + MAX_CHILD_BYTES_PER_READ);
+    if (end <= fold.offset)
+        return;
+    const fd = fs.openSync(file, 'r');
+    try {
+        const buffer = Buffer.alloc(end - fold.offset);
+        const read = fs.readSync(fd, buffer, 0, buffer.length, fold.offset);
+        fold.offset += read;
+        const text = fold.pending + buffer.toString('utf8', 0, read);
+        const lastNl = text.lastIndexOf('\n');
+        const complete = lastNl >= 0 ? text.slice(0, lastNl + 1) : '';
+        fold.pending = lastNl >= 0 ? text.slice(lastNl + 1) : text;
+        if (Buffer.byteLength(fold.pending) > MAX_CHILD_PENDING_BYTES)
+            fold.pending = '';
+        if (!complete)
+            return;
+        const events = parseClaudeContent(complete);
+        sanitizeEvents(events);
+        foldChildEvents(fold, events);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+export function readSessionSubagents(sessionFile, parentLive, failedCalls = [], nowMs = Date.now()) {
+    const files = claudeSubagentFiles(sessionFile);
+    if (!files)
+        return undefined;
+    const rows = [];
+    for (const file of files) {
+        try {
+            const stat = fs.statSync(file);
+            const metaPath = file.replace(/\.jsonl$/, '.meta.json');
+            let metaStamp = '';
+            try {
+                const metaStat = fs.statSync(metaPath);
+                metaStamp = `${metaStat.mtimeMs}:${metaStat.size}`;
+            }
+            catch { }
+            let fold = childFolds.get(file);
+            if (!fold || fold.metaStamp !== metaStamp) {
+                let meta = {};
+                if (metaStamp) {
+                    try {
+                        meta = JSON.parse(fs.readFileSync(metaPath, 'utf8'));
+                    }
+                    catch { }
+                }
+                fold = {
+                    offset: fold?.offset ?? 0,
+                    pending: fold?.pending ?? '',
+                    size: fold?.size ?? 0,
+                    metaStamp,
+                    mtimeMs: stat.mtimeMs,
+                    toolCount: fold?.toolCount ?? 0,
+                    startedAtMs: fold?.startedAtMs,
+                    endedAtMs: fold?.endedAtMs,
+                    resultExcerpt: fold?.resultExcerpt,
+                    agentType: typeof meta.agentType === 'string' ? meta.agentType : '',
+                    description: typeof meta.description === 'string' ? meta.description : '',
+                    toolUseId: typeof meta.toolUseId === 'string' ? meta.toolUseId : undefined,
+                };
+                if (childFolds.size >= 512)
+                    childFolds.clear();
+                childFolds.set(file, fold);
+            }
+            if (fold.size !== stat.size || fold.offset < stat.size) {
+                advanceChild(file, fold, stat.size);
+                fold.size = stat.size;
+                fold.mtimeMs = stat.mtimeMs;
+            }
+            const status = fold.toolUseId && failedCalls.includes(fold.toolUseId)
+                ? 'failed'
+                : parentLive && nowMs - fold.mtimeMs < 120_000 ? 'running' : 'done';
+            rows.push({
+                id: path.basename(file, '.jsonl'),
+                agentType: fold.agentType,
+                description: fold.description,
+                status,
+                ...(fold.startedAtMs !== undefined ? { startedAtMs: fold.startedAtMs, endedAtMs: fold.endedAtMs } : {}),
+                toolCount: fold.toolCount,
+                ...(fold.resultExcerpt ? { resultExcerpt: fold.resultExcerpt } : {}),
+                transcriptPath: file,
+            });
+        }
+        catch { }
+    }
+    return rows.sort((a, b) => (a.startedAtMs ?? 0) - (b.startedAtMs ?? 0) || a.id.localeCompare(b.id)).slice(0, 30);
+}
+const IMAGE_EXTENSIONS = { 'image/png': 'png', 'image/jpeg': 'jpg', 'image/gif': 'gif', 'image/webp': 'webp' };
+const MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+const MAX_IMAGE_BASE64 = Math.ceil(MAX_IMAGE_BYTES * 4 / 3) + 4;
+const openInlineImages = new Map();
+const pendingImagePaths = new Map();
+export function hasOpenInlineImage(sessionId) {
+    return openInlineImages.has(sessionId);
+}
+export function dropOpenInlineImage(sessionId) {
+    openInlineImages.delete(sessionId);
+    pendingImagePaths.delete(sessionId);
+}
+export function appendInlineImage(sessionId, chunk, mediaType) {
+    if (!chunk)
+        return;
+    let open = openInlineImages.get(sessionId);
+    if (!open) {
+        open = { base64: '', mediaType, dropped: false };
+        openInlineImages.set(sessionId, open);
+    }
+    if (open.dropped || open.base64.length + chunk.length > MAX_IMAGE_BASE64) {
+        open.dropped = true;
+        open.base64 = '';
+        return;
+    }
+    open.base64 += chunk;
+}
+export function finishInlineImage(sessionId, root) {
+    const open = openInlineImages.get(sessionId);
+    openInlineImages.delete(sessionId);
+    if (!open || open.dropped || !open.base64)
+        return;
+    const cached = cacheInlineImage(sessionId, open.base64, open.mediaType, root);
+    if (!cached)
+        return;
+    const list = pendingImagePaths.get(sessionId) ?? [];
+    list.push(cached);
+    pendingImagePaths.set(sessionId, list);
+}
+export function takePendingImagePaths(sessionId) {
+    const list = pendingImagePaths.get(sessionId) ?? [];
+    pendingImagePaths.delete(sessionId);
+    return list;
+}
+export function cacheInlineImage(sessionId, data, mediaType, root = path.join(getUserAgentsDir(), '.cache', 'attachments')) {
+    const safe = Boolean(sessionId) && path.basename(sessionId) === sessionId && sessionId !== '.' && sessionId !== '..';
+    const ext = IMAGE_EXTENSIONS[mediaType];
+    if (!safe || !data || !ext || Buffer.byteLength(data, 'base64') > MAX_IMAGE_BYTES)
+        return undefined;
+    const bytes = Buffer.from(data, 'base64');
+    if (!bytes.length)
+        return undefined;
+    const dir = path.join(root, sessionId);
+    const name = `${createHash('sha256').update(bytes).digest('hex')}.${ext}`;
+    const file = path.join(dir, name);
+    try {
+        fs.mkdirSync(dir, { recursive: true });
+        fs.chmodSync(dir, 0o700);
+        const images = new Set(fs.readdirSync(dir));
+        if (!images.has(name)) {
+            if (images.size >= 10)
+                return undefined;
+            try {
+                fs.writeFileSync(file, bytes, { flag: 'wx', mode: 0o600 });
+            }
+            catch (err) {
+                if (err.code !== 'EEXIST')
+                    throw err;
+            }
+            fs.chmodSync(file, 0o600);
+        }
+        return { path: file, size: bytes.length };
+    }
+    catch {
+        return undefined;
+    }
+}
+export function materializeInlineImages(events, sessionId, root = path.join(getUserAgentsDir(), '.cache', 'attachments')) {
+    for (const event of events) {
+        const data = event._imageData;
+        delete event._imageData;
+        if (!data || event.path || event.type !== 'attachment')
+            continue;
+        const cached = cacheInlineImage(sessionId, data, event.mediaType ?? '', root);
+        if (!cached)
+            continue;
+        event.path = cached.path;
+        event.sizeBytes = cached.size;
+    }
+}
+export function enrichGlanceFiles(rows, nowMs = Date.now()) {
+    const artifacts = indexArtifactSidecars(path.join(getUserAgentsDir(), 'artifacts'), nowMs);
+    for (const row of rows) {
+        if (!row.sessionId)
+            continue;
+        row.artifacts = mergeArtifacts(row.artifacts ?? [], artifacts.get(row.sessionId) ?? []);
+        if (!row.artifacts.length)
+            delete row.artifacts;
+        const plan = row.artifacts?.find(artifact => artifact.bucket === 'plans')?.path;
+        if (plan)
+            row.planFile = plan;
+        if (row.kind === 'claude' && row.sessionFile) {
+            const files = claudeSubagentFiles(row.sessionFile);
+            if (!files || files.length === 0)
+                continue;
+            const subagents = readSessionSubagents(row.sessionFile, row.pidAlive === true, [], nowMs);
+            if (!subagents?.length)
+                continue;
+            const failed = new Set(row.subagents?.filter(agent => agent.status === 'failed').map(agent => agent.id));
+            row.subagents = subagents.map(agent => failed.has(agent.id) ? { ...agent, status: 'failed' } : agent);
+            row.subAgentCount = row.subagents.length;
+        }
+    }
+}

package/dist/lib/session/hook-sessions.d.ts

@@ -1,5 +1,4 @@
 import { type PidSessionEntry } from './pid-registry.js';
-/** The subset of the hook's on-disk record this reader relies on. Extra fields are ignored. */
 export interface HookSessionRecord {
     session_id: string;
     agent?: string;
@@ -10,54 +9,22 @@ export interface HookSessionRecord {
     ts?: number;
     completed?: boolean;
 }
-/** Pre-built lookup maps over one scan of the hook state dir. */
 export interface HookSessionIndex {
     byLaunchId: Map<string, HookSessionRecord>;
     byTerminalId: Map<string, HookSessionRecord>;
     byPid: Map<number, HookSessionRecord>;
 }
-/**
- * Read the deployed hook's record for one specific pid, or undefined if absent /
- * corrupt / not fresh. `startedAtMs` (the live process's known start, when the
- * caller has it) rejects a stale record left by a PRIOR process at a reused pid:
- * the hook writes its record AFTER the agent boots, so a record whose `ts`
- * predates the current process's start belongs to a dead predecessor. `ts` is
- * Unix SECONDS (the hook stamps `date +%s`); `startedAtMs` is millis.
- */
 export declare function readStateSessionRecord(pid: number, startedAtMs?: number): HookSessionRecord | undefined;
-/** Capture ownership while the launched wrapper is alive. The deployed hook
- * walks ancestors to this registry entry and preserves these launcher fields. */
 export declare function captureLaunchBinding(pid: number | undefined, launchId: string): PidSessionEntry | undefined;
-/** Completion consumes the hook's launcher-keyed registry update, never a
- * numeric-PID metadata guess. The hook PID can be any descendant of the wrapper.
- * Ownership was measured before exit; matching the unique launch and preserved
- * start timestamp prevents a reused slot from supplying another run's id. */
 export declare function recordCompletedLaunch(binding: PidSessionEntry | undefined): void;
-/**
- * Scan the hook state dir once and index every record by launch_id, terminal_id,
- * and pid. Returns empty maps if the dir is absent. Newest-by-`ts` wins a key
- * collision (pid reuse, or a launch id lingering from a since-dead process).
- */
 export declare function loadHookSessionIndex(): HookSessionIndex;
 interface ResolveOpts {
     pid: number;
     kind: string;
     launchId?: string;
     terminalId?: string;
-    /** Immediate child pids of `pid` — the hook records under the agent pid, which
-     *  for a wrapper/shell pid we recorded is a child. */
     childPids?: number[];
 }
-/**
- * Resolve an agent's OWN authoritative session id from the hook index. Priority
- * mirrors the session-tracker's getLiveSession: launchId join (survives pid
- * divergence — the hook runs under the agent pid, our registry entry may sit on a
- * tmux pane leaf or cmd.exe wrapper) → terminalId join → direct pid → children.
- * Every hit is kind-guarded so a stale file at a reused pid can't cross agents.
- * Undefined until the hook lands (it can lag the spawn) or for hookless harnesses.
- */
 export declare function resolveHookSessionRecord(index: HookSessionIndex, opts: ResolveOpts): HookSessionRecord | undefined;
-/** The session id alone — see {@link resolveHookSessionRecord} for the full record
- *  (which also carries the SessionStart `ts` used to stamp `startedAtMs`). */
 export declare function resolveHookSessionId(index: HookSessionIndex, opts: ResolveOpts): string | undefined;
 export {};