@phnx-labs/agents-cli 1.22.113 → 1.22.115

package/dist/lib/term-client.js

@@ -0,0 +1,117 @@
+/**
+ * `term` client — thin subprocess wrapper over the standalone `term` CLI
+ * (published separately as `@phnx-labs/term-cli`), the PTY engine this repo
+ * used to own directly (`agents pty`, removed in PHNX-4091). `term` mirrors the
+ * old `agents pty` verbs/flags/JSON shapes 1:1 (`start`, `exec`, `read`,
+ * `write`, `screen`, `signal`, `resize`, `list`, `stop`, `server start|stop|
+ * status`, hidden `_server`) and owns starting/reusing its own background
+ * sidecar itself — this client never manages that process, it only shells out
+ * to the CLI and parses one line of JSON per call.
+ *
+ * Resolution order:
+ *   1. `$TERM_BIN` — an explicit override (a full path, or a PATH-resolvable
+ *      name other than `term`). Sets the exact binary this client execs; the
+ *      one legitimate use besides pointing at a real install is a test double.
+ *   2. `findInPath('term')` — the ordinary PATH lookup (skips this CLI's own
+ *      shims dir, same as every other native-binary resolution in this repo).
+ *
+ * Neither resolving is the expected state until `@phnx-labs/term-cli` is
+ * published and installed — every call fails loud with
+ * {@link TERM_NOT_INSTALLED_ERROR} rather than silently no-op'ing.
+ */
+import { execFile } from 'node:child_process';
+import { findInPath } from './agent-spec/agents.js';
+export const TERM_NOT_INSTALLED_ERROR = 'The standalone `term` CLI is not installed. npm i -g @phnx-labs/term-cli';
+/**
+ * Resolve the `term` binary to exec: `$TERM_BIN` first (exact override, used
+ * by tests and by an operator pinning a specific install), else an ordinary
+ * PATH lookup. Returns null when neither resolves — the caller must fail loud
+ * with {@link TERM_NOT_INSTALLED_ERROR} rather than falling back to anything.
+ */
+export function resolveTermBin() {
+    const override = process.env.TERM_BIN;
+    if (override && override.trim().length > 0)
+        return override.trim();
+    return findInPath('term');
+}
+/** Run one `term <args>` invocation and parse the trailing JSON line from stdout. */
+function runTerm(args) {
+    return new Promise((resolve, reject) => {
+        const bin = resolveTermBin();
+        if (!bin) {
+            reject(new Error(TERM_NOT_INSTALLED_ERROR));
+            return;
+        }
+        execFile(bin, args, { maxBuffer: 16 * 1024 * 1024, timeout: 30_000 }, (err, stdout, stderr) => {
+            const out = stdout.toString().trim();
+            if (!out) {
+                reject(new Error(`term ${args[0]} produced no output: ${stderr.toString().trim() || (err ? err.message : 'unknown error')}`));
+                return;
+            }
+            // `term` may emit progress on earlier lines; the response is the last line.
+            const line = out.split('\n').pop() ?? '';
+            try {
+                resolve(JSON.parse(line));
+            }
+            catch {
+                reject(new Error(`Invalid JSON from term: ${out.slice(0, 200)}`));
+            }
+        });
+    });
+}
+/** `term start [-r rows] [-c cols] [-s shell] [-d cwd] --json` → the new session id. */
+export function termStart(opts = {}) {
+    const args = ['start', '--json'];
+    if (opts.rows)
+        args.push('-r', String(opts.rows));
+    if (opts.cols)
+        args.push('-c', String(opts.cols));
+    if (opts.shell)
+        args.push('-s', opts.shell);
+    if (opts.cwd)
+        args.push('-d', opts.cwd);
+    return runTerm(args);
+}
+/** `term exec <id> <command> --json` — send a command, non-blocking. */
+export function termExec(id, command) {
+    return runTerm(['exec', id, command, '--json']);
+}
+/**
+ * `term write <id> <input> --raw --json` — send raw bytes to the session.
+ * `--raw` is load-bearing: the caller here always supplies already-literal
+ * bytes (e.g. `\x1b[B\r` as real control characters from a JS string), never
+ * the `pty write` CLI's `\n`/`\t`/`\e`/`\xHH` textual escape syntax, so `term`
+ * must not re-interpret them.
+ */
+export function termWrite(id, input) {
+    return runTerm(['write', id, input, '--raw', '--json']);
+}
+/** `term screen <id> --json` → `{ screen, exited, cols, rows }`. */
+export function termScreen(id) {
+    return runTerm(['screen', id, '--json']);
+}
+/**
+ * `term stop <id>` — end the session and clean up.
+ *
+ * Unlike every other verb, `stop` has no `--json` mode and prints nothing on
+ * success (confirmed against a real built `term` binary — a bare `--json`
+ * flag errors `unknown option '--json'`, and success alone leaves stdout
+ * empty), so this synthesizes the `{ ok }` envelope from the exit code
+ * instead of routing through {@link runTerm}'s stdout-JSON parse.
+ */
+export function termStop(id) {
+    return new Promise((resolve, reject) => {
+        const bin = resolveTermBin();
+        if (!bin) {
+            reject(new Error(TERM_NOT_INSTALLED_ERROR));
+            return;
+        }
+        execFile(bin, ['stop', id], { maxBuffer: 16 * 1024 * 1024, timeout: 30_000 }, (err, _stdout, stderr) => {
+            if (err) {
+                resolve({ ok: false, error: stderr.toString().trim() || err.message });
+                return;
+            }
+            resolve({ ok: true });
+        });
+    });
+}

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

@@ -33,8 +33,6 @@
  *             via System Events keystrokes, stealing focus. The resolver refuses
  *             to route here by default (see resolve.ts); it stays behind an
  *             explicit opt-in.
- *   - pty   → the `agents pty write` sidecar path (ptyRequest). Local-only —
- *             the sidecar is not an engine transport surface.
  *
  * Ink-TUI Enter semantics: Claude's Ink TUI swallows an Enter fused to the text,
  * so the default path delivers the text and the Enter as TWO SEPARATE writes
@@ -45,8 +43,7 @@ import { type HostResolver } from './transport.js';
 import { type LaunchSpec, type EngineContext } from './types.js';
 /**
  * An already-running surface to type into. A superset of the engine's launch
- * `Backend` — it adds `pty` (the sidecar), which the engine can't launch but can
- * be injected into.
+ * `Backend`.
  */
 export type InjectTarget = {
     backend: 'tmux';
@@ -70,9 +67,6 @@ export type InjectTarget = {
 } | {
     backend: 'ghostty';
     window?: string;
-} | {
-    backend: 'pty';
-    id: string;
 };
 export type InjectBackend = InjectTarget['backend'];
 export interface InjectOptions {
@@ -101,10 +95,9 @@ export interface InjectResult {
     /**
      * Delivery is CONFIRMED to have reached the running agent, not merely dispatched.
      *
-     * For tmux / iterm / ghostty / pty, `ok` already means delivered: `tmux
+     * For tmux / iterm / ghostty, `ok` already means delivered: `tmux
      * send-keys` errors on a missing pane, `osascript write text` errors on a bad
-     * session id, and a pty write errors if the sidecar can't reach the fd — so a
-     * successful transport IS the confirmation. For **vscodium**, `ok` only means the
+     * session id — so a successful transport IS the confirmation. For **vscodium**, `ok` only means the
      * editor CLI accepted the `--open-url` hand-off; whether the swarm-ext extension
      * actually parsed the verb and typed anything is unknown from the CLI side (the
      * ext must ack — RUSH follow-up). So vscodium is delivered-but-UNCONFIRMED, and
@@ -117,12 +110,6 @@ export interface InjectResult {
     specs?: LaunchSpec[];
     error?: string;
 }
-/**
- * Whether a successful transport on this backend CONFIRMS delivery to the agent.
- * Everything but vscodium self-confirms (see InjectResult.confirmed); vscodium's
- * `--open-url` is fire-and-forget until the swarm-ext extension acks the verb.
- */
-export declare function backendConfirmsDelivery(backend: InjectBackend): boolean;
 /**
  * argv for `tmux send-keys` targeting a pane by id. Starts with `tmux` (like the
  * engine's `tmuxTabArgv`) so the same transport runs it locally or over SSH. The

package/dist/lib/terminal/inject.js

@@ -33,15 +33,12 @@
  *             via System Events keystrokes, stealing focus. The resolver refuses
  *             to route here by default (see resolve.ts); it stays behind an
  *             explicit opt-in.
- *   - pty   → the `agents pty write` sidecar path (ptyRequest). Local-only —
- *             the sidecar is not an engine transport surface.
  *
  * Ink-TUI Enter semantics: Claude's Ink TUI swallows an Enter fused to the text,
  * so the default path delivers the text and the Enter as TWO SEPARATE writes
  * (swarmify's `sendText(text,false)` then `sendText('\r',false)`). `combined`
  * opts into one fused write for plain shells / REPLs.
  */
-import { ptyRequest } from '../pty-client.js';
 import { appleScriptStr } from './quote.js';
 import { runSpec } from './transport.js';
 import { itermBackend, ghosttyBackend } from './backends/index.js';
@@ -51,7 +48,7 @@ import { currentContext } from './types.js';
  * Everything but vscodium self-confirms (see InjectResult.confirmed); vscodium's
  * `--open-url` is fire-and-forget until the swarm-ext extension acks the verb.
  */
-export function backendConfirmsDelivery(backend) {
+function backendConfirmsDelivery(backend) {
     return backend !== 'vscodium';
 }
 /** Carriage return — what Enter delivers into a raw PTY/tmux byte stream. */
@@ -185,28 +182,6 @@ export function vscodiumInjectUri(scheme, terminalId, text, opts) {
 export function vscodiumInjectSpec(target, text, opts) {
     return { argv: [target.cli, '--open-url', vscodiumInjectUri(target.scheme, target.terminalId, text, opts)] };
 }
-// --- pty --------------------------------------------------------------------
-async function injectPty(target, text, o) {
-    if (o.host && o.host !== 'local') {
-        return { ok: false, confirmed: false, backend: 'pty', writes: 0, error: 'pty injection is local-only (the sidecar is not a remote surface)' };
-    }
-    // Same Ink-safe split as tmux: text write, then a separate CR write.
-    const writes = o.enter && o.combined ? [text + CR] : o.enter ? [text, CR] : [text];
-    if (o.dryRun)
-        return { ok: true, confirmed: true, backend: 'pty', writes: writes.length };
-    try {
-        for (const input of writes) {
-            const res = await ptyRequest('write', target.id, { input });
-            if (!res.ok)
-                return { ok: false, confirmed: false, backend: 'pty', writes: 0, error: res.error ?? 'pty write failed' };
-        }
-        // A successful sidecar write reached the fd — real delivery.
-        return { ok: true, confirmed: true, backend: 'pty', writes: writes.length };
-    }
-    catch (err) {
-        return { ok: false, confirmed: false, backend: 'pty', writes: 0, error: err instanceof Error ? err.message : String(err) };
-    }
-}
 // --- public entry -----------------------------------------------------------
 /**
  * Deliver `text` (+ Enter) into an existing terminal surface. Resolves the
@@ -216,9 +191,6 @@ async function injectPty(target, text, o) {
 export async function injectIntoTerminal(target, text, opts = {}) {
     const enter = opts.enter !== false;
     const combined = opts.combined === true;
-    if (target.backend === 'pty') {
-        return injectPty(target, text, { enter, combined, host: opts.host, dryRun: opts.dryRun });
-    }
     // tmux + AppleScript + editor-CLI backends all run through the engine transport.
     const specs = target.backend === 'tmux'
         ? tmuxInjectSpecs(target, text, { enter, combined, socket: opts.socket })

package/dist/lib/terminal/resolve.d.ts

@@ -11,7 +11,7 @@
  * Resolution reads the agent's INHERITED ENV (via session provenance) plus the
  * IDE's live-terminals registry (off disk) — no cooperation from the agent:
  *
- *   tmux  > iterm > vscodium > pty
+ *   tmux  > iterm > vscodium
  *
  * tmux wins whenever present: a `tmux send-keys -t <pane>` reaches the pane no
  * matter which host app (iTerm / Ghostty / VS Code) is above it, so it's correct
@@ -25,7 +25,7 @@
 import type { ActiveSession } from '../session/active.js';
 import type { InjectTarget } from './inject.js';
 /** A resolved rail, or an honest refusal. The watchdog acts only on `addressable: true`. */
-export type InjectRail = 'tmux' | 'iterm' | 'vscodium' | 'ghostty' | 'pty';
+export type InjectRail = 'tmux' | 'iterm' | 'vscodium' | 'ghostty';
 export type InjectResolution = {
     addressable: true;
     rail: InjectRail;
@@ -43,12 +43,6 @@ export interface ResolveOptions {
      * a Ghostty session with no tmux resolves to un-addressable instead.
      */
     allowGhosttyFocus?: boolean;
-    /**
-     * A known `agents pty` sidecar id for this session, if the caller has one. No
-     * automatic sessionId -> pty mapping exists yet, so pty is only emitted when
-     * supplied here (the lowest-precedence rail).
-     */
-    ptyId?: string;
 }
 /**
  * Human-facing recovery hint for a session the resolver judged un-addressable.
@@ -59,7 +53,7 @@ export declare function addressabilityRecoveryHint(session: ActiveSession, fallb
 /**
  * Resolve a target from an already-fetched ActiveSession. Pure — no I/O — so the
  * precedence logic is unit-testable without the process table. This is where the
- * tmux > iterm > vscodium > pty precedence and the Ghostty refusal live.
+ * tmux > iterm > vscodium precedence and the Ghostty refusal live.
  */
 export declare function resolveInjectTargetForSession(session: ActiveSession, opts?: ResolveOptions): InjectResolution;
 /**

package/dist/lib/terminal/resolve.js

@@ -33,12 +33,12 @@ export function addressabilityRecoveryHint(session, fallbackId) {
     if (session.host) {
         return `Host '${session.host}' has no addressable rail here. ${interactive ? `Enable tmux wrapping with \`${tmuxCmd}\` and re-launch, or ` : ''}use \`${resumeCmd}\` to continue this session.`;
     }
-    return `This session has no addressable terminal rail (not tmux, iTerm, an IDE terminal, or a pty sidecar). ${interactive ? `Enable tmux wrapping with \`${tmuxCmd}\` and re-launch, or ` : ''}use \`${resumeCmd}\` to continue this session.`;
+    return `This session has no addressable terminal rail (not tmux, iTerm, or an IDE terminal). ${interactive ? `Enable tmux wrapping with \`${tmuxCmd}\` and re-launch, or ` : ''}use \`${resumeCmd}\` to continue this session.`;
 }
 /**
  * Resolve a target from an already-fetched ActiveSession. Pure — no I/O — so the
  * precedence logic is unit-testable without the process table. This is where the
- * tmux > iterm > vscodium > pty precedence and the Ghostty refusal live.
+ * tmux > iterm > vscodium precedence and the Ghostty refusal live.
  */
 export function resolveInjectTargetForSession(session, opts = {}) {
     const prov = session.provenance;
@@ -77,11 +77,7 @@ export function resolveInjectTargetForSession(session, opts = {}) {
             target: { backend: 'vscodium', terminalId: session.sessionId, cli: variant.cli, scheme: variant.scheme },
         };
     }
-    // 4. pty — lowest precedence, only when the caller supplied a sidecar id.
-    if (opts.ptyId) {
-        return { addressable: true, rail: 'pty', target: { backend: 'pty', id: opts.ptyId } };
-    }
-    // 5. Ghostty — no per-split addressing exists. Refuse by default; the coarse,
+    // 4. Ghostty — no per-split addressing exists. Refuse by default; the coarse,
     //    focus-stealing window path is opt-in only.
     if (session.host === 'ghostty') {
         if (opts.allowGhosttyFocus) {

package/dist/lib/tmux/binary.d.ts

@@ -37,7 +37,7 @@ export declare class TmuxCommandError extends Error {
     readonly code: number | null;
     constructor(message: string, stderr: string, stdout: string, code: number | null);
 }
-export interface RunTmuxOptions {
+interface RunTmuxOptions {
     /** Socket path (default: shared server socket). */
     socket?: string;
     /** Args after `tmux -S <socket>` — e.g. `['has-session', '-t', 'foo']`. */
@@ -76,3 +76,4 @@ export declare function attachTmux(opts: {
     args: string[];
     env?: NodeJS.ProcessEnv;
 }): Promise<number>;
+export {};

package/dist/lib/tmux/orphan-reap.d.ts

@@ -98,8 +98,6 @@
  * entirely (env is inherently unreadable cross-process there without a native
  * helper); it is not a parsing bug {@link parseTmuxSessionMarker} can fix.
  */
-/** Grace between SIGTERM and SIGKILL for a reaped orphan. */
-export declare const REAP_GRACE_MS = 2000;
 /** Env var `runInTmux` stamps into the pane, inherited by every descendant. */
 export declare const TMUX_SESSION_ENV = "AGENT_TMUX_SESSION_NAME";
 /** One process, with the fields the reaper attributes on. */
@@ -119,15 +117,15 @@ export interface PaneOwner {
     attached: boolean;
 }
 /** Why a process was selected, for human output and tests. */
-export type OrphanReason = 'tmux-agent-exited' | 'detached-helper';
-export interface OrphanCandidate {
+type OrphanReason = 'tmux-agent-exited' | 'detached-helper';
+interface OrphanCandidate {
     pid: number;
     args: string;
     reason: OrphanReason;
     /** Owning tmux session, when the process carried the marker. */
     tmuxSession?: string;
 }
-export interface OrphanReapResult {
+interface OrphanReapResult {
     /** Processes signalled (SIGTERM, escalated to SIGKILL when they ignore it). */
     killed: number;
     /** One human-readable line per reaped process. */
@@ -148,7 +146,7 @@ export interface OrphanReapResult {
  * Registry rather than per-agent branches: a second harness with the same shape
  * is one entry, and the completeness of the table is what a reviewer checks.
  */
-export interface DetachedHelperRule {
+interface DetachedHelperRule {
     /** Harness id, for the reap detail line. */
     agent: string;
     /** Owner pid the helper declares in its own argv, or undefined when it is not this rule's process. */
@@ -247,7 +245,7 @@ export declare function readAgentProcesses(opts?: {
     pids?: number[];
 }): Promise<AgentProcess[]>;
 /** One socket's pane-ownership read. `ok: false` means tmux never actually answered. */
-export interface PaneOwnersRead {
+interface PaneOwnersRead {
     /**
      * `true` when tmux completed the query (whatever its exit code — a nonzero
      * exit from `list-panes -a` IS tmux affirmatively answering "no server /
@@ -314,3 +312,4 @@ export declare function reapProcessesForTmuxSession(name: string, socket?: strin
     graceMs?: number;
     pids?: number[];
 }): Promise<OrphanReapResult>;
+export {};

package/dist/lib/tmux/orphan-reap.js

@@ -113,7 +113,7 @@ const PS_TIMEOUT_MS = 10_000;
  */
 const TMUX_QUERY_TIMEOUT_MS = 10_000;
 /** Grace between SIGTERM and SIGKILL for a reaped orphan. */
-export const REAP_GRACE_MS = 2_000;
+const REAP_GRACE_MS = 2_000;
 /** Env var `runInTmux` stamps into the pane, inherited by every descendant. */
 export const TMUX_SESSION_ENV = 'AGENT_TMUX_SESSION_NAME';
 /**

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

@@ -127,7 +127,7 @@ export declare function teardownIfAgentExited(name: string, socket?: string): Pr
  */
 export declare function killAll(socket?: string): Promise<number>;
 /** Result returned by {@link reapDeadTmuxPanes}. */
-export interface ReapDeadPanesResult {
+interface ReapDeadPanesResult {
     /** Number of tmux sessions killed. */
     reaped: number;
     /** Names of reaped sessions. */
@@ -196,7 +196,7 @@ export interface TmuxClient {
  */
 export declare function listClients(socket?: string): Promise<TmuxClient[]>;
 /** A dead pane's exit status, read from tmux while the pane lingers under remain-on-exit. */
-export interface PaneExit {
+interface PaneExit {
     /** False when the pane/socket no longer exists or tmux could not query it. */
     found: boolean;
     /** True once the process that ran in the pane has exited (pane is dead). */
@@ -283,7 +283,7 @@ export declare function markSessionHookSchema(name: string, socket?: string, tim
  * its attach client returns — without that, a resume-attach has no handle to ask
  * tmux what happened and can only assume success (EXEC-23b).
  */
-export type ResumePreparation = {
+type ResumePreparation = {
     decision: 'attach';
     pane: string;
 } | {
@@ -381,3 +381,4 @@ export interface CaptureOptions {
 export declare function capturePane(opts: CaptureOptions): Promise<string>;
 /** Read a session's provenance JSON, if present. */
 export declare function readSessionMeta(name: string): SessionMeta | null;
+export {};

package/dist/lib/traces/backend.d.ts

@@ -6,8 +6,7 @@
  * `traces.agents-cli.sh` Worker. Zero Cloudflare setup.
  *
  * BYO path (future): TRACES_BASE_URL + TRACES_WRITE_TOKEN env vars. Not
- * exposed in the CLI for M1 — follow-on milestone, same pattern as
- * `agents artifacts setup`.
+ * exposed in the CLI for M1 — follow-on milestone.
  */
 export declare const DEFAULT_TRACES_DOMAIN = "traces.agents-cli.sh";
 export interface TracesBackend {

package/dist/lib/traces/backend.js

@@ -6,8 +6,7 @@
  * `traces.agents-cli.sh` Worker. Zero Cloudflare setup.
  *
  * BYO path (future): TRACES_BASE_URL + TRACES_WRITE_TOKEN env vars. Not
- * exposed in the CLI for M1 — follow-on milestone, same pattern as
- * `agents artifacts setup`.
+ * exposed in the CLI for M1 — follow-on milestone.
  */
 import { readSession } from '../identity/client.js';
 import { selectStorageBackendKind } from '../storage/selection.js';

package/dist/lib/traces/classify.d.ts

@@ -26,7 +26,7 @@ export interface DriftSignal {
     stallDelta: number;
     severity: 'degrading' | 'stable' | 'improving';
 }
-export interface TopicEvidence {
+interface TopicEvidence {
     cwd?: string | null;
     gitBranch?: string | null;
     topic?: string | null;
@@ -38,7 +38,7 @@ export interface ClassifiedTopic {
     key: string;
     label: string;
 }
-export interface ToolCallFailure {
+interface ToolCallFailure {
     tool: string;
     exit_code?: number | null;
     status_code?: number | null;
@@ -57,3 +57,4 @@ export declare function classifyCause(call: ToolCallFailure): TraceFailureCause;
  * not enough signal to distinguish noise from drift.
  */
 export declare function computeDriftSignal(history: BucketStats[][], today: BucketStats[]): DriftSignal[];
+export {};

package/dist/lib/traces/config.d.ts

@@ -1,10 +1,2 @@
-/** Isolated Cloudflare resources for the private Phoenix trace store. */
-export interface TracesConfig {
-    baseUrl: string;
-    accountId: string;
-    workerName: string;
-    bucketName: string;
-    domain?: string;
-}
 export declare const DEFAULT_WORKER_NAME = "agents-traces";
 export declare const DEFAULT_BUCKET_NAME = "agents-traces";

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

@@ -59,7 +59,7 @@ export interface FailurePattern {
     /** Movement vs the same pattern id in the previous shard. */
     drift: 'up' | 'flat' | 'down';
 }
-export interface ComputedInsights {
+interface ComputedInsights {
     /** Top-K patterns ranked by wastedMs (impact) — a rare 1-occurrence/8h loop still surfaces. */
     failurePatterns: FailurePattern[];
     /** Sum of wastedMs across every cluster found this sync, not just the top-K rows above. */
@@ -110,3 +110,4 @@ export declare function computeInsights(rows: readonly SyncRow[], calls: readonl
  * `tool` is the synthetic `silent-stall` and `key` is the duration bucket.
  */
 export declare function computeBehavioralPatterns(facetsBySession: ReadonlyMap<string, Pick<InsightFacets, 'frictionSignals'>>, prevShard?: TracesIndexShard | null): FailurePattern[];
+export {};

package/dist/lib/traces/phenotype.d.ts

@@ -25,12 +25,12 @@ export type FailurePhenotype = 'false-termination' | 'premature-completion' | 'o
  * - `human-takeover`: the final substantive action was a human-facing ask/wait.
  * - `invalid-env`  : environment/setup failures dominated the session.
  */
-export type TraceOutcome = 'merged' | 'tests-green' | 'partial' | 'abandoned' | 'human-takeover' | 'invalid-env';
-export interface PhenotypeResult {
+type TraceOutcome = 'merged' | 'tests-green' | 'partial' | 'abandoned' | 'human-takeover' | 'invalid-env';
+interface PhenotypeResult {
     phenotype: FailurePhenotype | null;
     reason: string;
 }
-export interface OutcomeResult {
+interface OutcomeResult {
     outcome: TraceOutcome;
     confidence: 'high' | 'medium' | 'low';
     reason: string;

package/dist/lib/traces/provision.d.ts

@@ -1,10 +1,8 @@
-import { type CloudflareRequester } from '../share/provision.js';
+import { type CloudflareRequester } from '../cloudflare/provision.js';
 interface ProvisionOptions {
     request?: CloudflareRequester;
 }
-/** Bind the Phoenix identity base URL used to verify every trace read and write. */
-export declare function setPhoenixIdBaseSecret(apiToken: string, accountId: string, workerName: string, phoenixIdBase: string, opts?: ProvisionOptions): Promise<void>;
-export interface ProvisionTracesOptions extends ProvisionOptions {
+interface ProvisionTracesOptions extends ProvisionOptions {
     apiToken: string;
     accountId: string;
     workerName: string;

package/dist/lib/traces/provision.js

@@ -1,12 +1,12 @@
 // Cloudflare orchestration for the private agents-traces store. The generic
-// request primitives live in share/provision; only the isolated traces resource
+// request primitives live in cloudflare/provision; only the isolated traces resource
 // choices and Worker template belong here.
 import { randomBytes } from 'node:crypto';
-import { addCustomDomain, createBucket, deployWorker, enableWorkersDev, findZoneId, putWorkerSecret, } from '../share/provision.js';
+import { addCustomDomain, createBucket, deployWorker, enableWorkersDev, findZoneId, putWorkerSecret, } from '../cloudflare/provision.js';
 import { DEFAULT_TRACES_DOMAIN } from './backend.js';
 import { renderTracesWorkerScript } from './worker-template.js';
 /** Bind the Phoenix identity base URL used to verify every trace read and write. */
-export async function setPhoenixIdBaseSecret(apiToken, accountId, workerName, phoenixIdBase, opts = {}) {
+async function setPhoenixIdBaseSecret(apiToken, accountId, workerName, phoenixIdBase, opts = {}) {
     const normalized = phoenixIdBase.replace(/\/+$/, '').trim();
     if (!normalized)
         throw new Error('PHOENIX_ID_BASE is required to verify trace requests.');

package/dist/lib/traces/schema2-build.d.ts

@@ -68,7 +68,7 @@ export declare function unwrapShellExec(command: string): string;
 export declare function mapBashCategory(cat: ClassifierCategory, argv: string[]): BashCategory;
 /** Build the per-segment BashAction list for a bash command. */
 export declare function buildBashActions(unwrapped: string): BashAction[];
-export interface BuildDetailV2Options {
+interface BuildDetailV2Options {
     redact?: boolean;
     knownSecrets?: readonly string[];
 }

package/dist/lib/traces/schema2-danger.d.ts

@@ -21,7 +21,7 @@
  * action was flagged, so the console can group by operation without re-parsing.
  */
 import type { BashDanger } from './schema2.js';
-export interface DangerVerdict {
+interface DangerVerdict {
     danger: BashDanger;
     /** Short stable label naming the operation, e.g. `recursive-delete`. Omitted for `normal`. */
     destructiveOperation?: string;
@@ -34,3 +34,4 @@ export interface DangerVerdict {
  * expands to), because the operation itself is the danger, not its target.
  */
 export declare function classifyActionDanger(argv: string[], _argvComplete?: boolean): DangerVerdict;
+export {};

package/dist/lib/traces/schema2.d.ts

@@ -1,5 +1,5 @@
 export type StepOutcome = 'ok' | 'error' | 'running' | 'unknown';
-export interface SessionStepBase {
+interface SessionStepBase {
     ordinal: number;
     startMs: number;
     durationMs: number;
@@ -17,15 +17,15 @@ export interface ThinkingStep extends SessionStepBase {
     lane: 'think';
     outcome: 'ok' | 'running' | 'unknown';
 }
-export interface ExecutionBase extends SessionStepBase {
+interface ExecutionBase extends SessionStepBase {
     kind: 'execution';
     lane: string;
     callId?: string;
     /** The tool call this execution targets (hook/permission → the guarded call). */
     targetCallId?: string;
 }
-export type ToolExecutionType = 'bash' | 'edit' | 'write' | 'read' | 'grep' | 'generic';
-export interface ToolExecutionBase extends ExecutionBase {
+type ToolExecutionType = 'bash' | 'edit' | 'write' | 'read' | 'grep' | 'generic';
+interface ToolExecutionBase extends ExecutionBase {
     executionType: ToolExecutionType;
     tool: string;
     result: ExecutionResult;
@@ -147,3 +147,4 @@ export interface HookExecution extends ExecutionBase {
     result: ExecutionResult;
 }
 export type SessionStepV2 = ThinkingStep | BashExecution | EditExecution | WriteExecution | ReadExecution | GrepExecution | GenericToolExecution | PermissionExecution | HookExecution;
+export {};

package/dist/lib/traces/segments.d.ts

@@ -13,10 +13,10 @@
  */
 export declare const TASK_TYPES: readonly ["bugfix", "feature", "refactor", "test", "chore", "other"];
 export type TaskType = (typeof TASK_TYPES)[number];
-export declare const FAILURE_TIMINGS: readonly ["early", "mid", "late"];
-export type FailureTiming = (typeof FAILURE_TIMINGS)[number];
+declare const FAILURE_TIMINGS: readonly ["early", "mid", "late"];
+type FailureTiming = (typeof FAILURE_TIMINGS)[number];
 /** The #1 group-by axis: compare the pair, never the model alone. */
-export interface SegmentAgent {
+interface SegmentAgent {
     model: string;
     harness: string;
 }
@@ -70,19 +70,11 @@ export interface Percentiles {
 export interface LatencyInsight {
     firstToolMs: Percentiles;
 }
-export interface SegmentDimensions {
+interface SegmentDimensions {
     agent: SegmentAgent;
     taskType: TaskType;
     failureTiming: FailureTiming | null;
 }
-/**
- * Tool name → file action. Lowercased. Write-family is a new file; Edit-family
- * is a patch. Anything else is ignored for diff-shape.
- */
-export declare const FILE_ACTION_TOOLS: ReadonlyArray<{
-    action: SegmentFile['action'];
-    tools: readonly string[];
-}>;
 type DiffShape = {
     files: readonly SegmentFile[];
     testOnly: boolean;
@@ -101,14 +93,6 @@ export declare const TASK_TYPE_RULES: ReadonlyArray<{
     patterns: readonly RegExp[];
     shape?: keyof Pick<DiffShape, 'testOnly' | 'newOnly' | 'choreOnly'>;
 }>;
-/**
- * Normalized position of the first failing step inside the session span.
- * Early failures cascade — highest-signal bucket. Exclusive upper bound.
- */
-export declare const FAILURE_TIMING_BUCKETS: ReadonlyArray<{
-    timing: FailureTiming;
-    maxExclusive: number;
-}>;
 /** Model × harness unit — the #1 group-by axis. */
 export declare function deriveAgent(session: SegmentSession): SegmentAgent;
 /**