@socketsecurity/lib 6.0.8 → 6.0.10

package/dist/ai/route.d.mts

@@ -6,15 +6,16 @@
  *   credential for it is resolvable; otherwise the resolver walks a
  *   cross-engine equivalence ladder (Claude → Codex → an open-weight provider
  *   via opencode) and returns the best available equivalent. Why gate on
- *   existence: a fleet machine may have Claude but no Codex, or Codex but an
- *   expired Claude key, or neither plus an opencode/synthetic seat. Hard-coding
- *   `fable` then fails at spawn time; routing here degrades gracefully and
- *   tells the caller WHY (the `reason`), so a skill can log "fell back to codex
- *   gpt-5.5 (claude unavailable)" instead of crashing. Pure given an
- *   availability/keyed context — no I/O — so callers fan out their `which` +
- *   credential probes once and pass the result in. Pairs with `buildArgs` in
- *   `spawn.mts`: a Fable candidate carries `effort: undefined` because Fable is
- *   adaptive-thinking-only and the spawn layer omits `--effort` for it anyway.
+ *   existence: a Socket dev machine may have Claude but no Codex, or Codex but
+ *   an expired Claude key, or neither plus an opencode/synthetic seat.
+ *   Hard-coding `fable` then fails at spawn time; routing here degrades
+ *   gracefully and tells the caller WHY (the `reason`), so a skill can log
+ *   "fell back to codex gpt-5.5 (claude unavailable)" instead of crashing. Pure
+ *   given an availability/keyed context — no I/O — so callers fan out their
+ *   `which` + credential probes once and pass the result in. Pairs with
+ *   `buildArgs` in `spawn.mts`: a Fable candidate carries `effort: undefined`
+ *   because Fable is adaptive-thinking-only and the spawn layer omits
+ *   `--effort` for it anyway.
  */
 import type { CredentialProvider } from './credentials.mts';
 import type { AiAgentName, AiEffort } from './types.mts';
@@ -32,15 +33,16 @@ export interface TierCandidate {
 }
 /**
  * Why the resolver returned what it did. - `preferred` — the tier's
- * first-choice engine was available + keyed. - `fellback` — the preferred
- * engine was missing/unkeyed; an equivalent on another engine was used (`from`
- * names the original tier).
+ * first-choice engine was available + keyed. - `fell-over` — the preferred
+ * engine was missing/unkeyed; an equivalent on another engine was used
+ * (`requestedTier` names the tier originally asked for). Matches the
+ * `fellOver` vocabulary `spawnTierWithFallback` (spawn.mts) reports.
  */
-export type TierResolveReason = 'fellback' | 'preferred';
+export type TierResolveReason = 'fell-over' | 'preferred';
 export interface TierResolution {
     readonly candidate: TierCandidate;
     readonly reason: TierResolveReason;
-    readonly from?: AiTier | undefined;
+    readonly requestedTier?: AiTier | undefined;
 }
 /**
  * The context a caller probes once and passes in: which engine CLIs exist, and
@@ -62,8 +64,20 @@ export declare function isCandidateUsable(candidate: TierCandidate, ctx: RouteCo
  * Resolve a tier to the best available concrete target. Prefers the tier's
  * first-choice (Claude) candidate; if its engine is missing or unkeyed, walks
  * the cross-engine equivalence ladder and returns the first usable equivalent,
- * tagging the result `fellback` with the original tier in `from`. Returns
- * `undefined` only when NOTHING in the chain is usable — the caller then skips
- * the work or surfaces a "no AI engine available" message.
+ * tagging the result `fell-over` with the original tier in `requestedTier`.
+ * Returns `undefined` only when NOTHING in the chain is usable — the caller
+ * then skips the work or surfaces a "no AI engine available" message.
  */
 export declare function resolveTier(tier: AiTier, ctx: RouteContext): TierResolution | undefined;
+/**
+ * The ORDERED list of usable candidates for a tier — the runtime-fallback
+ * sequence. `resolveTier` returns only the single best pick (good when you
+ * trust it will work); this returns every usable candidate in preference order
+ * so a caller can advance to the next when one fails AT RUNTIME — e.g. the
+ * preferred model is installed + keyed (so it passes `isCandidateUsable`) yet
+ * its CLI reports it offline at spawn ("Claude Fable 5 is currently
+ * unavailable"). The static check can't predict an outage; only the spawn
+ * result can, so the caller walks this list until a spawn returns without the
+ * `unavailable` flag. Empty when nothing in the chain is usable.
+ */
+export declare function usableTierCandidates(tier: AiTier, ctx: RouteContext): TierCandidate[];

package/dist/ai/route.js

@@ -12,15 +12,16 @@ const require_ai_tier = require('./tier.js');
 *   credential for it is resolvable; otherwise the resolver walks a
 *   cross-engine equivalence ladder (Claude → Codex → an open-weight provider
 *   via opencode) and returns the best available equivalent. Why gate on
-*   existence: a fleet machine may have Claude but no Codex, or Codex but an
-*   expired Claude key, or neither plus an opencode/synthetic seat. Hard-coding
-*   `fable` then fails at spawn time; routing here degrades gracefully and
-*   tells the caller WHY (the `reason`), so a skill can log "fell back to codex
-*   gpt-5.5 (claude unavailable)" instead of crashing. Pure given an
-*   availability/keyed context — no I/O — so callers fan out their `which` +
-*   credential probes once and pass the result in. Pairs with `buildArgs` in
-*   `spawn.mts`: a Fable candidate carries `effort: undefined` because Fable is
-*   adaptive-thinking-only and the spawn layer omits `--effort` for it anyway.
+*   existence: a Socket dev machine may have Claude but no Codex, or Codex but
+*   an expired Claude key, or neither plus an opencode/synthetic seat.
+*   Hard-coding `fable` then fails at spawn time; routing here degrades
+*   gracefully and tells the caller WHY (the `reason`), so a skill can log
+*   "fell back to codex gpt-5.5 (claude unavailable)" instead of crashing. Pure
+*   given an availability/keyed context — no I/O — so callers fan out their
+*   `which` + credential probes once and pass the result in. Pairs with
+*   `buildArgs` in `spawn.mts`: a Fable candidate carries `effort: undefined`
+*   because Fable is adaptive-thinking-only and the spawn layer omits
+*   `--effort` for it anyway.
 */
 /**
 * Per-tier preference chain, most-preferred-first. The head is the "perfect"
@@ -54,7 +55,7 @@ const TIER_CHAINS = {
 		{
 			effort: "xhigh",
 			engine: "opencode",
-			model: "fireworks-ai/accounts/fireworks/models/glm-5p1",
+			model: "fireworks-ai/accounts/fireworks/models/glm-5p2",
 			provider: "fireworks"
 		}
 	],
@@ -74,7 +75,7 @@ const TIER_CHAINS = {
 		{
 			effort: "high",
 			engine: "opencode",
-			model: "fireworks-ai/accounts/fireworks/models/glm-5p1",
+			model: "fireworks-ai/accounts/fireworks/models/glm-5p2",
 			provider: "fireworks"
 		}
 	],
@@ -94,7 +95,7 @@ const TIER_CHAINS = {
 		{
 			effort: "medium",
 			engine: "opencode",
-			model: "synthetic/hf:moonshotai/Kimi-K2.5",
+			model: "synthetic/hf:moonshotai/Kimi-K2.6",
 			provider: "synthetic"
 		}
 	],
@@ -114,7 +115,7 @@ const TIER_CHAINS = {
 		{
 			effort: "low",
 			engine: "opencode",
-			model: "synthetic/hf:moonshotai/Kimi-K2.5",
+			model: "synthetic/hf:moonshotai/Kimi-K2.6",
 			provider: "synthetic"
 		}
 	]
@@ -131,9 +132,9 @@ function isCandidateUsable(candidate, ctx) {
 * Resolve a tier to the best available concrete target. Prefers the tier's
 * first-choice (Claude) candidate; if its engine is missing or unkeyed, walks
 * the cross-engine equivalence ladder and returns the first usable equivalent,
-* tagging the result `fellback` with the original tier in `from`. Returns
-* `undefined` only when NOTHING in the chain is usable — the caller then skips
-* the work or surfaces a "no AI engine available" message.
+* tagging the result `fell-over` with the original tier in `requestedTier`.
+* Returns `undefined` only when NOTHING in the chain is usable — the caller
+* then skips the work or surfaces a "no AI engine available" message.
 */
 function resolveTier(tier, ctx) {
 	const chain = TIER_CHAINS[tier] ?? TIER_CHAINS.sonnet;
@@ -144,13 +145,28 @@ function resolveTier(tier, ctx) {
 			reason: "preferred"
 		} : {
 			candidate,
-			from: tier,
-			reason: "fellback"
+			requestedTier: tier,
+			reason: "fell-over"
 		};
 	}
 }
+/**
+* The ORDERED list of usable candidates for a tier — the runtime-fallback
+* sequence. `resolveTier` returns only the single best pick (good when you
+* trust it will work); this returns every usable candidate in preference order
+* so a caller can advance to the next when one fails AT RUNTIME — e.g. the
+* preferred model is installed + keyed (so it passes `isCandidateUsable`) yet
+* its CLI reports it offline at spawn ("Claude Fable 5 is currently
+* unavailable"). The static check can't predict an outage; only the spawn
+* result can, so the caller walks this list until a spawn returns without the
+* `unavailable` flag. Empty when nothing in the chain is usable.
+*/
+function usableTierCandidates(tier, ctx) {
+	return (TIER_CHAINS[tier] ?? TIER_CHAINS.sonnet).filter((c) => isCandidateUsable(c, ctx));
+}
 
 //#endregion
 exports.TIER_CHAINS = TIER_CHAINS;
 exports.isCandidateUsable = isCandidateUsable;
-exports.resolveTier = resolveTier;
+exports.resolveTier = resolveTier;
+exports.usableTierCandidates = usableTierCandidates;

package/dist/ai/spawn.d.mts

@@ -5,12 +5,14 @@
  *   permissionMode / no-session-persistence). The helper enforces this at the
  *   type level (`SpawnAiAgentOptions` requires the relevant fields) AND at the
  *   spawn site (per-agent flag translator). Why CLI subprocess instead of an
- *   SDK call: the fleet's contract matches what the local user sees when
+ *   SDK call: Socket's contract matches what the local user sees when
  *   invoking the CLI — same auth config, same model availability, same tool
  *   permissions. SDK calls would diverge on auth handling and force per-agent
  *   SDK installs. Retry: 3 attempts on overload (HTTP 529 / "Overloaded"), exp.
  *   backoff (5s / 15s / 45s). Each retry is a fresh subprocess.
  */
+import type { RouteContext, TierCandidate } from './route.mts';
+import type { AiTier } from './tier.mts';
 import type { AgentSpawnResult, AiAgentName, SpawnAiAgentOptions } from './types.mts';
 export declare function backoffFor(attempt: number): number;
 /**
@@ -31,7 +33,9 @@ export declare function buildArgs(agent: AiAgentName, options: SpawnAiAgentOptio
  * shapes (`fable`, `claude-fable-5`, `mythos`, `claude-mythos-5`).
  */
 export declare function isAdaptiveOnlyModel(model: string): boolean;
+export declare function isModelUnavailable(stdout: string, stderr: string): boolean;
 export declare function isOverloaded(stdout: string, stderr: string): boolean;
+export declare function isQuotaExhausted(stdout: string, stderr: string): boolean;
 export declare function pickAgent(requested: AiAgentName | undefined, cwd: string): Promise<AiAgentName>;
 /**
  * Spawn an AI agent CLI subprocess with the locked-down flag set.
@@ -55,3 +59,32 @@ export declare function pickAgent(requested: AiAgentName | undefined, cwd: strin
  *   is requested, when none of the known agents are on PATH).
  */
 export declare function spawnAiAgent(options: SpawnAiAgentOptions): Promise<AgentSpawnResult>;
+/**
+ * Result of a tier spawn that may have fallen over one or more offline models.
+ * `result` is the spawn that actually ran (the first whose model was not
+ * `unavailable`, or the last attempt if every candidate was down). `candidate`
+ * is the engine/model that produced it. `fellOver` lists the candidates that
+ * reported their model offline before this one — empty on a first-try success.
+ */
+export interface TierSpawnResult {
+    readonly candidate: TierCandidate;
+    readonly fellOver: readonly TierCandidate[];
+    readonly result: AgentSpawnResult;
+}
+/**
+ * Spawn a tier's work, automatically FALLING OVER to the next agent when a
+ * model is offline. Walks the tier's usable candidates (Claude → Codex →
+ * open-weight) in order; if a spawn comes back with `unavailable` (the model is
+ * down or gated — e.g. "Claude Fable 5 is currently unavailable"), it advances
+ * to the next candidate instead of failing. This is the runtime complement to
+ * `route.mts`'s static availability check: that check can't predict an outage,
+ * so the live spawn result drives the fallback.
+ *
+ * Returns the first non-`unavailable` spawn (success OR a genuine work failure
+ * on a model that WAS reachable — a real failure shouldn't silently retry on a
+ * weaker model). If every candidate is offline, returns the last attempt with
+ * its `unavailable` flag set, so the caller can report "all models down".
+ * Throws only when the tier has no usable candidate at all (nothing installed +
+ * keyed) — same contract as `resolveTier` returning undefined.
+ */
+export declare function spawnTierWithFallback(tier: AiTier, ctx: RouteContext, options: Omit<SpawnAiAgentOptions, 'agent' | 'effort' | 'model'>): Promise<TierSpawnResult>;

package/dist/ai/spawn.js

@@ -1,6 +1,7 @@
 "use strict";
 /* Socket Lib - Built with rolldown */
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.js');
 const require_primordials_error = require('../primordials/error.js');
 const require_primordials_object = require('../primordials/object.js');
 const require_primordials_date = require('../primordials/date.js');
@@ -9,6 +10,9 @@ const require_process_spawn_errors = require('../process/spawn/errors.js');
 const require_process_spawn_child = require('../process/spawn/child.js');
 const require_ai_discover = require('./discover.js');
 const require_primordials_promise = require('../primordials/promise.js');
+const require_ai_route = require('./route.js');
+let node_process = require("node:process");
+node_process = require_runtime.__toESM(node_process, 1);
 
 //#region src/ai/spawn.mts
 /**
@@ -18,7 +22,7 @@ const require_primordials_promise = require('../primordials/promise.js');
 *   permissionMode / no-session-persistence). The helper enforces this at the
 *   type level (`SpawnAiAgentOptions` requires the relevant fields) AND at the
 *   spawn site (per-agent flag translator). Why CLI subprocess instead of an
-*   SDK call: the fleet's contract matches what the local user sees when
+*   SDK call: Socket's contract matches what the local user sees when
 *   invoking the CLI — same auth config, same model availability, same tool
 *   permissions. SDK calls would diverge on auth handling and force per-agent
 *   SDK installs. Retry: 3 attempts on overload (HTTP 529 / "Overloaded"), exp.
@@ -113,10 +117,64 @@ function buildArgs(agent, options) {
 function isAdaptiveOnlyModel(model) {
 	return /\b(?:fable|mythos)\b/i.test(model) || /claude-(?:fable|mythos)/i.test(model);
 }
+const MODEL_UNAVAILABLE_PHRASES = [
+	"access denied",
+	"currently unavailable",
+	"forbidden",
+	"have access",
+	"is unavailable",
+	"isn’t available",
+	"isn't available",
+	"may not exist",
+	"no access to",
+	"no such model",
+	"not authorized",
+	"not authorised",
+	"not available",
+	"permission denied",
+	"permission_denied",
+	"temporarily unavailable",
+	"unauthorized",
+	"unauthorised"
+];
+const MODEL_EXISTENCE_PHRASES = [
+	"does not exist",
+	"doesn't exist",
+	"no such",
+	"not exist",
+	"not found",
+	"unavailable",
+	"unknown",
+	"unreachable"
+];
+function isModelUnavailable(stdout, stderr) {
+	const text = `${stdout}\n${stderr}`.toLowerCase();
+	for (let i = 0, { length } = MODEL_UNAVAILABLE_PHRASES; i < length; i += 1) if (text.includes(MODEL_UNAVAILABLE_PHRASES[i])) return true;
+	if (/\bmodel[_-]?not[_-]?found\b/i.test(text) || /\bapi error:\s*(?:403|404)\b/i.test(text)) return true;
+	if (text.includes("model")) {
+		for (let i = 0, { length } = MODEL_EXISTENCE_PHRASES; i < length; i += 1) if (text.includes(MODEL_EXISTENCE_PHRASES[i])) return true;
+	}
+	return false;
+}
 function isOverloaded(stdout, stderr) {
 	const re = /API Error: 529|Overloaded/i;
 	return re.test(stdout) || re.test(stderr);
 }
+const QUOTA_EXHAUSTED_PHRASES = [
+	"exceeded your current quota",
+	"insufficient_quota",
+	"quota exceeded",
+	"rate limit",
+	"rate-limited",
+	"rate_limit_error",
+	"usage limit"
+];
+function isQuotaExhausted(stdout, stderr) {
+	const text = `${stdout}\n${stderr}`.toLowerCase();
+	if (/\bapi error:\s*429\b/.test(text) || text.includes("429 too many requests")) return true;
+	for (let i = 0, { length } = QUOTA_EXHAUSTED_PHRASES; i < length; i += 1) if (text.includes(QUOTA_EXHAUSTED_PHRASES[i])) return true;
+	return false;
+}
 async function pickAgent(requested, cwd) {
 	const discovered = await require_ai_discover.discoverAiAgents({ repoRoot: cwd });
 	if (requested) {
@@ -172,6 +230,10 @@ async function spawnAiAgent(options) {
 		try {
 			const child = require_process_spawn_child.spawn(agent, args, {
 				cwd: options.cwd,
+				...options.env ? { env: {
+					...node_process.default.env,
+					...options.env
+				} } : {},
 				stdio: "pipe",
 				stdioString: true,
 				timeout: options.timeoutMs
@@ -200,7 +262,54 @@ async function spawnAiAgent(options) {
 		exitCode,
 		overloaded: isOverloaded(stdout, stderr),
 		stderr,
-		stdout
+		stdout,
+		unavailable: isModelUnavailable(stdout, stderr)
+	};
+}
+/**
+* Spawn a tier's work, automatically FALLING OVER to the next agent when a
+* model is offline. Walks the tier's usable candidates (Claude → Codex →
+* open-weight) in order; if a spawn comes back with `unavailable` (the model is
+* down or gated — e.g. "Claude Fable 5 is currently unavailable"), it advances
+* to the next candidate instead of failing. This is the runtime complement to
+* `route.mts`'s static availability check: that check can't predict an outage,
+* so the live spawn result drives the fallback.
+*
+* Returns the first non-`unavailable` spawn (success OR a genuine work failure
+* on a model that WAS reachable — a real failure shouldn't silently retry on a
+* weaker model). If every candidate is offline, returns the last attempt with
+* its `unavailable` flag set, so the caller can report "all models down".
+* Throws only when the tier has no usable candidate at all (nothing installed +
+* keyed) — same contract as `resolveTier` returning undefined.
+*/
+async function spawnTierWithFallback(tier, ctx, options) {
+	const candidates = require_ai_route.usableTierCandidates(tier, ctx);
+	if (candidates.length === 0) throw new require_primordials_error.ErrorCtor(`spawnTierWithFallback: no usable agent for tier "${tier}". No candidate engine is both installed and keyed (checked: ${candidates.length}). Install/authenticate one of the tier's engines, or pick a different tier.`);
+	const fellOver = [];
+	let last;
+	for (let i = 0, { length } = candidates; i < length; i += 1) {
+		const candidate = candidates[i];
+		const result = await spawnAiAgent({
+			...options,
+			agent: candidate.engine,
+			effort: candidate.effort,
+			model: candidate.model
+		});
+		last = {
+			candidate,
+			result
+		};
+		if (!result.unavailable && !isQuotaExhausted(result.stdout, result.stderr)) return {
+			candidate,
+			fellOver,
+			result
+		};
+		fellOver.push(candidate);
+	}
+	return {
+		candidate: last.candidate,
+		fellOver: fellOver.slice(0, -1),
+		result: last.result
 	};
 }
 
@@ -208,6 +317,9 @@ async function spawnAiAgent(options) {
 exports.backoffFor = backoffFor;
 exports.buildArgs = buildArgs;
 exports.isAdaptiveOnlyModel = isAdaptiveOnlyModel;
+exports.isModelUnavailable = isModelUnavailable;
 exports.isOverloaded = isOverloaded;
+exports.isQuotaExhausted = isQuotaExhausted;
 exports.pickAgent = pickAgent;
-exports.spawnAiAgent = spawnAiAgent;
+exports.spawnAiAgent = spawnAiAgent;
+exports.spawnTierWithFallback = spawnTierWithFallback;

package/dist/ai/subagent-status.d.mts

@@ -44,5 +44,7 @@ export declare const SUBAGENT_STATUSES: readonly SubagentStatus[];
 export declare function escalationFor(status: SubagentStatus): SubagentEscalation;
 /**
  * True when `value` names a status in the contract.
+ *
+ * @unused No internal or Socket consumers (exercised only by its unit tests).
  */
 export declare function isSubagentStatus(value: string): value is SubagentStatus;

package/dist/ai/subagent-status.js

@@ -46,6 +46,8 @@ function escalationFor(status) {
 }
 /**
 * True when `value` names a status in the contract.
+*
+* @unused No internal or Socket consumers (exercised only by its unit tests).
 */
 function isSubagentStatus(value) {
 	return SUBAGENT_STATUSES.includes(value);

package/dist/ai/tier.d.mts

@@ -1,6 +1,6 @@
 /**
  * @file Canonical model + reasoning-effort ladder for AI orchestrators. The
- *   fleet's AI-fix / AI-codify orchestrators pick a capability TIER per unit of
+ *   Socket AI-fix / AI-codify orchestrators pick a capability TIER per unit of
  *   work (a lint rule, a hook, a doc edit) and resolve it to a concrete `{
  *   model, effort }` pair. Before this module each orchestrator redefined the
  *   same three-row table, so a model-generation bump (Sonnet 4.6 → 5.0, Opus

package/dist/ai/types.d.mts

@@ -1,5 +1,5 @@
 /**
- * @file Shared types for the locked-down AI agent surface. The fleet runs
+ * @file Shared types for the locked-down AI agent surface. Socket runs
  *   Claude / Codex / OpenCode / Gemini through CLI subprocesses, never via SDK
  *   calls. These types model the cross- agent contract: a permission mode, a
  *   tool allowlist, a tool denylist, a prompt, a working directory. Per-agent
@@ -13,7 +13,7 @@
  */
 export type AiAgentName = 'claude' | 'codex' | 'gemini' | 'opencode';
 /**
- * Permission mode passed to the agent's CLI. The fleet rule (CLAUDE.md
+ * Permission mode passed to the agent's CLI. Socket's rule (CLAUDE.md
  * "Programmatic Claude calls") requires every headless call to set one of these
  * explicitly — never the agent's default.
  *
@@ -56,6 +56,16 @@ export interface AgentSpawnResult {
     readonly overloaded: boolean;
     readonly stderr: string;
     readonly stdout: string;
+    /**
+     * True when the selected MODEL could not serve the request — it is offline
+     * (e.g. "Claude Fable 5 is currently unavailable") or gated/absent for this
+     * account ("issue with the selected model … may not exist or you may not have
+     * access"). Distinct from `overloaded`: the model is not coming back within a
+     * retry window, so the right response is to FALL OVER to the next agent in
+     * the tier chain rather than retry the same one. Both surface as a non-zero
+     * `exitCode`; this flag is how a caller knows to route elsewhere.
+     */
+    readonly unavailable: boolean;
 }
 /**
  * Inputs to a single agent spawn.
@@ -93,6 +103,13 @@ export interface SpawnAiAgentOptions {
      * claude-specific — other agents ignore it.
      */
     readonly effort?: AiEffort | undefined;
+    /**
+     * Extra environment variables for the spawned agent process, merged over the
+     * inherited env. Gated off by default (inherit-only when absent). Used by
+     * egress-containment callers to inject `HTTP_PROXY` / `NODE_OPTIONS`; no
+     * effect when omitted.
+     */
+    readonly env?: Readonly<Record<string, string>> | undefined;
     /**
      * Override the agent's flag list (rare; for one-off advanced cases).
      */

package/dist/ai/worktree.d.mts

@@ -1,6 +1,6 @@
 /**
  * @file Run AI agents in parallel, each in its own git worktree, and merge
- *   results back to the base branch. The fleet's CLAUDE.md "Parallel Claude
+ *   results back to the base branch. Socket's CLAUDE.md "Parallel Claude
  *   sessions" rule mandates worktree isolation when multiple agents touch the
  *   same checkout. This helper enforces that contract: each item gets a fresh
  *   worktree branched from the base, the per-item function runs inside it, then

package/dist/ai/worktree.js

@@ -17,7 +17,7 @@ node_path = require_runtime.__toESM(node_path, 1);
 //#region src/ai/worktree.mts
 /**
 * @file Run AI agents in parallel, each in its own git worktree, and merge
-*   results back to the base branch. The fleet's CLAUDE.md "Parallel Claude
+*   results back to the base branch. Socket's CLAUDE.md "Parallel Claude
 *   sessions" rule mandates worktree isolation when multiple agents touch the
 *   same checkout. This helper enforces that contract: each item gets a fresh
 *   worktree branched from the base, the per-item function runs inside it, then
@@ -152,7 +152,8 @@ async function spawnAiAgentsInWorktrees(items, fn, options) {
 			cursor += 1;
 			if (idx >= items.length) return;
 			const item = items[idx];
-			settled[idx] = await runOne(item, idx, `${namePrefix}-${idx}-${require_primordials_date.DateNow()}`, node_path.default.join(worktreeRoot, `${namePrefix}-${idx}`), baseRepo, branch, cleanup, fn);
+			const result = await runOne(item, idx, `${namePrefix}-${idx}-${require_primordials_date.DateNow()}`, node_path.default.join(worktreeRoot, `${namePrefix}-${idx}`), baseRepo, branch, cleanup, fn);
+			settled[idx] = result;
 		}
 	}
 	await require_primordials_promise.PromiseAll(require_primordials_array.ArrayFrom({ length: concurrency }, () => worker()));

package/dist/argv/parse.d.ts

@@ -61,6 +61,8 @@ export interface ParsedArgs<T = Record<string, unknown>> {
 }
 /**
  * Common parseArgs configuration for Socket registry scripts.
+ *
+ * @unused No internal or Socket consumers (exercised only by its unit tests).
  */
 export declare const commonParseArgsConfig: ParseArgsConfig;
 /**

package/dist/argv/parse.js

@@ -18,6 +18,8 @@ src_external_yargs_parser = require_runtime.__toESM(src_external_yargs_parser);
 */
 /**
 * Common parseArgs configuration for Socket registry scripts.
+*
+* @unused No internal or Socket consumers (exercised only by its unit tests).
 */
 const commonParseArgsConfig = {
 	options: {

package/dist/bin/_internal.d.ts

@@ -2,7 +2,7 @@
  * @file Private internals for `bin/*` modules — lazy `fs` / `path` accessors
  *   and the binary-resolution caches. Underscore prefix keeps this file out of
  *   the public exports map (see the `dist/<dir>/_<file>` ignore in
- *   scripts/post-build/make-package-exports.mts). Two caches:
+ *   scripts/fleet/make-package-exports.mts). Two caches:
  *
  *   1. `binPathCache` — maps a binary name to its first resolved path. Validated
  *      with `existsSync` before reuse so a stale cache doesn't survive a tool

package/dist/bin/_internal.js

@@ -10,7 +10,7 @@ const require_node_path = require('../node/path.js');
 * @file Private internals for `bin/*` modules — lazy `fs` / `path` accessors
 *   and the binary-resolution caches. Underscore prefix keeps this file out of
 *   the public exports map (see the `dist/<dir>/_<file>` ignore in
-*   scripts/post-build/make-package-exports.mts). Two caches:
+*   scripts/fleet/make-package-exports.mts). Two caches:
 *
 *   1. `binPathCache` — maps a binary name to its first resolved path. Validated
 *      with `existsSync` before reuse so a stale cache doesn't survive a tool