@phnx-labs/agents-cli 1.22.120 → 1.22.121

package/dist/lib/drift.d.ts

@@ -1,12 +1,3 @@
-/**
- * Shared drift-detection internals for `agents doctor` (overview mode) and
- * `agents doctor --check` (the scriptable, CI-friendly gate).
- *
- * This is the single source of truth for "is the install out of sync?": the
- * per-version sync status (fresh / stale / never-synced) and the orphan census.
- * `agents doctor` renders it as a human report; `agents doctor --check` reduces it
- * to an exit code. Neither reimplements the diagnostic — both call `computeDrift`.
- */
 import type { AgentId } from './types.js';
 import { type SourceLayerBehind } from './doctor-diff.js';
 export interface SyncStatusRow {
@@ -14,15 +5,8 @@ export interface SyncStatusRow {
     version: string;
     status: 'fresh' | 'stale' | 'never-synced';
     isDefault: boolean;
-    /** For stale rows: prioritized lines naming exactly what diverged (plugins first).
-     *  Also carries hook-wiring divergence for a version whose hooks are present but
-     *  not wired into settings.json — independent of manifest staleness. */
     divergence?: string[];
-    /** Count of hooks present on disk but NOT wired into the version's settings.json
-     *  (claude/droid). A non-zero value makes the version out-of-sync even when the
-     *  manifest reads fresh — the yosemite-s1 blind spot the CI gate must catch. */
     unwiredHooks?: number;
-    /** Generated hooks whose shared runtime wrapper is missing or unusable. */
     brokenHookRuntime?: number;
 }
 export interface OrphanRow {
@@ -34,44 +18,17 @@ export interface OrphanRow {
 }
 export declare function checkSyncStatus(cwd: string): SyncStatusRow[];
 export declare function countOrphans(): OrphanRow[];
-/**
- * Probe each source layer (user, system, enabled extras) for how far it trails
- * its upstream, from the LAST-FETCHED remote-tracking ref (no network). A layer
- * behind origin means every version home is reconciled against stale truth — a
- * drift signal `agents doctor --check` must fail on, not a buried preamble. Returns
- * only the behind layers. Canonical home for both `agents doctor` and `agents doctor --check`.
- */
 export declare function computeSourceBehind(): SourceLayerBehind[];
 interface DriftSummary {
     syncRows: SyncStatusRow[];
     orphanRows: OrphanRow[];
-    /** Versions whose sources changed since last sync. */
     staleCount: number;
-    /** Versions installed but never synced. */
     neverSyncedCount: number;
-    /** Versions carrying orphan resources (informational — not a drift signal). */
     orphanVersionCount: number;
-    /** Versions with hooks present on disk but not wired into settings.json. */
     unwiredHookVersions: number;
-    /** Versions with at least one broken generated hook-runtime wrapper. */
     brokenHookRuntimeVersions: number;
-    /** Source layers behind their upstream (reconciled against stale truth). */
     sourceBehind: SourceLayerBehind[];
-    /**
-     * True when the install is out of sync: any installed version is stale,
-     * never-synced, carries unwired hooks, or has a broken generated hook runtime,
-     * OR a source layer is behind origin.
-     * `agents doctor` surfaces it as "run `agents sync status`"; `agents doctor --check`
-     * maps it to a non-zero exit. Orphans are a `prune` concern, not sync drift, so they do
-     * NOT set this flag (mirrors the sync-status engine: an orphan alone never
-     * flags needsSync).
-     */
     hasDrift: boolean;
 }
-/**
- * Compute the same drift/divergence diagnostic `agents doctor` prints, reduced
- * to a summary with a single `hasDrift` boolean. The gate `agents doctor --check`
- * maps to an exit code; the readout `agents doctor` renders in full.
- */
 export declare function computeDrift(cwd: string): DriftSummary;
 export {};

package/dist/lib/drift.js

@@ -7,11 +7,6 @@ import { diffVersionSkills, iterSkillsCapableVersions } from './plugins/skills.j
 import { iterHooksCapableVersions, listUnmanagedHooksInVersionHome, checkVersionHookWiring } from './hooks/install.js';
 import { commitsBehindUpstream } from './git.js';
 import { getUserAgentsDir, getSystemAgentsDir, getEnabledExtraRepos } from './state.js';
-// Lines naming exactly what's out of sync for a version, plugins prioritized:
-// each divergent plugin gets its own line with specifics (stale mirror version,
-// invalid manifest, or the bundled skills/commands missing from the mirror —
-// the system-repo plugin content that matters most). Other kinds collapse to
-// compact counts so the readout stays scannable.
 function divergenceLines(report) {
     const lines = [];
     for (const p of report.kinds.plugins) {
@@ -36,10 +31,6 @@ function divergenceLines(report) {
 }
 export function checkSyncStatus(cwd) {
     const rows = [];
-    // Every installed version, not just the default — a stale NON-default version
-    // (e.g. one you launched from yesterday) is exactly the rot that silently
-    // serves outdated/invalid resources and that `--fix` now heals. Hiding it here
-    // is why that class of bug went unnoticed.
     for (const agent of ALL_AGENT_IDS) {
         const def = getGlobalDefault(agent);
         for (const version of listInstalledVersions(agent)) {
@@ -50,15 +41,9 @@ export function checkSyncStatus(cwd) {
             const row = { agent, version, status, isDefault: version === def };
             const divergence = [];
             if (status === 'stale') {
-                // Resolve the specifics against non-project layers (the global home is
-                // never reconciled against per-cwd project resources).
                 const report = diffVersionResources(agent, version, { cwd, excludeProject: true });
                 divergence.push(...divergenceLines(report));
             }
-            // Hook WIRING is independent of manifest staleness: a hook file can be
-            // byte-identical to source (fresh) yet absent from settings.json, so it
-            // never fires. Surface that for every version, fresh or stale, so overview
-            // AND `agents doctor --check` flag it (claude/droid; other agents report unsupported).
             const wiring = checkVersionHookWiring(agent, version);
             if (wiring.runtimeBroken.length > 0) {
                 row.brokenHookRuntime = wiring.runtimeBroken.length;
@@ -111,10 +96,6 @@ export function countOrphans() {
         if (diff.orphans.length > 0)
             ensure(agent, version).skills = diff.orphans.length;
     }
-    // Orphan hooks are scripts in the version home that no agents.yaml/hooks.yaml
-    // entry registers — so the registrar never wires them to an event and they
-    // never fire. (Distinct from the source-diff `diffVersionHooks().orphans`,
-    // which false-flags valid system-sourced registered hooks.)
     for (const { agent, version } of iterHooksCapableVersions()) {
         const dead = listUnmanagedHooksInVersionHome(agent, version);
         if (dead.length > 0)
@@ -122,13 +103,6 @@ export function countOrphans() {
     }
     return Array.from(byKey.values()).filter((r) => r.commands + r.skills + r.hooks > 0);
 }
-/**
- * Probe each source layer (user, system, enabled extras) for how far it trails
- * its upstream, from the LAST-FETCHED remote-tracking ref (no network). A layer
- * behind origin means every version home is reconciled against stale truth — a
- * drift signal `agents doctor --check` must fail on, not a buried preamble. Returns
- * only the behind layers. Canonical home for both `agents doctor` and `agents doctor --check`.
- */
 export function computeSourceBehind() {
     const out = [];
     const probe = (layer, dir, label, alias) => {
@@ -142,11 +116,6 @@ export function computeSourceBehind() {
         probe('extra', e.dir, e.alias, e.alias);
     return out;
 }
-/**
- * Compute the same drift/divergence diagnostic `agents doctor` prints, reduced
- * to a summary with a single `hasDrift` boolean. The gate `agents doctor --check`
- * maps to an exit code; the readout `agents doctor` renders in full.
- */
 export function computeDrift(cwd) {
     const syncRows = checkSyncStatus(cwd);
     const orphanRows = countOrphans();

package/dist/lib/event-families.d.ts

@@ -1,22 +1,5 @@
-/**
- * Event stream families — sessions-style --include / --exclude for the unified
- * event reader. One vocabulary maps onto existing filters (includeActivity,
- * eventTypes, level) so the engine stays single-path.
- */
 import type { UnifiedQuery } from './event-stream.js';
 export declare const EVENT_FAMILIES: readonly ["ops", "activity", "commands", "runs", "security"];
 export type EventFamily = (typeof EVENT_FAMILIES)[number];
-/**
- * Parse a comma-separated family list. Throws on unknown names or empty list
- * after split (same discipline as sessions role lists).
- */
 export declare function parseFamilyList(raw: string, flagName: string): EventFamily[];
-/**
- * Fold family include/exclude into a UnifiedQuery.
- * Precedence: family narrows sources/types; field filters (module, event, …)
- * still apply on top.
- *
- * --include and --exclude are mutually exclusive at the CLI layer; this
- * function accepts only one of includeFamilies / excludeFamilies.
- */
 export declare function applyFamilies(q: UnifiedQuery): UnifiedQuery;

package/dist/lib/event-families.js

@@ -1,8 +1,3 @@
-/**
- * Event stream families — sessions-style --include / --exclude for the unified
- * event reader. One vocabulary maps onto existing filters (includeActivity,
- * eventTypes, level) so the engine stays single-path.
- */
 export const EVENT_FAMILIES = [
     'ops',
     'activity',
@@ -14,10 +9,6 @@ const FAMILY_SET = new Set(EVENT_FAMILIES);
 function isEventFamily(value) {
     return FAMILY_SET.has(value);
 }
-/**
- * Parse a comma-separated family list. Throws on unknown names or empty list
- * after split (same discipline as sessions role lists).
- */
 export function parseFamilyList(raw, flagName) {
     const parts = raw.split(',').map((s) => s.trim()).filter(Boolean);
     if (parts.length === 0) {
@@ -33,18 +24,8 @@ export function parseFamilyList(raw, flagName) {
     }
     return out;
 }
-/** Command-churn event kinds. */
 const COMMAND_EVENT_TYPES = ['command.start', 'command.end'];
-/** Run-dispatch outcome kinds (replaces the separate audit/log.jsonl product). */
 const RUN_EVENT_TYPES = ['run.dispatched', 'run.launch', 'agent.run.end'];
-/**
- * Fold family include/exclude into a UnifiedQuery.
- * Precedence: family narrows sources/types; field filters (module, event, …)
- * still apply on top.
- *
- * --include and --exclude are mutually exclusive at the CLI layer; this
- * function accepts only one of includeFamilies / excludeFamilies.
- */
 export function applyFamilies(q) {
     const include = q.includeFamilies;
     const exclude = q.excludeFamilies;
@@ -63,23 +44,17 @@ function applyInclude(q, families) {
     let level = q.level;
     let includeActivity = false;
     let forceModule;
-    // Source selection — multi-family include is a UNION of each family's rows.
     if (has('activity'))
         includeActivity = true;
     if (has('ops') || has('commands') || has('runs') || has('security')) {
-        // ops path open (includeActivity stays true when activity is also listed)
     }
     else if (has('activity')) {
-        // activity-only
         forceModule = q.module ?? 'activity';
         includeActivity = true;
     }
-    // Default when include lists only type-scoping / ops / security: activity off
-    // unless activity is listed.
     if (!has('activity') && (has('ops') || has('commands') || has('runs') || has('security'))) {
         includeActivity = false;
     }
-    // include ops + activity explicitly
     if (has('ops') && has('activity'))
         includeActivity = true;
     if (has('commands'))
@@ -89,14 +64,9 @@ function applyInclude(q, families) {
     if (has('security')) {
         if (!level)
             level = 'audit';
-        // security without activity stays ops-only
         if (!has('activity'))
             includeActivity = false;
     }
-    // Type-scoped families (commands / runs) only restrict eventTypes when no
-    // broader ops-side family is in the include list. ops and security already
-    // cover those kinds; AND-ing a type filter would shrink the union (e.g.
-    // --include security,runs would drop secrets.get and keep only run.dispatched).
     const broadOps = has('ops') || has('security');
     let eventTypes = q.eventTypes ? [...q.eventTypes] : undefined;
     if (typeSets.length > 0 && !broadOps) {
@@ -105,7 +75,6 @@ function applyInclude(q, families) {
             for (const t of set)
                 union.add(t);
         if (eventTypes?.length) {
-            // Intersect with --event; empty means no match (never silently widen).
             const allowed = new Set(eventTypes);
             eventTypes = [...union].filter((t) => allowed.has(t));
         }
@@ -127,8 +96,6 @@ function applyExclude(q, families) {
     const excludeEventTypes = [...(q.excludeEventTypes ?? [])];
     let excludeLevel = q.excludeLevel;
     let forceModule;
-    // Exclude ops first (→ activity-only), then activity (may clear the reopen).
-    // --exclude ops,activity must not re-open activity after both sources are out.
     if (has('ops')) {
         forceModule = q.module ?? 'activity';
         includeActivity = true;

package/dist/lib/event-provenance.d.ts

@@ -13,10 +13,6 @@ interface EventProvenance {
     parentLaunchId?: string;
     originTerminalId?: string;
 }
-/**
- * Stamp the shared identity floor used by both operational and activity events.
- * Explicit event payload fields may override these defaults at the call site.
- */
 export declare function stampProvenance(env?: NodeJS.ProcessEnv): EventProvenance;
 export declare function resetEventProvenanceForTest(): void;
 export {};

package/dist/lib/event-provenance.js

@@ -4,10 +4,6 @@ import { machineId } from './machine-id.js';
 import { parseSshConnection } from './session/provenance.js';
 let cachedOrigin;
 let cachedDeviceId;
-/**
- * Stamp the shared identity floor used by both operational and activity events.
- * Explicit event payload fields may override these defaults at the call site.
- */
 export function stampProvenance(env = process.env) {
     if (!cachedOrigin) {
         let osUser = 'unknown';
@@ -15,7 +11,6 @@ export function stampProvenance(env = process.env) {
             osUser = os.userInfo().username;
         }
         catch {
-            // A uid without a passwd entry has no attributable OS user.
         }
         const ssh = env.SSH_CONNECTION ? parseSshConnection(env.SSH_CONNECTION) : undefined;
         const actor = resolveActor();

package/dist/lib/event-stream.d.ts

@@ -1,51 +1,22 @@
-/**
- * The unified event reader -- one stream over BOTH operational events
- * (`~/.agents/.history/events/YYYY-MM-DD/` via events.ts: secrets, commands, teams, ...) and
- * agent-semantic events (the per-session activity logs via activity.ts: plans,
- * PRs, worktrees, sub-agents, artifacts). They share one {@link EventType}
- * vocabulary and one {@link EventRecord} shape, so `agents events` and any
- * higher-level feature (a session/project summarizer, RSS) read them together.
- *
- * The two write paths stay separate for efficiency -- operational events append
- * to the locked global log (low frequency), agent events append to lock-free
- * per-session shards (high frequency, one writer each). This module is the
- * single READ surface that merges them; nothing here writes.
- */
 import { type EventRecord, type EventType, type EventLevel } from './feed/events.js';
 import { type EventFamily } from './event-families.js';
 export interface UnifiedQuery {
     startDate?: Date;
     endDate?: Date;
     eventTypes?: EventType[];
-    /** Drop these event kinds after read (used by --exclude commands / runs). */
     excludeEventTypes?: EventType[];
     level?: EventLevel;
-    /** Drop this level (used by --exclude security). */
     excludeLevel?: EventLevel;
     agent?: string;
-    /** Only events stamped with this session id (payload `sessionId`, the provenance floor). */
     sessionId?: string;
-    /** Only events carrying this bundle name in their payload (e.g. secrets events).
-     * Combined with `sessionId`, answers "which session read this secrets bundle". */
     bundle?: string;
     caller?: string;
     command?: string;
     module?: string;
     limit?: number;
-    /** Include agent-semantic activity events. Default true. */
     includeActivity?: boolean;
-    /** Override the activity dir (tests). */
     activityRoot?: string;
-    /** Sessions-style family filters (resolved via applyFamilies). */
     includeFamilies?: EventFamily[];
     excludeFamilies?: EventFamily[];
 }
-/**
- * Read a unified, newest-first event stream. Operational events come from
- * events.ts `query()`; agent-semantic events from the activity logs, normalized
- * to the same record shape and filtered identically. `limit` caps the merged
- * result (each source is fetched up to `limit` *after* its primary filters —
- * eventTypes for activity, eventTypes/module/bundle for ops — so the top-N is
- * exact for those filters).
- */
 export declare function readUnifiedEvents(raw?: UnifiedQuery): EventRecord[];

package/dist/lib/event-stream.js

@@ -1,24 +1,8 @@
-/**
- * The unified event reader -- one stream over BOTH operational events
- * (`~/.agents/.history/events/YYYY-MM-DD/` via events.ts: secrets, commands, teams, ...) and
- * agent-semantic events (the per-session activity logs via activity.ts: plans,
- * PRs, worktrees, sub-agents, artifacts). They share one {@link EventType}
- * vocabulary and one {@link EventRecord} shape, so `agents events` and any
- * higher-level feature (a session/project summarizer, RSS) read them together.
- *
- * The two write paths stay separate for efficiency -- operational events append
- * to the locked global log (low frequency), agent events append to lock-free
- * per-session shards (high frequency, one writer each). This module is the
- * single READ surface that merges them; nothing here writes.
- */
 import { query, levelFor } from './feed/events.js';
 import { readActivityAsEventRecords } from './feed/activity.js';
 import { applyFamilies } from './event-families.js';
-/** Apply the same filters query() applies, to an activity-derived record. */
 function matches(r, q) {
     const ms = Date.parse(r.ts);
-    // Mirror query()'s default upper bound (endDate = now) so both sources drop
-    // future-dated records identically -- keeps the two in exact filter parity.
     const endMs = (q.endDate ?? new Date()).getTime();
     if (q.startDate && !Number.isNaN(ms) && ms < q.startDate.getTime())
         return false;
@@ -48,20 +32,8 @@ function matches(r, q) {
         return false;
     return true;
 }
-/**
- * Read a unified, newest-first event stream. Operational events come from
- * events.ts `query()`; agent-semantic events from the activity logs, normalized
- * to the same record shape and filtered identically. `limit` caps the merged
- * result (each source is fetched up to `limit` *after* its primary filters —
- * eventTypes for activity, eventTypes/module/bundle for ops — so the top-N is
- * exact for those filters).
- */
 export function readUnifiedEvents(raw = {}) {
     const q = applyFamilies(raw);
-    // `bundle` is filtered inside query()'s scan (before its limit cutoff) so a
-    // matching-bundle record older than the newest-`limit` window is not dropped.
-    // Over-fetch when we will post-filter excludeEventTypes / excludeLevel so the
-    // top-N is still meaningful after drops.
     const needsPost = Boolean(q.excludeEventTypes?.length || q.excludeLevel);
     const fetchLimit = q.limit === undefined
         ? undefined
@@ -84,17 +56,9 @@ export function readUnifiedEvents(raw = {}) {
     if (q.includeActivity === false) {
         return typeof q.limit === 'number' ? ops.slice(0, q.limit) : ops;
     }
-    // Activity events always stamp module: 'activity'. A non-activity module
-    // filter can never match them — skip the activity scan entirely.
     if (q.module != null && q.module !== 'activity') {
         return typeof q.limit === 'number' ? ops.slice(0, q.limit) : ops;
     }
-    // Push eventTypes into the activity reader so `limit` is applied AFTER the
-    // event-type filter (readRecentActivity already does this for `events`).
-    // Without this, a rare match older than the newest-`limit` window of routine
-    // churn is silently dropped — the same class of bug as the ops-side bundle
-    // pre-filter above (RUSH-2093). Remaining filters (agent, sessionId, …) still
-    // run via matches() for fields activity.ts does not pre-filter.
     const acts = readActivityAsEventRecords({
         sinceMs: q.startDate?.getTime(),
         limit: fetchLimit,

package/dist/lib/events-ingest.d.ts

@@ -1,47 +1,20 @@
 interface IngestReject {
-    /** 1-based index of the offending line within the batch. */
     line: number;
     reason: string;
 }
 interface IngestResult {
     written: number;
     rejected: IngestReject[];
-    /** Per-store counts, so a caller/test can assert routing without reading files. */
     routed: {
         operational: number;
         activity: number;
     };
 }
 interface IngestOptions {
-    /**
-     * Producer name, stamped as `module` on operational records so
-     * `agents events --module <source>` filters to this producer. Required: an
-     * unattributed external event is not auditable.
-     */
     source: string;
-    /** Validate and report without writing either store. */
     dryRun?: boolean;
-    /** Override the activity root (tests). */
     activityRoot?: string;
 }
-/**
- * Route one already-validated line.
- *
- * The rule is forced by the stores, not chosen:
- *   - The activity store is keyed by session id ON DISK (one file per session),
- *     so an event with no session has nowhere to live there.
- *   - Activity records are read back with `module: 'activity'` hardcoded, so
- *     anything that must stay filterable by its producer has to be operational.
- * Therefore: milestone + usable sessionId -> activity; everything else -> ops.
- * `readUnifiedEvents` merges the two at read time, so `agents events` sees both.
- */
 export declare function routeFor(event: string, sessionId: unknown): 'activity' | 'operational';
-/**
- * Ingest a JSONL batch.
- *
- * Rejection is PER LINE and lossless: a single bad line never discards the rest
- * of the batch. One typo in a 100-event flush must not silently drop 99 real
- * events, and the caller still learns exactly which line failed and why.
- */
 export declare function ingestBatch(input: string, opts: IngestOptions): IngestResult;
 export {};

package/dist/lib/events-ingest.js

@@ -1,31 +1,10 @@
-/**
- * Ingest events produced OUTSIDE this process — the writer behind
- * `agents events emit`.
- *
- * Why this exists: `emit()` (lib/events.ts) and `appendActivityEvent()`
- * (lib/activity.ts) are in-process APIs, but the producers that most need to
- * record events are not agents-cli processes at all — the Factory VS Code
- * extension host, a shell guard, any external tool. They shell out instead, and
- * this module is the one place that turns their JSONL into real records.
- *
- * It deliberately does NOT reuse `feed post`: that surface hardcodes the
- * `status.posted` kind, infers identity by walking the pid-registry ancestor
- * chain (wrong for a process that is not a descendant of an agent), throws when
- * that inference fails, and fires the configured broadcast sinks. A telemetry
- * path must do none of those things.
- *
- * Pure except for the two writers it calls, so the routing and validation rules
- * below are unit-testable against a temp events path + activity root.
- */
 import { emit, isEventType, } from './feed/events.js';
 import { appendActivityEvent, tierForEvent, } from './feed/activity.js';
-/** Envelope keys an incoming line may set directly; everything else is payload. */
 const ENVELOPE_KEYS = [
     'event', 'ts', 'sessionId', 'mailboxId', 'terminalId', 'launchId', 'tmuxPane',
     'host', 'runtime', 'agent', 'tool', 'detail', 'url', 'project', 'cwd',
 ];
 const ENVELOPE_KEY_SET = new Set(ENVELOPE_KEYS);
-/** ISO-8601 with at least seconds. Rejects "now", epoch ints, and garbage. */
 function isIsoTimestamp(value) {
     if (typeof value !== 'string')
         return false;
@@ -33,30 +12,12 @@ function isIsoTimestamp(value) {
         return false;
     return !Number.isNaN(Date.parse(value));
 }
-/**
- * A session id must be non-empty AND survive the activity writer's filename
- * sanitizer — `activityPath` throws on an id that reduces to nothing, and that
- * throw would abort a whole batch mid-write. Check it here so the line is
- * rejected cleanly and its siblings still land.
- */
 function isUsableSessionId(value) {
     return typeof value === 'string' && value.replace(/[^A-Za-z0-9._-]/g, '-').replace(/-+/g, '') !== '';
 }
-/**
- * Route one already-validated line.
- *
- * The rule is forced by the stores, not chosen:
- *   - The activity store is keyed by session id ON DISK (one file per session),
- *     so an event with no session has nowhere to live there.
- *   - Activity records are read back with `module: 'activity'` hardcoded, so
- *     anything that must stay filterable by its producer has to be operational.
- * Therefore: milestone + usable sessionId -> activity; everything else -> ops.
- * `readUnifiedEvents` merges the two at read time, so `agents events` sees both.
- */
 export function routeFor(event, sessionId) {
     return tierForEvent(event) === 'milestone' && isUsableSessionId(sessionId) ? 'activity' : 'operational';
 }
-/** Validate one raw JSONL line. Returns either a parsed line or a rejection. */
 function parseLine(raw, lineNo) {
     let obj;
     try {
@@ -79,11 +40,6 @@ function parseLine(raw, lineNo) {
     if (rec.ts !== undefined && !isIsoTimestamp(rec.ts)) {
         return { line: lineNo, reason: `invalid "ts" (want ISO-8601): ${String(rec.ts)}` };
     }
-    // A milestone with no usable session id is REJECTED, not quietly demoted to
-    // the operational store. Silently writing it somewhere else would look like
-    // success while the event never appears in the activity lane the producer
-    // asked for -- exactly the "wrong path that looks like success" this codebase
-    // forbids at a boundary.
     if (tierForEvent(event) === 'milestone' && !isUsableSessionId(rec.sessionId)) {
         return {
             line: lineNo,
@@ -105,13 +61,6 @@ function parseLine(raw, lineNo) {
 function str(value) {
     return typeof value === 'string' && value !== '' ? value : undefined;
 }
-/**
- * Ingest a JSONL batch.
- *
- * Rejection is PER LINE and lossless: a single bad line never discards the rest
- * of the batch. One typo in a 100-event flush must not silently drop 99 real
- * events, and the caller still learns exactly which line failed and why.
- */
 export function ingestBatch(input, opts) {
     const source = opts.source.trim();
     if (!source)
@@ -157,9 +106,6 @@ export function ingestBatch(input, opts) {
             result.written += 1;
             continue;
         }
-        // Operational. `module: source` is what makes `--module factory` work;
-        // the envelope fields that have no EventPayload home ride along as payload
-        // keys, where sanitizePayload still applies its redaction rules.
         const payload = {
             module: source,
             ...parsed.payload,

package/dist/lib/exec-account-home.d.ts

@@ -8,22 +8,8 @@ interface NativeSpawnHome {
     execHome: string;
     source: SpawnHomeSource;
     slot?: DeviceAccountSlot;
-    /** Installation label when `source` is `legacy-home`. */
     label?: string;
 }
-/**
- * The env a DURABLE slot injects at spawn (PHNX-3940 T5/T6). A worker's slot
- * for an api-key harness (codex/grok/cursor/opencode/droid) holds no file — the
- * daemon pushed the account's worker API key into the reserved
- * `__<harness>__` store and `provisionWorkerSlot` recorded the slot as
- * `durable`; the key rides the harness's own env var (`CURSOR_API_KEY`, …)
- * on every launch. Anything else — a native login in the slot on a headed
- * device, a claude durable slot (its setup-token is a `.oauth_token` file the
- * adapter reads), a harness with no api-key worker kind, a headed device — injects
- * nothing.
- * Without this, `agents run cursor#gmail` on a worker reached Cursor with an
- * empty env and got `Authentication required … set CURSOR_API_KEY`.
- */
 export declare function durableSlotEnv(agent: AgentId, account: {
     id: string;
 }, resolved: Pick<NativeSpawnHome, 'slot'>, meta: Pick<Meta, 'accounts' | 'deviceAccounts'>, deps?: {
@@ -33,21 +19,11 @@ export declare function missingSlotHint(agent: AgentId, name: string): string;
 export declare function symlinkAdoptedAccountError(agent: AgentId, name: string, defaultName: string | undefined): string;
 export declare function adoptedSymlinkMismatchError(agent: AgentId, name: string, execHome: string): string;
 export declare function adoptedConfigPointsAtHome(agent: AgentId, home: string): boolean;
-/**
- * For a symlink-adopted harness, point `~/.<config>` at this account's slot
- * or throw. Does not write the harness default — the caller records that only
- * after this succeeds.
- */
 export declare function ensureAdoptedDefaultRepoint(agent: AgentId, account: {
     id: string;
     name: string;
     agent: AgentId;
 }, meta: Pick<Meta, 'accounts' | 'deviceAccounts'>): void;
-/**
- * Resolve the spawn HOME for a native account on THIS device.
- * Existing slot, then a provisionable worker slot, then a leftover `homes`
- * label, then identity match across installed homes, then fail loud.
- */
 export declare function resolveNativeSpawnHome(agent: AgentId, account: {
     id: string;
     name: string;