@phnx-labs/agents-cli 1.22.112 → 1.22.114

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

@@ -1,6 +1,6 @@
 /** A session's foreground/background presence. */
 export type Presence = 'attached' | 'background' | 'parked';
-export interface DetachRecord {
+interface DetachRecord {
     sessionId: string;
     agent: string;
     cwd?: string;
@@ -28,3 +28,4 @@ export declare function isHeadlessAlive(rec: DetachRecord): boolean;
  *   - record + pid exited   -> `parked` (the run finished; transcript is durable)
  */
 export declare function presenceFromStore(sessionId: string): Presence | undefined;
+export {};

package/dist/lib/session/detached.js

@@ -1,6 +1,6 @@
 /**
  * Detached-session store — the record `agents sessions detach` writes and both
- * `agents sessions attach` and the active-session scan read to know an agent is
+ * `agents sessions resume` and the active-session scan read to know an agent is
  * "backgrounded": running headless with no terminal, continuing its task
  * unattended.
  *
@@ -14,7 +14,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { getSystemAgentsDir } from '../state.js';
-import { captureProcessStartTime } from '../pty-server.js';
+import { captureProcessStartTime } from '../platform/process.js';
 function detachedDir() {
     return path.join(getSystemAgentsDir(), 'detached');
 }

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

@@ -13,7 +13,6 @@ export interface FileChange {
     path: string;
     op: FileOp;
 }
-export declare const READ_TOOLS: Set<string>;
 export declare const WRITE_TOOLS: Set<string>;
 export declare const EDIT_TOOLS: Set<string>;
 /**
@@ -51,7 +50,7 @@ export declare function toolHistogram(toolCounts: Record<string, number>, top?:
  * only surfaces repeatable tools.
  */
 export declare function bashToolCounts(events: SessionEvent[]): Record<string, number>;
-export interface TestResult {
+interface TestResult {
     runner: string;
     passed?: number;
     failed?: number;
@@ -64,3 +63,4 @@ export interface TestResult {
  * (tool_use) with the next tool_result's output. Returns undefined if none ran.
  */
 export declare function detectTestResult(events: SessionEvent[]): TestResult | undefined;
+export {};

package/dist/lib/session/digest.js

@@ -10,7 +10,7 @@
 import { bucketKey, classifyBashCommand } from './bash-command.js';
 // Tool vocab mirrors parse.ts / render.ts so classification matches what those
 // modules already recognize across Claude/Codex/others.
-export const READ_TOOLS = new Set(['Read', 'read_file', 'view_file', 'cat_file', 'get_file']);
+const READ_TOOLS = new Set(['Read', 'read_file', 'view_file', 'cat_file', 'get_file']);
 export const WRITE_TOOLS = new Set(['Write', 'write_file', 'create_file', 'Create']);
 export const EDIT_TOOLS = new Set(['Edit', 'edit_file', 'replace', 'patch', 'MultiEdit', 'apply_patch']);
 /**

package/dist/lib/session/discover.js

@@ -823,7 +823,8 @@ function collectChangedFilesInLeafDirs(leafDirs, ext) {
                 let hot = isLiveRoot;
                 if (!hot && stamps) {
                     const s = stamps.get(filePath);
-                    hot = s?.scannedAt !== undefined && now - s.scannedAt <= HOT_FILE_WINDOW_MS;
+                    hot = s?.extractorVersion !== CONTENT_INDEX_VERSION
+                        || (s?.scannedAt !== undefined && now - s.scannedAt <= HOT_FILE_WINDOW_MS);
                 }
                 if (!hot)
                     continue;
@@ -3884,7 +3885,11 @@ function applyCodexLine(state, parsed) {
     }
     if (parsed.type === 'session_meta') {
         const payload = parsed.payload || {};
-        state.sessionId = payload.id || state.sessionId;
+        // Native forks prepend child ownership before inherited parent metadata.
+        // The first valid identity owns this file in both full and resumed scans.
+        if (state.sessionId || typeof payload.id !== 'string' || !payload.id.trim())
+            return;
+        state.sessionId = payload.id;
         state.timestamp = payload.timestamp || parsed.timestamp || state.timestamp;
         state.cwd = payload.cwd || state.cwd;
         state.gitBranch = payload.git?.branch || state.gitBranch;

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

@@ -15,13 +15,13 @@
  */
 import type { SessionMeta } from './types.js';
 /** File-change tally as `sessions preview --json` serializes it (digest.changes). */
-export interface ForkRecapChanges {
+interface ForkRecapChanges {
     created: number;
     modified: number;
     deleted: number;
 }
 /** Everything the recap seed is built from — resolved cross-fleet before launch. */
-export interface ForkRecapInput {
+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). */
@@ -57,3 +57,4 @@ export declare function forkLabelFor(session: Pick<SessionMeta, 'label' | 'gener
  * orchestration in `commands/fork.ts` stays the only side-effecting layer.
  */
 export declare function buildForkRecap(input: ForkRecapInput): string;
+export {};

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

@@ -30,7 +30,7 @@ export declare function isSkillInvocation(e: SessionEvent): boolean;
  * `args.skill` (or `args.name`). Sorted by count desc, then name.
  */
 export declare function extractSkills(events: SessionEvent[]): SkillUse[];
-export interface SlashCommandUse {
+interface SlashCommandUse {
     /** WITH the leading slash, e.g. `/recap`, `/code:commit` — matches SessionEvent.slashCommand's shape. */
     name: string;
     count: number;
@@ -43,7 +43,7 @@ export interface SlashCommandUse {
  * count desc, then name.
  */
 export declare function extractSlashCommands(events: SessionEvent[]): SlashCommandUse[];
-export interface HookUse {
+interface HookUse {
     /** Hook name as configured, e.g. `SessionStart:startup`. */
     name: string;
     /** Lifecycle event, e.g. `SessionStart`. */
@@ -60,8 +60,8 @@ export interface HookUse {
  * Sorted by count desc, then name.
  */
 export declare function extractHooks(events: SessionEvent[]): HookUse[];
-export type LinkKind = 'linear' | 'jira' | 'github' | 'gitlab' | 'other';
-export interface SessionLink {
+type LinkKind = 'linear' | 'jira' | 'github' | 'gitlab' | 'other';
+interface SessionLink {
     kind: LinkKind;
     url: string;
     /** Short display label: `RUSH-2076`, `PR#1755`, `owner/repo#123`, host. */
@@ -113,7 +113,7 @@ export declare function harnessTracksBackgroundShells(agent: SessionAgentId): bo
  * matching events while streaming instead of re-reading the transcript.
  */
 export declare function isBackgroundShellStart(e: SessionEvent): boolean;
-export interface BackgroundShell {
+interface BackgroundShell {
     /** The command line as invoked, trimmed for display. */
     command: string;
     timestamp: string;
@@ -148,3 +148,4 @@ export declare function extractBackgroundShells(events: SessionEvent[]): Backgro
  * different answer; do not "unify" them.
  */
 export declare function isSubAgentTool(tool: string, command: string): boolean;
+export {};

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

@@ -1,3 +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;
@@ -7,6 +8,7 @@ export interface HookSessionRecord {
     launch_id?: string;
     terminal_id?: string;
     ts?: number;
+    completed?: boolean;
 }
 /** Pre-built lookup maps over one scan of the hook state dir. */
 export interface HookSessionIndex {
@@ -23,13 +25,21 @@ export interface HookSessionIndex {
  * 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;
-export interface ResolveOpts {
+interface ResolveOpts {
     pid: number;
     kind: string;
     launchId?: string;
@@ -50,3 +60,4 @@ export declare function resolveHookSessionRecord(index: HookSessionIndex, opts:
 /** 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 {};

package/dist/lib/session/hook-sessions.js

@@ -19,7 +19,8 @@
  * NOT import the session-tracker package (a separate, workspace-less package;
  * see packages/session-tracker/CLAUDE.md) — mirroring AGI EXT's own
  * hand-copied reader in apps/ext/src/core/liveSession.ts. It only READS the
- * existing dir/schema; it never writes or moves anything, so it is safe across a
+ * existing dir/schema. The owning launcher also records a completed launch
+ * binding in that schema before returning; readers remain read-only across a
  * fleet where old hooks and a new CLI coexist.
  *
  * The whole state dir is scanned ONCE per active-scan into an index (the listing
@@ -27,8 +28,13 @@
  * re-scan per candidate.
  */
 import fs from 'fs';
+import { createHash } from 'node:crypto';
+import { execFileSync } from 'node:child_process';
+import { atomicWriteFileSync } from '../fs-atomic.js';
+import { hostProcessView } from './process-view.js';
 import path from 'path';
 import { getTerminalsDir, getRuntimeStateDir } from '../state.js';
+import { listPidSessionEntries, pidSessionEntryMatchesLiveProcess, readLivePidSessionEntry, readPidSessionEntry } from './pid-registry.js';
 function hookSessionsDir() {
     // Sibling of the pid-registry's by-pid/ dir. The hook hardcodes this same path
     // (packages/session-tracker/src/hook.sh); we read it, never move it.
@@ -97,6 +103,98 @@ function keepNewest(map, key, rec) {
     if (!prev || (rec.ts ?? 0) > (prev.ts ?? 0))
         map.set(key, rec);
 }
+let clockTicks;
+/** Recover an already-running launch after an old reader removed its registry.
+ * Enumerate live PIDs, not the hook's unbounded graveyard. Only decode the one
+ * allowed environment key; no unrelated environment value escapes this reader.
+ * Kernel incarnation and namespace are checked on both sides of the reads. */
+function liveUnregisteredHookRecords() {
+    const scope = hostProcessView();
+    if (process.platform !== 'linux' || !scope?.pidNamespace)
+        return [];
+    try {
+        clockTicks ??= Number(execFileSync('getconf', ['CLK_TCK'], { encoding: 'utf8', timeout: 1000 }));
+        if (!Number.isFinite(clockTicks) || clockTicks <= 0)
+            return [];
+        const bootSeconds = Number(fs.readFileSync('/proc/stat', 'utf8').match(/^btime (\d+)$/m)?.[1]);
+        if (!Number.isFinite(bootSeconds))
+            return [];
+        const result = [];
+        const identity = (pid) => {
+            if (fs.readlinkSync(`/proc/${pid}/ns/pid`) !== scope.pidNamespace)
+                return undefined;
+            const stat = fs.readFileSync(`/proc/${pid}/stat`, 'utf8');
+            const fields = stat.slice(stat.lastIndexOf(')') + 2).split(' ');
+            return fields[0] !== 'Z' && /^\d+$/.test(fields[19]) ? fields[19] : undefined;
+        };
+        const prefix = Buffer.from('AGENT_LAUNCH_ID=');
+        for (const name of fs.readdirSync('/proc')) {
+            if (!/^\d+$/.test(name))
+                continue;
+            const pid = Number(name);
+            try {
+                if (!fs.existsSync(stateSessionRecordPath(pid)))
+                    continue;
+                const before = identity(pid);
+                if (!before)
+                    continue;
+                const rec = readStateSessionRecord(pid);
+                const startedSeconds = bootSeconds + Number(before) / clockTicks;
+                if (!rec || rec.pid !== pid || typeof rec.ts !== 'number'
+                    || rec.ts < Math.floor(startedSeconds) || rec.ts > Date.now() / 1000)
+                    continue;
+                const environment = fs.readFileSync(`/proc/${pid}/environ`);
+                let launchId;
+                for (let start = 0; start < environment.length;) {
+                    const end = environment.indexOf(0, start);
+                    const limit = end < 0 ? environment.length : end;
+                    if (environment.subarray(start, start + prefix.length).equals(prefix)) {
+                        launchId = environment.subarray(start + prefix.length, limit).toString('utf8').trim();
+                        break;
+                    }
+                    start = limit + 1;
+                }
+                if (!launchId || launchId.length > 512 || /[\x00-\x20]/.test(launchId)
+                    || (rec.launch_id && rec.launch_id !== launchId) || identity(pid) !== before)
+                    continue;
+                result.push({ ...rec, launch_id: launchId });
+            }
+            catch { /* exited, inaccessible, or procfs raced: unknown, never prune */ }
+        }
+        return result;
+    }
+    catch {
+        return [];
+    }
+}
+/** Capture ownership while the launched wrapper is alive. The deployed hook
+ * walks ancestors to this registry entry and preserves these launcher fields. */
+export function captureLaunchBinding(pid, launchId) {
+    if (!pid)
+        return undefined;
+    const entry = readLivePidSessionEntry(pid);
+    return entry?.launchId === launchId ? structuredClone(entry) : 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 function recordCompletedLaunch(binding) {
+    if (!binding?.launchId || !hostProcessView())
+        return;
+    const entry = readPidSessionEntry(binding.pid);
+    if (!entry?.sessionId || entry.pid !== binding.pid || entry.launchId !== binding.launchId
+        || entry.startedAtMs !== binding.startedAtMs || entry.agent !== binding.agent)
+        return;
+    const rec = { session_id: entry.sessionId, pid: entry.pid, agent: entry.agent,
+        launch_id: binding.launchId, terminal_id: binding.terminalId, ts: Date.now() / 1000, completed: true };
+    try {
+        fs.mkdirSync(hookSessionsDir(), { recursive: true });
+        const name = createHash('sha256').update(binding.launchId).digest('hex');
+        atomicWriteFileSync(path.join(hookSessionsDir(), `launch-${name}.json`), JSON.stringify(rec), 'utf8');
+    }
+    catch { /* completion must preserve the child exit status */ }
+}
 /**
  * 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
@@ -111,7 +209,7 @@ export function loadHookSessionIndex() {
         files = fs.readdirSync(hookSessionsDir()).filter(f => f.endsWith('.json'));
     }
     catch {
-        return { byLaunchId, byTerminalId, byPid };
+        files = [];
     }
     for (const f of files) {
         let rec;
@@ -123,13 +221,47 @@ export function loadHookSessionIndex() {
         }
         if (!rec)
             continue;
-        if (typeof rec.pid === 'number')
+        if (!rec.completed && typeof rec.pid === 'number')
             keepNewest(byPid, rec.pid, rec);
         if (rec.launch_id)
             keepNewest(byLaunchId, rec.launch_id, rec);
-        if (rec.terminal_id)
+        if (!rec.completed && rec.terminal_id)
             keepNewest(byTerminalId, rec.terminal_id, rec);
     }
+    // Deployed legacy hooks contain only a pid/session id. Join their targeted
+    // records with launch facts instead of requiring a terminal_id they never
+    // wrote. This is read-only: an observer cannot infer host PID liveness.
+    for (const entry of listPidSessionEntries()) {
+        if (!entry.launchId || pidSessionEntryMatchesLiveProcess(entry) !== true)
+            continue;
+        const rec = entry.sessionId
+            ? { session_id: entry.sessionId, pid: entry.pid, ts: entry.startedAtMs / 1000, agent: entry.agent }
+            : readStateSessionRecord(entry.pid, entry.startedAtMs);
+        if (!rec || !kindMatches(rec.agent, entry.agent))
+            continue;
+        if (rec.launch_id && rec.launch_id !== entry.launchId)
+            continue;
+        const joined = { ...rec, agent: rec.agent ?? entry.agent, launch_id: entry.launchId, terminal_id: entry.terminalId };
+        if (!byLaunchId.has(entry.launchId))
+            byLaunchId.set(entry.launchId, joined);
+        if (!byPid.has(entry.pid))
+            byPid.set(entry.pid, joined);
+        if (entry.terminalId && !byTerminalId.has(entry.terminalId))
+            byTerminalId.set(entry.terminalId, joined);
+    }
+    const recovered = new Map();
+    for (const rec of liveUnregisteredHookRecords()) {
+        if (!byPid.has(rec.pid))
+            byPid.set(rec.pid, rec);
+        const previous = recovered.get(rec.launch_id);
+        // Inherited launch metadata cannot disambiguate two different native
+        // sessions. Keep their exact PID identities but refuse the ambiguous join.
+        recovered.set(rec.launch_id, previous === null || (previous && previous.session_id !== rec.session_id) ? null : rec);
+    }
+    for (const [launchId, rec] of recovered) {
+        if (rec && !byLaunchId.has(launchId))
+            byLaunchId.set(launchId, rec);
+    }
     return { byLaunchId, byTerminalId, byPid };
 }
 /**
@@ -156,13 +288,14 @@ function kindMatches(recordAgent, kind) {
  */
 export function resolveHookSessionRecord(index, opts) {
     const { pid, kind, launchId, terminalId, childPids } = opts;
-    const take = (rec) => rec?.session_id && kindMatches(rec.agent, kind) ? rec : undefined;
+    const take = (rec) => rec?.session_id && kindMatches(rec.agent, kind)
+        && (!launchId || !rec.launch_id || rec.launch_id === launchId) ? rec : undefined;
     if (launchId) {
         const hit = take(index.byLaunchId.get(launchId));
         if (hit)
             return hit;
     }
-    if (terminalId) {
+    if (terminalId && !launchId) {
         const hit = take(index.byTerminalId.get(terminalId));
         if (hit)
             return hit;

package/dist/lib/session/host-link.d.ts

@@ -55,7 +55,7 @@ export type HostLink =
  * the extension agree on when a window is dead.
  */
 export declare const HOST_HEARTBEAT_STALE_MS: number;
-export interface HostLinkInput {
+interface HostLinkInput {
     /** The agent process is still alive (already pid-reuse-checked by the caller). */
     pidAlive: boolean;
     /**
@@ -102,3 +102,4 @@ export declare function classifyHostLink(input: HostLinkInput): HostLink;
  * Pure — same injected signals as the classifier.
  */
 export declare function hostWindowLost(input: HostLinkInput): boolean;
+export {};

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

@@ -13,6 +13,6 @@ import type { InjectTarget } from '../terminal/index.js';
 /**
  * Map a session's `ReplyRail` to an engine `InjectTarget`. Today only tmux rails
  * are externally addressable (provenance.ts:143-149); a null rail yields null and
- * the caller must supply a target another way (a pty id, a macOS window).
+ * the caller must supply a target another way (a macOS window).
  */
 export declare function injectTargetFromReplyRail(rail: ReplyRail): InjectTarget | null;

package/dist/lib/session/inject.js

@@ -11,7 +11,7 @@
 /**
  * Map a session's `ReplyRail` to an engine `InjectTarget`. Today only tmux rails
  * are externally addressable (provenance.ts:143-149); a null rail yields null and
- * the caller must supply a target another way (a pty id, a macOS window).
+ * the caller must supply a target another way (a macOS window).
  */
 export function injectTargetFromReplyRail(rail) {
     if (rail && rail.rail === 'tmux') {

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

@@ -21,14 +21,6 @@
  *     the raw file count rather than quietly differing.
  */
 import type { SessionEvent } from './types.js';
-/**
- * Minimum quiet time after the assistant's last event before a user message
- * is classified as an **agent silent stall**: the model went quiet on its own
- * and sat idle until the human resumed. Shorter gaps are normal turn-taking.
- * 5 minutes is long enough to exclude "user typing the next instruction" and
- * short enough to catch "went silent mid-task until I said continue."
- */
-export declare const SILENT_STALL_SECONDS = 300;
 /** Behavioural facets of one session. Serialized as JSON into `session_insights`. */
 export interface InsightFacets {
     toolCounts: Record<string, number>;
@@ -112,11 +104,6 @@ export interface InsightFacets {
  * can be re-bucketed for a different display timezone without re-parsing.
  */
 export declare function computeInsightFacets(events: SessionEvent[], timezoneOffsetMinutes?: number): InsightFacets;
-/**
- * Classify a long quiet gap after the assistant's last event as an agent silent stall.
- * Optionally also marks an explicit resume nudge ("continue", …) after that silence.
- */
-export declare function classifySilentStall(gapSeconds: number, userText: string, friction: Record<string, number>, corrections: Record<string, number>): void;
 /** Percentile of a numeric sample, nearest-rank. Returns 0 for an empty sample. */
 export declare function percentile(values: number[], p: number): number;
 /** Bucket response gaps for display. Returns every bucket, including empty ones. */
@@ -132,7 +119,7 @@ export interface SessionSpan {
     endMs: number;
 }
 /** How much work ran concurrently, and how much of it straddled two accounts. */
-export interface OverlapReport {
+interface OverlapReport {
     /** Pairs of sessions whose spans intersect. */
     overlappingPairs: number;
     /** Of those, pairs belonging to DIFFERENT accounts. */
@@ -169,9 +156,10 @@ export interface InsightAction {
     evidenceCount: number;
     sampleSessionIds: string[];
 }
-export interface SessionFacetEvidence {
+interface SessionFacetEvidence {
     id: string;
     facets: InsightFacets;
 }
 /** Build a stable, evidence-backed action list without exposing transcript text. */
 export declare function buildInsightActions(sessions: SessionFacetEvidence[]): InsightAction[];
+export {};

package/dist/lib/session/insights.js

@@ -60,7 +60,7 @@ const GAP_CEILING_SECONDS = 3600;
  * 5 minutes is long enough to exclude "user typing the next instruction" and
  * short enough to catch "went silent mid-task until I said continue."
  */
-export const SILENT_STALL_SECONDS = 300;
+const SILENT_STALL_SECONDS = 300;
 /** Response-gap buckets, in ascending order. Upper bound is exclusive. */
 const GAP_BUCKETS = [
     ['<10s', 10], ['10-30s', 30], ['30s-1m', 60], ['1-2m', 120],
@@ -326,7 +326,7 @@ const RESUME_NUDGE_PATTERN = /\b(?:continue|keep going|don'?t stop|resume|pick u
  * Classify a long quiet gap after the assistant's last event as an agent silent stall.
  * Optionally also marks an explicit resume nudge ("continue", …) after that silence.
  */
-export function classifySilentStall(gapSeconds, userText, friction, corrections) {
+function classifySilentStall(gapSeconds, userText, friction, corrections) {
     for (const [label, min, max] of SILENT_STALL_BUCKETS) {
         if (gapSeconds >= min && gapSeconds < max) {
             bump(friction, label);

package/dist/lib/session/local-tmux-attach.d.ts

@@ -14,24 +14,7 @@ export declare function resolveTmuxAliasState(selector: string, socket?: string)
  * identity to another machine.
  */
 export declare function shouldAttachLocalTmuxAliasBeforeFleet(selector: string | undefined, hosts: string[]): selector is string;
-/**
- * Attach a live tmux session named exactly as the selector, without needing the
- * session index to know anything about it.
- *
- * SES-41 requires a `ag-<agent>-<8hex>` tmux alias to resolve, but the alias's
- * hex is the LAUNCH id, not the harness session id, and for a harness that
- * writes no `state/sessions/<pid>.json` record there is no mapping back to a
- * SessionMeta at all. The pane is the thing the user asked for, and its NAME is
- * sufficient to attach it — so an unattributable session is still reachable
- * instead of being a dead end that forces raw `tmux -S … attach`.
- *
- * Returns false when this is not an alias, the server/session is absent, or
- * every pane is dead — the caller then continues to normal id resolution.
- * SES-39's "re-read `pane_dead` immediately before attach" is honoured here:
- * liveness is queried at attach time, not read from a roster.
- */
-export declare function attachLiveTmuxAlias(selector: string): Promise<boolean>;
-export type LocalAliasBySuffix = {
+type LocalAliasBySuffix = {
     kind: 'alias';
     alias: string;
 } | {
@@ -67,3 +50,4 @@ export declare function resolveUniqueLocalLiveAliasBySuffix(shortId: string, soc
  * resolution / the fleet race.
  */
 export declare function attachLocalLiveSelector(selector: string | undefined, hosts: string[]): Promise<boolean>;
+export {};

package/dist/lib/session/local-tmux-attach.js

@@ -67,7 +67,7 @@ export function shouldAttachLocalTmuxAliasBeforeFleet(selector, hosts) {
  * SES-39's "re-read `pane_dead` immediately before attach" is honoured here:
  * liveness is queried at attach time, not read from a roster.
  */
-export async function attachLiveTmuxAlias(selector) {
+async function attachLiveTmuxAlias(selector) {
     const socket = getDefaultSocketPath();
     if (await resolveTmuxAliasState(selector, socket) !== 'live')
         return false;

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

@@ -24,7 +24,6 @@ export interface MigrationRecord {
     status: 'completed' | 'failed';
     error?: string;
 }
-export declare function migrationsLedgerPath(): string;
 /**
  * Append one migration event. A ledger write must never break a migration that
  * otherwise succeeded, so a write failure is a visible warning, not a throw.

package/dist/lib/session/migrations.js

@@ -13,7 +13,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import chalk from 'chalk';
 import { homeDir } from '../platform/paths.js';
-export function migrationsLedgerPath() {
+function migrationsLedgerPath() {
     return path.join(homeDir(), '.agents', '.history', 'migrations.jsonl');
 }
 /**

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

@@ -21,10 +21,6 @@
  * consume so its DB is not written with rows it never renders.
  */
 import { type ConfiguredDeviceRole } from '../device-config.js';
-/** Cap on sessions published per device — the payload stays what a picker shows. */
-export declare const SESSION_MIRROR_MAX_ROWS = 200;
-/** First-user-message snippet ceiling; the full turn stays on the owning box. */
-export declare const SESSION_MIRROR_SNIPPET_MAX = 280;
 /** Mirror rows older than this since their last sync are pruned (staleness/size ceiling). */
 export declare const SESSION_MIRROR_MAX_AGE_MS: number;
 /** Caps for the timeline block on a published mirror row. */
@@ -32,12 +28,12 @@ export declare const SESSION_MIRROR_MAX_STEPS = 8;
 export declare const SESSION_MIRROR_STEP_TEXT_MAX = 160;
 export declare const SESSION_MIRROR_REQUEST_MAX = 2000;
 export declare const SESSION_MIRROR_MAX_FILES = 8;
-export interface PublishSessionMirrorOptions {
+interface PublishSessionMirrorOptions {
     userAgentsDir?: string;
     device?: string;
     limit?: number;
 }
-export interface PublishSessionMirrorResult {
+interface PublishSessionMirrorResult {
     published: boolean;
     changed: boolean;
     count: number;
@@ -47,14 +43,14 @@ export interface PublishSessionMirrorResult {
 }
 /** Publish this device's most-recent local sessions into its owned shared-state file. */
 export declare function publishSessionMirrorToSharedStore(options?: PublishSessionMirrorOptions): Promise<PublishSessionMirrorResult>;
-export interface ConsumeSessionMirrorOptions {
+interface ConsumeSessionMirrorOptions {
     userAgentsDir?: string;
     device?: string;
     role?: ConfiguredDeviceRole;
     now?: number;
     maxAgeMs?: number;
 }
-export interface ConsumeSessionMirrorResult {
+interface ConsumeSessionMirrorResult {
     sources: string[];
     merged: number;
     pruned: number;
@@ -71,3 +67,4 @@ export interface ConsumeSessionMirrorResult {
  * marked worker skips: the mirror feeds an interactive picker it never renders.
  */
 export declare function consumeSessionMirrorFromSharedStore(options?: ConsumeSessionMirrorOptions): ConsumeSessionMirrorResult;
+export {};

package/dist/lib/session/mirror.js

@@ -26,9 +26,9 @@ import { getUserAgentsDir } from '../state.js';
 import { machineId, normalizeHost } from './sync/config.js';
 import { pruneMirrorSessions, queryLocalOriginSessionsForMirror, upsertMirrorSession, } from './db.js';
 /** Cap on sessions published per device — the payload stays what a picker shows. */
-export const SESSION_MIRROR_MAX_ROWS = 200;
+const SESSION_MIRROR_MAX_ROWS = 200;
 /** First-user-message snippet ceiling; the full turn stays on the owning box. */
-export const SESSION_MIRROR_SNIPPET_MAX = 280;
+const SESSION_MIRROR_SNIPPET_MAX = 280;
 /** Mirror rows older than this since their last sync are pruned (staleness/size ceiling). */
 export const SESSION_MIRROR_MAX_AGE_MS = 14 * 24 * 60 * 60_000;
 /** Caps for the timeline block on a published mirror row. */