opencode-swarm 7.149.0 → 7.150.0

package/dist/cli/{index-bcfcekx9.js → index-qqs44wcp.js}

@@ -6,17 +6,17 @@ import {
   resolveExecutableFromPath,
   runEvaluation,
   runExternalTool
-} from "./index-vfv4vnnc.js";
+} from "./index-n99s022c.js";
 import {
   normalizeToolNameLowerCase,
   stableCanonicalStringify
-} from "./index-wsar7d91.js";
+} from "./index-bhg6brtw.js";
 import {
   detectStraySwarmDirs,
   readDoctorArtifact,
   removeStraySwarmDir,
   runConfigDoctor
-} from "./index-ccyve4pb.js";
+} from "./index-htqs4p52.js";
 import {
   MAX_TRANSIENT_RETRIES,
   archiveEvidence,
@@ -62,7 +62,7 @@ import {
   updateTaskStatus,
   validateProjectRoot,
   validateSymlinkBoundary
-} from "./index-kb1p6dpx.js";
+} from "./index-an922xj4.js";
 import {
   EvaluationTaskV1Schema,
   GateAuditManifestV1Schema,
@@ -79,7 +79,7 @@ import {
   saveGateAuditResult,
   savePromotionDecision,
   saveTaskSetSnapshot
-} from "./index-z6471b7r.js";
+} from "./index-prxrmc3b.js";
 import {
   loadDatabaseCtor
 } from "./index-134d35c1.js";
@@ -105,12 +105,12 @@ import {
 } from "./index-y8552snf.js";
 import {
   readRecentEscalations
-} from "./index-ef0wracg.js";
+} from "./index-g75rbw3e.js";
 import {
   alreadyCuratedThisGeneration,
   claimNextScanBatch,
   resolveCohortId
-} from "./index-s7t2c9jd.js";
+} from "./index-reknv4f9.js";
 import {
   CURATOR_INIT_PROMPT,
   CURATOR_PHASE_PROMPT,
@@ -159,7 +159,7 @@ import {
   listActive,
   subscribe,
   unsubscribe
-} from "./index-wbz365gn.js";
+} from "./index-k2sm9677.js";
 import {
   BUNDLED_PROJECT_SKILL_ROOT,
   DEFAULT_SKILL_MIN_CONFIDENCE,
@@ -180,7 +180,7 @@ import {
   retireSkill,
   selectCandidateEntries,
   syncBundledProjectSkillsIfMissingAsync
-} from "./index-42habrdv.js";
+} from "./index-1rww5k9e.js";
 import {
   appendUnactionable,
   quarantineEntry,
@@ -191,11 +191,11 @@ import {
   validateActionableFields,
   validateLesson,
   validateSkillPath
-} from "./index-8hkxm9mh.js";
+} from "./index-mnhagjvn.js";
 import {
   authorizeCuration,
   buildConfigFingerprintInput
-} from "./index-bmaz2yy4.js";
+} from "./index-4sdhbxgq.js";
 import {
   cohortConfigFingerprint
 } from "./index-rtry5xyf.js";
@@ -219,7 +219,7 @@ import {
   scanBackgroundCoderReservationsForAdmission,
   scanDelegationsForRecovery,
   sweepStaleDelegations
-} from "./index-n6jykega.js";
+} from "./index-vy6q9d8j.js";
 import {
   WORKTREE_LIFECYCLE_LOCK_FILE,
   recordWorktreeProvisioningOwner,
@@ -252,18 +252,18 @@ import {
   transitionTaskWorkflowEvidence,
   withTaskEvidenceTransaction,
   writeWorkflowWalFile
-} from "./index-5q5ws00e.js";
+} from "./index-1wmd5wn1.js";
 import {
   provisionWorktree,
   removeWorktree
-} from "./index-mza55jmc.js";
+} from "./index-1rpjd5na.js";
 import {
   MAX_PENDING_SCOPE_BINDINGS,
   canonicalWorkspaceIdentity,
   clearAllScopes,
   clearScopeBindingFromDisk,
   clearScopeBindings
-} from "./index-79pwr8hc.js";
+} from "./index-r5djc1cc.js";
 import {
   appendLedgerEvent,
   computePlanHash,
@@ -278,7 +278,7 @@ import {
   readPlanEpochIdentity,
   replayFromLedgerWithStatus,
   takeSnapshotEvent
-} from "./index-6thxr1q7.js";
+} from "./index-zyv56em5.js";
 import {
   CORE_EVENT_LOCKED,
   appendCoreEventSync,
@@ -288,7 +288,7 @@ import {
   hasSpecDriftAuditEvent,
   hasTaskRepairAuditEvent,
   readCoreEvents
-} from "./index-c83bztkp.js";
+} from "./index-exn0ztsv.js";
 import {
   isPathWithinDeclaredScope,
   sanitizeDiagnosticText
@@ -340,7 +340,7 @@ import {
   transactFile,
   transactKnowledge,
   wordBigrams
-} from "./index-01q7mb83.js";
+} from "./index-ma1p1w05.js";
 import {
   MAX_EVENT_LOG_ENTRIES,
   _internals as _internals2,
@@ -354,10 +354,10 @@ import {
   recordKnowledgeEvent,
   recordPhaseCloseIntent,
   resolveKnowledgeEventsPath
-} from "./index-pgfn8h50.js";
+} from "./index-0tn1kxej.js";
 import {
   resolveWorktreeIsolationConfig
-} from "./index-xdp0bx28.js";
+} from "./index-w9pb72vg.js";
 import {
   RetrospectiveEvidenceSchema
 } from "./index-gprxjmm7.js";
@@ -379,7 +379,7 @@ import {
   init_loader,
   loadPluginConfig,
   loadPluginConfigWithMeta
-} from "./index-q8e2yd98.js";
+} from "./index-t54jt9cs.js";
 import {
   DEFAULT_SKILL_OPT_CONFIG,
   FALLBACK_MODELS_MAX,
@@ -393,7 +393,7 @@ import {
   package_default,
   resolveAutoReviewConfig,
   stripKnownSwarmPrefix
-} from "./index-41n0thtd.js";
+} from "./index-mef0trex.js";
 import {
   AGENT_TOOL_MAP,
   ALL_AGENT_NAMES,
@@ -433,10 +433,10 @@ import {
   resolveLinkDir,
   sanitizeLinkId,
   writeLinkPointer
-} from "./index-c1h0rdkr.js";
+} from "./index-jb9tb1sd.js";
 import {
   atomicWriteFile
-} from "./index-cfvbd3dg.js";
+} from "./index-apwcvfjt.js";
 import {
   KNOWLEDGE_SCHEMA_VERSION,
   OUTCOME_BLOCK_THRESHOLD,
@@ -448,7 +448,7 @@ import {
   atomicWriteSwarmFileSync,
   matchTempGrammar,
   parseTargetBasename
-} from "./index-ame8ek9g.js";
+} from "./index-dtmgt2xn.js";
 import {
   assertProjectRoot,
   hasExplicitProjectBoundary,
@@ -456,12 +456,12 @@ import {
   listActiveLocks,
   tryAcquireLock,
   withEvidenceLock
-} from "./index-a90c1gtn.js";
+} from "./index-m8dn0qnm.js";
 import {
   emit,
   getLastHeartbeat,
   telemetry
-} from "./index-wj0gnab0.js";
+} from "./index-xggpmtfx.js";
 import {
   require_proper_lockfile
 } from "./index-7g4c7s5r.js";
@@ -599,6 +599,7 @@ function formatLegacyQaBindingRecovery(identity, retryAction) {
 }
 
 // src/db/qa-gate-profile.ts
+init_logger();
 var _internals5 = {
   getProfile,
   getProfileLookupForIdentity,
@@ -826,7 +827,9 @@ function hasAnyProfileWithEnabledGate(directory, gate) {
       const parsed = JSON.parse(row.gates);
       if (parsed?.[gate] === true)
         return true;
-    } catch {}
+    } catch (err) {
+      warn(`[qa-gate-profile] skipping unparseable qa_gate_profile row while checking gate "${gate}": ${err instanceof Error ? err.message : String(err)}`);
+    }
   }
   return false;
 }
@@ -5596,7 +5599,7 @@ async function cleanupRecoveredWorktree(directory, descriptor) {
     awaitingMergeByCallID,
     cleanupStandardWorktreeForCallId,
     standardWorktreeByCallID
-  } = await import("./worktree-isolation-pbr4d5m9.js");
+  } = await import("./worktree-isolation-pcr5zv0c.js");
   standardWorktreeByCallID.delete(descriptor.callID);
   if (hasResidue)
     awaitingMergeByCallID.set(descriptor.callID, {
@@ -5698,7 +5701,7 @@ async function recoverCoderSettlement(directory, taskId) {
           awaitingMergeByCallID,
           finishStandardWorktreeDispatch,
           standardWorktreeByCallID
-        } = await import("./worktree-isolation-pbr4d5m9.js");
+        } = await import("./worktree-isolation-pcr5zv0c.js");
         const descriptor = wal.worktree;
         const reconstructedDispatch = {
           callID: descriptor.callID,
@@ -6576,6 +6579,69 @@ function repairCleanEvidencePipes(text) {
   return { text: lines.join(`
 `), repaired };
 }
+function escapeCandidateField(value) {
+  return value.trim().replace(/\|/g, "\\|");
+}
+function repairCandidateEvidencePipes(text, family) {
+  let repaired = false;
+  const lines = text.split(/\r?\n/).map((line) => {
+    const fields = splitPipeFields(line);
+    if (fields[0]?.trim() !== CANDIDATE_MARKER || fields.length <= CANDIDATE_FIELD_COUNT + 1 || fields.length > CANDIDATE_FIELD_COUNT + 17 || !isCandidateConfidence(fields.at(-1)?.trim())) {
+      return line;
+    }
+    const normalized = fields.map(escapeCandidateField);
+    const overflowEvidence = family === "base_explorer" ? normalized.slice(7, -2) : normalized.slice(8, -1);
+    if (overflowEvidence.length < 3 || overflowEvidence.some((fragment) => fragment.length < 4)) {
+      return line;
+    }
+    const rebuilt = family === "base_explorer" ? [
+      ...normalized.slice(0, 7),
+      overflowEvidence.join(" \\| "),
+      ...normalized.slice(-2)
+    ] : [
+      ...normalized.slice(0, 8),
+      overflowEvidence.join(" \\| "),
+      normalized.at(-1) ?? ""
+    ];
+    if (rebuilt.length !== CANDIDATE_FIELD_COUNT + 1)
+      return line;
+    repaired = true;
+    return rebuilt.join(" | ");
+  });
+  return { text: lines.join(`
+`), repaired };
+}
+function resynchronizeLateCanonicalHeader(text, family) {
+  const lines = text.split(/\r?\n/);
+  const firstMarker = lines.findIndex((line) => {
+    const marker = splitPipeFields(line)[0]?.trim();
+    return marker === CANDIDATE_MARKER || marker === CLEAN_MARKER;
+  });
+  if (firstMarker < 0 || !analyzeCandidateLine(lines[firstMarker], family)?.valid) {
+    return { text, repaired: false };
+  }
+  const headerIndexes = lines.flatMap((line, index) => line.trim() === CANDIDATE_HEADERS[family] ? [index] : []);
+  if (!headerIndexes.some((index) => index > firstMarker)) {
+    return { text, repaired: false };
+  }
+  if (declaredCanonicalFamilies(text).some((declared) => declared !== family)) {
+    return { text, repaired: false };
+  }
+  const withoutHeaders = lines.filter((_line, index) => !headerIndexes.includes(index));
+  const insertion = withoutHeaders.findIndex((line) => {
+    const marker = splitPipeFields(line)[0]?.trim();
+    return marker === CANDIDATE_MARKER || marker === CLEAN_MARKER;
+  });
+  return {
+    text: [
+      ...withoutHeaders.slice(0, insertion),
+      CANDIDATE_HEADERS[family],
+      ...withoutHeaders.slice(insertion)
+    ].join(`
+`),
+    repaired: true
+  };
+}
 function isStrictProtocolDataLine(line, family) {
   const clean = repairRedundantCleanConfidenceLine(line, family).line;
   const fields = splitPipeFields(clean).map((field) => field.trim());
@@ -6644,7 +6710,15 @@ function normalizeCandidateArtifact(rawText, fallbackFamily) {
   const pipeRepair = repairCleanEvidencePipes(cleanRepair.text);
   if (pipeRepair.repaired)
     repairKinds.push("clean-evidence-pipe-tail-merge");
-  const duplicateHeaderDrop = dropDuplicateHeaderRows(pipeRepair.text);
+  const candidatePipeRepair = repairCandidateEvidencePipes(pipeRepair.text, fallbackFamily);
+  if (candidatePipeRepair.repaired) {
+    repairKinds.push("candidate-evidence-pipe-recovery-lossy");
+  }
+  const lateHeaderRepair = resynchronizeLateCanonicalHeader(candidatePipeRepair.text, fallbackFamily);
+  if (lateHeaderRepair.repaired) {
+    repairKinds.push("late-canonical-header-resynchronized");
+  }
+  const duplicateHeaderDrop = dropDuplicateHeaderRows(lateHeaderRepair.text);
   if (duplicateHeaderDrop.dropped) {
     repairKinds.push("duplicate-header-row-dropped");
   }
@@ -7680,13 +7754,24 @@ var PrReviewHandoffSchema = exports_external.object({
   summary: exports_external.string().trim().min(1).max(20000),
   provenance: exports_external.array(exports_external.string().trim().min(1).max(4000)).min(1).max(1000)
 }).strict();
+var PrReviewPartialBaseCoverageSchema = exports_external.object({
+  missing_dimension: exports_external.enum([
+    "intent-architecture",
+    "correctness-state",
+    "tests-falsifiability",
+    "security-trust",
+    "reliability-performance",
+    "compatibility-delivery"
+  ])
+}).strict();
 var WritePrReviewArtifactArgsSchema = exports_external.discriminatedUnion("kind", [
   exports_external.object({
     kind: exports_external.literal("findings"),
     run_id: PrReviewRunIdSchema.optional(),
     pr_head_sha: exports_external.string().trim().regex(/^[0-9a-f]{6,64}$/i),
     boundary: exports_external.enum(PR_REVIEW_ARTIFACT_BOUNDARIES),
-    records: exports_external.array(PrReviewFindingSchema).min(1).max(1000)
+    records: exports_external.array(PrReviewFindingSchema).min(1).max(1000),
+    partial_base_coverage: PrReviewPartialBaseCoverageSchema.optional()
   }).strict(),
   exports_external.object({
     kind: exports_external.literal("handoff"),
@@ -7695,6 +7780,13 @@ var WritePrReviewArtifactArgsSchema = exports_external.discriminatedUnion("kind"
     handoff: PrReviewHandoffSchema
   }).strict()
 ]).superRefine((value, ctx) => {
+  if (value.kind === "findings" && value.partial_base_coverage !== undefined && value.boundary !== "post_explorer") {
+    ctx.addIssue({
+      code: "custom",
+      path: ["partial_base_coverage"],
+      message: "is valid only for the post_explorer boundary"
+    });
+  }
   const bytes = serializedPrReviewArtifactInputBytes(value);
   const maxBytes = value.kind === "findings" ? PR_REVIEW_FINDINGS_WRITE_MAX_BYTES : PR_REVIEW_HANDOFF_WRITE_MAX_BYTES;
   if (bytes > maxBytes) {
@@ -8529,6 +8621,15 @@ var PrReviewResilienceStateRecordSchema = exports_external.object({
   attempts: exports_external.array(PrReviewResilienceAttemptRecordSchema).max(3),
   circuit: PrReviewResilienceCircuitRecordSchema.optional()
 }).strict();
+var PrReviewPartialBaseCoverageRecordSchema = exports_external.object({
+  runId: exports_external.string().min(1).max(128),
+  prHeadSha: exports_external.string().regex(/^[0-9a-f]{6,64}$/i),
+  revisionDigest: exports_external.string().min(1).max(256),
+  missingDimension: exports_external.enum(PR_REVIEW_BASE_DIMENSION_IDS),
+  failureClass: exports_external.enum(["contract", "resource", "deadline"]),
+  terminalEventId: exports_external.string().min(1).max(256),
+  admittedAt: exports_external.string().datetime()
+}).strict();
 var PrFeedbackLaneOwnershipSchema = exports_external.object({
   laneId: exports_external.string().min(1),
   ownedItemIds: exports_external.array(exports_external.string().min(1)).min(1)
@@ -8681,6 +8782,7 @@ var PrWorkflowGateStateSchema = exports_external.object({
   prReviewBaseDispatches: exports_external.array(PrReviewBaseDispatchRecordSchema).max(MAX_WORKFLOW_BATCHES).optional(),
   prReviewBaseDispatch: PrReviewBaseDispatchRecordSchema.optional(),
   prReviewResilience: PrReviewResilienceStateRecordSchema.optional(),
+  prReviewContractRetryDimensions: exports_external.array(PrReviewBaseDimensionIdSchema).max(PR_REVIEW_BASE_DIMENSION_IDS.length).optional(),
   prReviewTriggerLedger: exports_external.array(PrReviewInlineTriggerRowSchema).length(PR_REVIEW_REQUIRED_TRIGGER_IDS.length).optional(),
   prReviewTriggerEvalPath: exports_external.string().min(1).optional(),
   prReviewTriggerEvalRunId: exports_external.string().min(1).optional(),
@@ -8691,6 +8793,9 @@ var PrWorkflowGateStateSchema = exports_external.object({
   prReviewReservedRunId: exports_external.string().min(1).optional(),
   prReviewArtifactRunId: exports_external.string().min(1).optional(),
   prReviewFindingsPath: exports_external.string().min(1).optional(),
+  prReviewPartialBaseCoverage: PrReviewPartialBaseCoverageRecordSchema.optional(),
+  prReviewCoverageDisclosurePath: exports_external.string().min(1).max(512).optional(),
+  prReviewCoverageDisclosureDigest: exports_external.string().regex(/^[0-9a-f]{64}$/).optional(),
   prReviewArtifactBoundaries: exports_external.array(exports_external.enum(["post_explorer", "post_reviewer", "post_critic"])).max(3).optional(),
   prReviewHandoffPath: exports_external.string().min(1).optional(),
   prReviewHandoffRequired: exports_external.boolean().optional(),
@@ -8817,13 +8922,6 @@ var PR_WORKFLOW_SWEEPABLE_LANE_STATUSES = new Set(["pending", "running"]);
 var CAS_ESCAPE_DISCLOSURE = "state revision unsalvageable; cleared without compare-and-swap";
 var PR_WORKFLOW_LANE_LIVENESS_PROBE_TIMEOUT_MS = 5000;
 var PR_WORKFLOW_PENDING_LIVENESS_THRESHOLD_MS = 3 * 60000;
-var PR_WORKFLOW_PENDING_LIVENESS_MODES = new Set([
-  "swarm-pr-review:base",
-  "swarm-pr-review:micro",
-  "swarm-pr-review:council",
-  "swarm-pr-review:reviewer",
-  "swarm-pr-review:critic"
-]);
 var LIVE_SESSION_STATUS_TYPES = new Set([
   "busy",
   "retry"
@@ -9221,6 +9319,28 @@ async function assertPrFeedbackTrackingCheckout(directory, prHeadSha) {
     throw new Error(`BLOCKED: PR_FEEDBACK upstream "${attachedUpstream.remoteTrackingRef}" must point to the exact intake PR head "${prHeadSha}" before the first head bind`);
   }
 }
+function normalizeFailureSignatureText(value) {
+  return value.toLowerCase().replace(/\b\d{4}-\d{2}-\d{2}t\d{2}:\d{2}:\d{2}(?:\.\d{1,6})?(?:z|[+-]\d{2}:\d{2})\b/g, "<iso-timestamp>").replace(/\b\d{10,16}\b/g, "<epoch>").replace(/\b((?:session|request|trace|correlation|run)(?:[_-]?id)?)\s*[:=]\s*([a-z0-9._:-]*[0-9_-][a-z0-9._:-]*)\b/g, "$1=<id>").replace(/\b((?:session|sess|request|req|trace|correlation|corr|run)(?:[_-]?id)?)\s+((?:(?:sess?|req|trace|corr|run)[_-][a-z0-9._:-]+|[a-z][a-z0-9._:-]*\d[a-z0-9._:-]*))\b/g, "$1 <id>").replace(/\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/g, "<uuid>").replace(/\b[0-9a-f]{16,64}\b/g, "<hex>").replace(/[a-z]:\\[^\s)]+/gi, "<path>").replace(/(?:\/[\w.@:-]+)+/g, "<path>").replace(/\s+/g, " ").trim().slice(0, 160);
+}
+function classifyTerminalFailureSignature(record) {
+  if (!TERMINAL_FAILED_DELEGATION_STATUSES.has(record.status))
+    return null;
+  const result = record.terminalResult?.result ?? record.result;
+  if (!result)
+    return `terminal-zero-output:${record.status}`;
+  const outputRef = result.outputRef?.trim();
+  const text = result.text?.trim() ?? "";
+  if (!outputRef && text.length === 0 && (result.chars ?? 0) === 0) {
+    return `terminal-zero-output:${record.status}`;
+  }
+  const errorText = result.error?.trim();
+  if (errorText) {
+    return `terminal-error-output:${record.status}:${normalizeFailureSignatureText(errorText)}`;
+  }
+  if (record.status === "completed")
+    return null;
+  return `terminal-nonzero-output:${record.status}`;
+}
 var TERMINAL_FAILED_DELEGATION_STATUSES = new Set([
   "completed",
   "error",
@@ -9276,6 +9396,40 @@ function minimumConsolidatedLaneCover(sets) {
   }
   return best[full];
 }
+var PR_REVIEW_COVERAGE_DISCLOSURE_MAX_BYTES = 4096;
+function coverageDisclosureRelativePath(runId) {
+  return path12.join("pr-review", runId, "coverage-disclosure.json");
+}
+async function readAndVerifyCoverageDisclosure(directory, state) {
+  const record = state.prReviewPartialBaseCoverage;
+  const relativePath = state.prReviewCoverageDisclosurePath;
+  const expectedDigest = state.prReviewCoverageDisclosureDigest;
+  if (!record && !relativePath && !expectedDigest)
+    return null;
+  if (!record || !relativePath || !expectedDigest) {
+    throw new Error("BLOCKED: PR_REVIEW partial base coverage disclosure state is incomplete");
+  }
+  const expectedPath = coverageDisclosureRelativePath(record.runId).split(path12.sep).join("/");
+  if (relativePath !== expectedPath) {
+    throw new Error("BLOCKED: PR_REVIEW partial base coverage disclosure path does not match its bound run");
+  }
+  const raw = await readBoundedSwarmRegularFile(directory, relativePath, PR_REVIEW_COVERAGE_DISCLOSURE_MAX_BYTES, "PR_REVIEW partial base coverage disclosure");
+  const digest = createHash5("sha256").update(raw, "utf8").digest("hex");
+  if (digest !== expectedDigest) {
+    throw new Error("BLOCKED: PR_REVIEW partial base coverage disclosure digest does not match durable state");
+  }
+  let decoded;
+  try {
+    decoded = JSON.parse(raw);
+  } catch {
+    throw new Error("BLOCKED: PR_REVIEW partial base coverage disclosure is invalid JSON");
+  }
+  const parsed = PrReviewPartialBaseCoverageRecordSchema.safeParse(decoded);
+  if (!parsed.success || JSON.stringify(parsed.data) !== JSON.stringify(record)) {
+    throw new Error("BLOCKED: PR_REVIEW partial base coverage disclosure does not match durable state");
+  }
+  return record;
+}
 async function assertPrReviewBaseCoverageSettled(directory, sessionID, gateContext) {
   const state = await requireBoundState(directory, sessionID, "PR_REVIEW");
   const batches = state.prReviewBaseDispatches ?? [];
@@ -9293,6 +9447,10 @@ async function assertPrReviewBaseCoverageSettled(directory, sessionID, gateConte
   }
   const missing = PR_REVIEW_BASE_DIMENSION_IDS.filter((dimension) => !covered.has(dimension));
   if (missing.length > 0 || covered.size !== PR_REVIEW_BASE_DIMENSION_IDS.length) {
+    const disclosure = await readAndVerifyCoverageDisclosure(directory, state);
+    if (disclosure && missing.length === 1 && covered.size === PR_REVIEW_BASE_DIMENSION_IDS.length - 1 && disclosure.missingDimension === missing[0] && disclosure.prHeadSha === state.prHeadSha && disclosure.revisionDigest === ctx.revisionDigest && disclosure.runId === (state.prReviewArtifactRunId ?? state.prReviewReservedRunId)) {
+      return state;
+    }
     throw new Error(`BLOCKED: PR_REVIEW base coverage is incomplete; missing dimensions: ${missing.join(", ") || "(none)"}${malformedDiagnostics.length > 0 ? `; first failed lane predicates: ${malformedDiagnostics.join(" | ")}` : ""}; valid dimensions: ${PR_REVIEW_BASE_DIMENSION_IDS.join(", ")}; expected candidate row: ${CANDIDATE_HEADERS.base_explorer}; expected clean row: ${CLEAN_TEMPLATES.base_explorer}`);
   }
   return state;
@@ -9794,6 +9952,7 @@ async function transitionPrReviewToFeedback(directory, sessionID, request) {
   }));
 }
 var _test_exports2 = {
+  classifyTerminalFailureSignature,
   minimumConsolidatedLaneCover,
   analyzePrReviewBatchRecordIntegrity,
   MAX_COVER_UNIVERSE_BITS,
@@ -13089,6 +13248,7 @@ async function computeGateStatistics(directory, minSamples = 6, runId) {
 }
 
 // src/services/cost-accounting.ts
+init_logger();
 import * as fs8 from "fs";
 import * as os from "os";
 import * as path15 from "path";
@@ -13121,11 +13281,17 @@ function readTelemetryEvents(directory) {
     }
   } catch {}
   const events = [];
+  let unreadableSnapshots = 0;
+  let firstUnreadableReason = "";
   for (const file of snapshotFiles) {
     let content = "";
     try {
       content = fs8.readFileSync(file, "utf-8");
-    } catch {
+    } catch (err) {
+      unreadableSnapshots += 1;
+      if (!firstUnreadableReason) {
+        firstUnreadableReason = err instanceof Error ? err.message : String(err);
+      }
       continue;
     }
     for (const line of content.split(/\r?\n/)) {
@@ -13139,6 +13305,9 @@ function readTelemetryEvents(directory) {
       } catch {}
     }
   }
+  if (unreadableSnapshots > 0) {
+    warn(`[cost-accounting] ${unreadableSnapshots} of ${snapshotFiles.length} snapshot file(s) were unreadable; cost totals undercount. First reason: ${firstUnreadableReason}`);
+  }
   try {
     for (const f of snapshotFiles) {
       try {
@@ -16121,8 +16290,40 @@ function redactUrl(match) {
     return `<url:${hashValue(match).slice(0, 12)}>`;
   }
 }
+var FILL_MAX_RUN = 8;
+var FILL = `[\\s\\p{Cc}\\p{Cf}\\p{Default_Ignorable_Code_Point}]{0,${FILL_MAX_RUN}}`;
+var CONTROL_CHAR_RUN = /[\p{Cc}\p{Cf}\p{Default_Ignorable_Code_Point}]+/gu;
+var MAX_SANITIZE_INPUT_CHARS = MAX_DISPLAY_BYTES * 8;
+function tolerantKeyword(word) {
+  return word.split("").join(FILL);
+}
+var CREDENTIAL_KEYWORDS_LOWER = [
+  "bearer",
+  "token",
+  "secret",
+  "password",
+  "authorization"
+].map(tolerantKeyword);
+var API_KEY_PATTERN = `${tolerantKeyword("api")}${FILL}[_-]?${FILL}${tolerantKeyword("key")}`;
+var CREDENTIAL_KEYWORD_ALTERNATION = `(?:${API_KEY_PATTERN}|${CREDENTIAL_KEYWORDS_LOWER.join("|")})`;
+var SCREAMING_SUFFIXES = ["TOKEN", "KEY", "SECRET", "PASSWORD", "AUTH"];
+var TOLERANT_BEARER_PREFIX = tolerantKeyword("Bearer");
+var CREDENTIAL_KV_PATTERN = new RegExp(`\\b(${CREDENTIAL_KEYWORD_ALTERNATION})\\b${FILL}[:=]${FILL}(?:${TOLERANT_BEARER_PREFIX}${FILL})?[^\\s,;]+`, "giu");
+var SCREAMING_KEY_HORIZONTAL_FILL_CHARS = "\\x00-\\x09\\x0e-\\x1f\\x7f-\\x9f\\p{Zs}\\p{Cf}\\p{Default_Ignorable_Code_Point}";
+var SCREAMING_KV_CANDIDATE_PATTERN = new RegExp(`\\b([A-Z0-9_${SCREAMING_KEY_HORIZONTAL_FILL_CHARS}]{1,80})${FILL}=${FILL}([^\\s]+)`, "gu");
+function screamingKeyContainsSuffix(key) {
+  const stripped = key.replace(CONTROL_CHAR_RUN, "").replace(/\s+/g, "");
+  return SCREAMING_SUFFIXES.some((suffix) => stripped.includes(suffix));
+}
 function sanitizeFailureEvidenceDisplay(value) {
-  const redacted = value.replace(/\bhttps?:\/\/[^\s'"<>]+/gi, (match) => redactUrl(match)).replace(/\b((?:api[_-]?key|bearer|token|secret|password|authorization))\b\s*[:=]\s*(?:Bearer\s+)?[^\s,;]+/gi, (_, key) => `${key}=<redacted>`).replace(/\b([A-Z][A-Z0-9_]*(?:TOKEN|KEY|SECRET|PASSWORD|AUTH)[A-Z0-9_]*)=([^\s]+)/g, (_, key) => `${key}=<redacted>`);
+  const bounded = value.slice(0, MAX_SANITIZE_INPUT_CHARS);
+  const redacted = bounded.replace(/\bhttps?:\/\/[^\s'"<>]+/gi, (match) => redactUrl(match)).replace(CREDENTIAL_KV_PATTERN, (_, key) => {
+    return `${key.replace(CONTROL_CHAR_RUN, "")}=<redacted>`;
+  }).replace(SCREAMING_KV_CANDIDATE_PATTERN, (match, key) => {
+    if (!screamingKeyContainsSuffix(key))
+      return match;
+    return `${key.replace(CONTROL_CHAR_RUN, "").replace(/\s+/g, "")}=<redacted>`;
+  }).replace(CONTROL_CHAR_RUN, " ");
   return boundedUtf8(redacted.trim());
 }
 function signalFrom(value) {
@@ -18302,7 +18503,7 @@ function planMerges(active, threshold, maxComparisons, maxMerges) {
   };
 }
 async function sweepActiveNearDuplicates(directory, options = {}) {
-  const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-hbhw2qd7.js");
+  const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-s0xz2520.js");
   const { config } = loadPluginConfigWithMeta2(directory);
   const sweepConfig = config.learning?.dedup_sweep;
   if (sweepConfig?.enabled === false)
@@ -19432,7 +19633,7 @@ async function runCuratorPhase(directory, phase, agentsDispatched, config, knowl
     }
     if (config.skill_generation_enabled === true && skillCandidates.length > 0) {
       try {
-        const skillModule = await import("./skill-generator-esrn40th.js");
+        const skillModule = await import("./skill-generator-0gmpxwgk.js");
         for (const cand of skillCandidates) {
           if (cand.confidence < (config.min_skill_confidence ?? DEFAULT_SKILL_MIN_CONFIDENCE)) {
             continue;
@@ -19904,7 +20105,7 @@ async function applyCuratorKnowledgeUpdates(directory, recommendations, knowledg
     } catch {}
   }
   if (contradictedEntries.length > 0 && knowledgeConfig.contradiction_threshold_action === "quarantine") {
-    const { maybeQuarantineOnContradiction } = await import("./knowledge-escalator-ty2kesdj.js");
+    const { maybeQuarantineOnContradiction } = await import("./knowledge-escalator-pc7smwrd.js");
     for (const { id } of contradictedEntries) {
       try {
         await maybeQuarantineOnContradiction(directory, id, knowledgeConfig.contradiction_quarantine_threshold, knowledgeConfig.contradiction_quarantine_window_days);
@@ -20723,7 +20924,7 @@ async function runCuratorPostMortem(directory, options = {}) {
       warnings.push("Failed to collect knowledge summary.");
     }
     try {
-      const { getScanStatus } = await import("./scan-cursor-3ba1spad.js");
+      const { getScanStatus } = await import("./scan-cursor-hr8e3jqj.js");
       const scanStatus = await getScanStatus(directory);
       if (scanStatus.remaining_estimate > 0) {
         warnings.push(`Fair scan: reviewed ${knowledgeSummary.length} entries this sweep (generation ${scanStatus.generation}); ${scanStatus.remaining_estimate} more eligible entries will be visited in future curation sweeps.`);
@@ -20895,9 +21096,9 @@ var _internals26 = {
   verifyPostMortemKnowledgeActions,
   repairPostMortemActions,
   loadDefaultKnowledgeConfig: async (directory) => {
-    const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-h251vmd1.js");
+    const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-g44y7s0w.js");
     try {
-      const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-hbhw2qd7.js");
+      const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-s0xz2520.js");
       const loaded = loadPluginConfigWithMeta2(directory);
       return KnowledgeConfigSchema2.parse(loaded.config.knowledge ?? {});
     } catch {
@@ -20905,11 +21106,11 @@ var _internals26 = {
     }
   },
   applyCuratorKnowledgeUpdates: async (directory, recommendations, knowledgeConfig, generation) => {
-    const { applyCuratorKnowledgeUpdates: applyCuratorKnowledgeUpdates2 } = await import("./curator-6w4frzdz.js");
+    const { applyCuratorKnowledgeUpdates: applyCuratorKnowledgeUpdates2 } = await import("./curator-frrehxxe.js");
     return applyCuratorKnowledgeUpdates2(directory, recommendations, knowledgeConfig, generation);
   },
   checkHivePromotions: async (entries, knowledgeConfig, directory) => {
-    const { checkHivePromotions } = await import("./hive-promoter-32artf8c.js");
+    const { checkHivePromotions } = await import("./hive-promoter-10zv1b45.js");
     return checkHivePromotions(entries, knowledgeConfig, directory);
   },
   applyProposalTriage: async (directory, triage) => {
@@ -20918,7 +21119,7 @@ var _internals26 = {
       activateProposal,
       listSkills: listSkills2,
       sanitizeSlug
-    } = await import("./skill-generator-esrn40th.js");
+    } = await import("./skill-generator-0gmpxwgk.js");
     const result = {
       approved: [],
       rejected: [],
@@ -22248,9 +22449,9 @@ function hashContent(content) {
   return createHash10("sha1").update(content).digest("hex");
 }
 async function loadConfigForPolicyCurator(directory) {
-  const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-h251vmd1.js");
+  const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-g44y7s0w.js");
   try {
-    const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-hbhw2qd7.js");
+    const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-s0xz2520.js");
     const { config: loadedConfig } = loadPluginConfigWithMeta2(directory);
     return KnowledgeConfigSchema2.parse(loadedConfig.knowledge ?? {});
   } catch {
@@ -29894,7 +30095,8 @@ function gatherToolProblems(toolAggregates) {
           failureCount: agg.failureCount,
           totalCalls: agg.count,
           failureRate: Math.round(failureRate * 100) / 100,
-          avgDurationMs: Math.round(agg.totalDuration / agg.count)
+          avgDurationMs: Math.round(agg.totalDuration / agg.count),
+          ...agg.failureReasons && agg.failureReasons.length > 0 ? { failureReasons: agg.failureReasons } : {}
         });
       }
     }
@@ -30205,6 +30407,9 @@ function buildReflectionDataSummary(data) {
     lines.push("TOOL PROBLEMS (tools with >20% failure rate or >2 failures):");
     for (const p of data.toolProblems) {
       lines.push(`  - ${p.tool}: ${p.failureCount}/${p.totalCalls} failures (${Math.round(p.failureRate * 100)}%), avg ${p.avgDurationMs}ms`);
+      if (p.failureReasons && p.failureReasons.length > 0) {
+        lines.push(`      reasons: ${p.failureReasons.join("; ")}`);
+      }
     }
     lines.push("");
   }
@@ -30320,7 +30525,7 @@ function buildSignalsBlock(data) {
     if (p.failureCount > 0) {
       reproBacked.push({
         title: `Tool ${p.tool} failing (${p.failureCount}/${p.totalCalls}, ${Math.round(p.failureRate * 100)}%)`,
-        evidence: `tool failure rate ${Math.round(p.failureRate * 100)}% (${p.failureCount}/${p.totalCalls})`
+        evidence: `tool failure rate ${Math.round(p.failureRate * 100)}% (${p.failureCount}/${p.totalCalls})${p.failureReasons && p.failureReasons.length > 0 ? `; reasons: ${p.failureReasons.join("; ")}` : ""}`
       });
     }
   }
@@ -30463,6 +30668,9 @@ function buildDeterministicReport(data) {
     lines.push("");
     for (const p of data.toolProblems) {
       lines.push(`- **${p.tool}**: ${p.failureCount}/${p.totalCalls} failures (${Math.round(p.failureRate * 100)}%), avg ${p.avgDurationMs}ms per call`);
+      if (p.failureReasons && p.failureReasons.length > 0) {
+        lines.push(`  - reasons: ${p.failureReasons.join("; ")}`);
+      }
     }
     lines.push("");
   }
@@ -33450,7 +33658,7 @@ async function runFinalizeStage(ctx) {
     }
   }
   try {
-    const { CuratorConfigSchema: CCS } = await import("./schema-h251vmd1.js");
+    const { CuratorConfigSchema: CCS } = await import("./schema-g44y7s0w.js");
     const { config: pmLoadedConfig } = _internals41.loadPluginConfigWithMeta(ctx.directory);
     const curatorCfg = CCS.parse(pmLoadedConfig.curator ?? {});
     if (curatorCfg.enabled && curatorCfg.postmortem_enabled) {
@@ -34320,7 +34528,7 @@ var _internals41 = {
   closePlanTerminalState: reconcileCloseTerminalStateForPlan,
   endAgentSession,
   flushAndDrainTelemetry: async () => {
-    const { flushAndDrainTelemetry } = await import("./telemetry-jtq6px7k.js");
+    const { flushAndDrainTelemetry } = await import("./telemetry-5deacb7w.js");
     return flushAndDrainTelemetry();
   },
   finalizeContextTelemetry: (directory) => {
@@ -35652,9 +35860,9 @@ var _internals45 = {
   loadPluginConfigWithMeta,
   loadCuratorDeps: async () => {
     const [{ CuratorConfigSchema }, curator, { createCuratorLLMDelegate: createCuratorLLMDelegate2 }] = await Promise.all([
-      import("./schema-h251vmd1.js"),
-      import("./curator-6w4frzdz.js"),
-      import("./curator-llm-factory-8fstpeqh.js")
+      import("./schema-g44y7s0w.js"),
+      import("./curator-frrehxxe.js"),
+      import("./curator-llm-factory-b83jsg02.js")
     ]);
     return { CuratorConfigSchema, curator, createCuratorLLMDelegate: createCuratorLLMDelegate2 };
   }
@@ -36644,7 +36852,7 @@ async function computeCurationDiagnostics(directory, entries) {
   let scanCompleted = false;
   let scanRemaining = 0;
   try {
-    const { getScanStatus } = await import("./scan-cursor-3ba1spad.js");
+    const { getScanStatus } = await import("./scan-cursor-hr8e3jqj.js");
     const status = await getScanStatus(directory);
     scanGeneration = status.generation;
     scanCompleted = status.completed;
@@ -36652,19 +36860,19 @@ async function computeCurationDiagnostics(directory, entries) {
   } catch {}
   let configMatch = null;
   try {
-    const { isLinked: isLinked2 } = await import("./knowledge-link-a5f89833.js");
+    const { isLinked: isLinked2 } = await import("./knowledge-link-mzn8x0qd.js");
     if (isLinked2(directory)) {
-      const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-h251vmd1.js");
+      const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-g44y7s0w.js");
       let config;
       try {
-        const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-hbhw2qd7.js");
+        const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-s0xz2520.js");
         const loaded = loadPluginConfigWithMeta2(directory);
         config = KnowledgeConfigSchema2.parse(loaded.config.knowledge ?? {});
       } catch {
         config = KnowledgeConfigSchema2.parse({});
       }
       const { cohortConfigFingerprint: cohortConfigFingerprint2 } = await import("./config-fingerprint-v22xh5a2.js");
-      const { buildConfigFingerprintInput: buildConfigFingerprintInput2, readCohortConfigFingerprint } = await import("./curation-policy-4jxx3ey4.js");
+      const { buildConfigFingerprintInput: buildConfigFingerprintInput2, readCohortConfigFingerprint } = await import("./curation-policy-nck9g765.js");
       const currentFp = cohortConfigFingerprint2(buildConfigFingerprintInput2(config));
       const cohortFp = await readCohortConfigFingerprint(directory);
       configMatch = cohortFp === null ? null : currentFp === cohortFp;
@@ -37968,7 +38176,7 @@ async function handleDoctorCommand(directory, args) {
   const result = runConfigDoctor(config, directory);
   let output;
   if (enableAutoFix && result.hasAutoFixableIssues) {
-    const { runConfigDoctorWithFixes } = await import("./config-doctor-fx8d6pma.js");
+    const { runConfigDoctorWithFixes } = await import("./config-doctor-96qyv31a.js");
     const fixResult = await runConfigDoctorWithFixes(directory, config, true, {
       applyLossy: true
     });
@@ -38908,7 +39116,7 @@ async function handleEvidenceCommand(directory, args) {
   return formatTaskEvidenceMarkdown(evidenceData);
 }
 async function handleEvidenceSummaryCommand(directory) {
-  const { buildEvidenceSummary } = await import("./evidence-summary-service-x00z38n2.js");
+  const { buildEvidenceSummary } = await import("./evidence-summary-service-dv4bt2bx.js");
   const artifact = await buildEvidenceSummary(directory);
   if (!artifact) {
     return "No plan found. Run `/swarm plan` to check plan status.";
@@ -50113,6 +50321,8 @@ var QUERIES = {
 			) @func.def
 			(class_declaration name: (name) @class.name) @class.def
 			(interface_declaration name: (name) @interface.name) @interface.def
+			(trait_declaration name: (name) @trait.name) @trait.def
+			(enum_declaration name: (name) @enum.name) @enum.def
 		`,
     imports: `
 			(namespace_use_declaration) @import
@@ -50359,6 +50569,7 @@ function buildFacts(tree, qs, grammarId) {
       defNameKeys.add(nodeKey(nameNode));
     }
   }
+  augmentNativeDynamicDefs(grammarId, root.text, defs);
   const importsWithIndex = [];
   const addImport = (entry, node) => {
     if (!entry)
@@ -50440,12 +50651,28 @@ function buildFacts(tree, qs, grammarId) {
       }
     }
   }
-  if (isEsMGrammar(grammarId)) {
+  if (isEsMGrammar(grammarId) || grammarId === "dart") {
     for (const exportNode of exportNodes) {
       addImport(parseImport(grammarId, exportNode.text.trim()), exportNode);
     }
   }
-  const imports = importsWithIndex.sort((a, b) => a.index - b.index).map((item) => item.entry);
+  for (const fallback of fallbackImportsForSource(grammarId, root.text)) {
+    importsWithIndex.push(fallback);
+  }
+  const seenImports = new Set;
+  const imports = importsWithIndex.sort((a, b) => a.index - b.index).map((item) => item.entry).filter((entry) => {
+    const key = JSON.stringify([
+      entry.specifier,
+      entry.importType,
+      entry.bindings,
+      entry.reExport ?? false,
+      entry.exportedBindings ?? []
+    ]);
+    if (seenImports.has(key))
+      return false;
+    seenImports.add(key);
+    return true;
+  });
   const topLevelDefs = defNodes.filter((d) => isTopLevelDef(d.node, root)).map((d) => ({ name: d.name, node: d.node }));
   const refs = [];
   const refParamTypes = grammarId === "swift" ? SWIFT_REF_PARAM_TYPES : PARAM_TYPES;
@@ -50490,7 +50717,390 @@ function buildFacts(tree, qs, grammarId) {
       });
     }
   }
-  return { defs, imports, refs };
+  const normalizedDefs = defs.map((def) => ({
+    ...def,
+    endLine: Math.max(def.endLine, def.startLine)
+  }));
+  return { defs: normalizedDefs, imports, refs };
+}
+function augmentNativeDynamicDefs(grammarId, source, defs) {
+  switch (grammarId) {
+    case "dart":
+      augmentDartDefs(source, defs);
+      return;
+    case "ruby":
+      augmentRubyDefs(source, defs);
+      return;
+    case "php":
+      augmentPhpDefs(source, defs);
+      return;
+  }
+}
+function upsertAugmentedDef(defs, def) {
+  const existing = defs.find((item) => item.name === def.name && item.startLine === def.startLine);
+  if (existing) {
+    existing.kind = def.kind;
+    existing.exported = def.exported;
+    existing.visibilityInfo = def.visibilityInfo;
+    existing.endLine = Math.max(existing.endLine, def.endLine);
+    return;
+  }
+  defs.push(def);
+}
+function symbolVisibilityInfo(visibility, exported, exportedReason) {
+  return {
+    exported,
+    visibility,
+    exportedReason,
+    apiSurfaceKind: exported ? "public" : "private"
+  };
+}
+function addRegexDef(defs, source, name, kind, start, end, visibility, exported, exportedReason) {
+  upsertAugmentedDef(defs, {
+    name,
+    kind,
+    exported,
+    visibilityInfo: symbolVisibilityInfo(visibility, exported, exportedReason),
+    startLine: lineNumberAt(source, start),
+    endLine: lineNumberAt(source, end)
+  });
+}
+function findMatchingBrace(source, openIndex) {
+  if (source[openIndex] !== "{")
+    return null;
+  let depth = 0;
+  for (let i = openIndex;i < source.length; i++) {
+    const ch = source[i];
+    if (ch === "{")
+      depth++;
+    else if (ch === "}") {
+      depth--;
+      if (depth === 0)
+        return i;
+    }
+  }
+  return null;
+}
+function lineNumberAt(text, index) {
+  let line = 1;
+  for (let i = 0;i < index && i < text.length; i++) {
+    if (text[i] === `
+`)
+      line++;
+  }
+  return line;
+}
+function advanceLineOffset(source, offset, lineLength) {
+  const after = offset + lineLength;
+  if (source[after] === "\r" && source[after + 1] === `
+`)
+    return after + 2;
+  if (source[after] === `
+` || source[after] === "\r")
+    return after + 1;
+  return after;
+}
+function declarationEnd(source, start) {
+  const open2 = source.indexOf("{", start);
+  const semi = source.indexOf(";", start);
+  if (open2 !== -1 && (semi === -1 || open2 < semi)) {
+    return findMatchingBrace(source, open2) ?? open2;
+  }
+  return semi === -1 ? start : semi;
+}
+var dartTypeRe = /\b(extension\s+type|class|mixin|enum|extension|typedef)\s+(?!on\b)([A-Za-z_][A-Za-z0-9_]*)/g;
+function maskCommentsForAugment(source) {
+  let out = "";
+  let inBlock = false;
+  let quote = null;
+  for (let i = 0;i < source.length; i++) {
+    const ch = source[i];
+    const two = source.substring(i, i + 2);
+    if (quote !== null) {
+      if (ch === "\\") {
+        out += "  ";
+        i++;
+        continue;
+      }
+      if (ch === quote) {
+        quote = null;
+        out += ch;
+      } else {
+        out += ch === `
+` ? `
+` : " ";
+      }
+      continue;
+    }
+    if (!inBlock && two === "/*") {
+      inBlock = true;
+      out += "  ";
+      i++;
+      continue;
+    }
+    if (inBlock) {
+      if (two === "*/") {
+        inBlock = false;
+        out += "  ";
+        i++;
+      } else {
+        out += source[i] === `
+` ? `
+` : " ";
+      }
+      continue;
+    }
+    if (two === "//" || source[i] === "#") {
+      out += two === "//" ? "  " : " ";
+      if (two === "//")
+        i++;
+      while (i + 1 < source.length && source[i + 1] !== `
+`) {
+        out += " ";
+        i++;
+      }
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      if (source[i + 1] === ch && source[i + 2] === ch) {
+        out += ch + ch + ch;
+        i += 2;
+        while (i + 1 < source.length) {
+          if (source[i + 1] === ch && source[i + 2] === ch && source[i + 3] === ch) {
+            out += ch + ch + ch;
+            i += 3;
+            break;
+          }
+          out += source[i + 1] === `
+` ? `
+` : " ";
+          i++;
+        }
+        continue;
+      }
+      quote = ch;
+      out += ch;
+      continue;
+    }
+    out += ch;
+  }
+  return out;
+}
+function augmentDartDefs(source, defs) {
+  const masked = maskCommentsForAugment(source);
+  dartTypeRe.lastIndex = 0;
+  for (let m = dartTypeRe.exec(masked);m !== null; m = dartTypeRe.exec(masked)) {
+    const exported = !m[2].startsWith("_");
+    const kindWord = m[1].trim().split(/\s+/).pop() ?? m[1];
+    addRegexDef(defs, source, m[2], kindWord === "enum" ? "enum" : kindWord === "class" ? "class" : "type", m.index, declarationEnd(masked, m.index), exported ? "public" : "private", exported, exported ? "naming_convention" : "unknown");
+  }
+}
+var rubyMethodDefNameRe = /^def\s+(?:(self)\.)?([A-Za-z_][A-Za-z0-9_?!]*)/;
+var rubyTargetedVisibilityRe = /^(private|protected)\s+((?::[A-Za-z_][A-Za-z0-9_?!]*\s*,\s*)*:[A-Za-z_][A-Za-z0-9_?!]*)$/;
+var rubyEndWordRe = /\bend\b/g;
+var rubyHeredocOpenRe = /(?:^|[=(,[]\s*|(?:puts|print|raise|return|p)\s+)<<[~-]?['"]?([A-Za-z_][A-Za-z0-9_]*)['"]?/;
+function augmentRubyDefs(source, defs) {
+  const lines = source.split(/\r?\n/);
+  const state = {
+    visibility: "public",
+    stack: [],
+    endLevel: 0,
+    heredocId: null
+  };
+  let offset = 0;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (state.heredocId !== null) {
+      if (trimmed === state.heredocId)
+        state.heredocId = null;
+    } else {
+      const open2 = trimmed.match(rubyHeredocOpenRe);
+      if (open2)
+        state.heredocId = open2[1];
+      augmentRubyLine(trimmed, line, offset, source, defs, state);
+    }
+    offset = advanceLineOffset(source, offset, line.length);
+  }
+}
+function augmentRubyLine(trimmed, line, offset, source, defs, state) {
+  if (trimmed === "private" || trimmed === "protected") {
+    state.visibility = trimmed;
+  }
+  const targeted = trimmed.match(rubyTargetedVisibilityRe);
+  if (targeted) {
+    const visibility = targeted[1];
+    for (const name of targeted[2].split(",").map((part) => part.trim())) {
+      const sym = name.replace(/^:/, "");
+      for (let i = defs.length - 1;i >= 0; i--) {
+        const d = defs[i];
+        if (d.name === sym && d.startLine <= lineNumberAt(source, offset)) {
+          d.exported = false;
+          d.visibilityInfo = symbolVisibilityInfo(visibility, false, "unknown");
+          break;
+        }
+      }
+    }
+  }
+  const moduleMatch = trimmed.match(/^module\s+([A-Z][A-Za-z0-9_:]*)/);
+  const classMatch = trimmed.match(/^class\s+([A-Z][A-Za-z0-9_:]*)/);
+  if (moduleMatch || classMatch) {
+    state.stack.push({
+      visibility: state.visibility,
+      atEndLevel: state.endLevel
+    });
+    state.visibility = "public";
+    state.endLevel++;
+    const name = (moduleMatch ?? classMatch)[1];
+    addRegexDef(defs, source, name, moduleMatch ? "type" : "class", offset + line.indexOf((moduleMatch ?? classMatch)[0]), offset + line.length, "public", true, "module_public");
+  }
+  const constMatch = trimmed.match(/^([A-Z][A-Za-z0-9_]*)\s*=/);
+  if (constMatch) {
+    addRegexDef(defs, source, constMatch[1], "const", offset + line.indexOf(constMatch[1]), offset + line.length, "public", true, "module_public");
+  }
+  const methodMatch = trimmed.match(rubyMethodDefNameRe);
+  if (methodMatch) {
+    state.endLevel++;
+    const isSingleton = Boolean(methodMatch[1]);
+    const shortName = methodMatch[2];
+    const name = isSingleton ? `self.${shortName}` : shortName;
+    const visibility = isSingleton ? "public" : state.visibility;
+    const exported = visibility !== "private" && !shortName.startsWith("_");
+    addRegexDef(defs, source, name, "method", offset + line.indexOf("def"), offset + line.length, visibility, exported, exported ? "module_public" : "unknown");
+  }
+  rubyEndWordRe.lastIndex = 0;
+  const ends = trimmed.match(rubyEndWordRe)?.length ?? 0;
+  if (ends > 0) {
+    state.endLevel -= ends;
+    while (state.stack.length > 0 && state.endLevel <= state.stack[state.stack.length - 1].atEndLevel) {
+      state.visibility = state.stack.pop().visibility;
+    }
+  }
+}
+var phpNamespaceRe = /\bnamespace\s+([^;{]+)\s*[;{]/g;
+var phpTypeRe = /\b(trait|class|interface|enum)\s+([A-Za-z_][A-Za-z0-9_]*)/g;
+var phpFunctionRe = /\b(?:(public|protected|private|static|final|abstract)\s+){0,6}function\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(/g;
+function augmentPhpDefs(source, defs) {
+  const masked = maskCommentsForAugment(source);
+  phpNamespaceRe.lastIndex = 0;
+  for (let m = phpNamespaceRe.exec(masked);m !== null; m = phpNamespaceRe.exec(masked)) {
+    addRegexDef(defs, source, m[1].trim(), "type", m.index, m.index + m[0].length, "public", true, "namespace_public");
+  }
+  const typeRanges = [];
+  phpTypeRe.lastIndex = 0;
+  for (let m = phpTypeRe.exec(masked);m !== null; m = phpTypeRe.exec(masked)) {
+    const bodyStart = masked.indexOf("{", m.index);
+    const bodyEnd = bodyStart === -1 ? null : findMatchingBrace(masked, bodyStart);
+    if (bodyStart !== -1 && bodyEnd !== null) {
+      typeRanges.push({ start: bodyStart, end: bodyEnd });
+    }
+    addRegexDef(defs, source, m[2], m[1] === "class" ? "class" : m[1] === "enum" ? "enum" : "interface", m.index, declarationEnd(masked, m.index), "public", true, "module_public");
+  }
+  phpFunctionRe.lastIndex = 0;
+  for (let m = phpFunctionRe.exec(masked);m !== null; m = phpFunctionRe.exec(masked)) {
+    const modifiers = m[0].slice(0, m[0].indexOf("function"));
+    const visibility = modifiers.match(/\b(public|protected|private)\b/)?.[1] ?? "public";
+    const exported = visibility !== "private" && !m[2].startsWith("_");
+    const effectiveVisibility = m[2].startsWith("_") ? "private" : visibility;
+    const kind = typeRanges.some((range) => m.index >= range.start && m.index <= range.end) ? "method" : "function";
+    addRegexDef(defs, source, m[2], kind, m.index, declarationEnd(masked, m.index), effectiveVisibility, exported, exported ? "module_public" : "unknown");
+  }
+}
+function fallbackImportsForSource(grammarId, source) {
+  const entries = [];
+  if (grammarId !== "dart" && grammarId !== "ruby" && grammarId !== "php") {
+    return entries;
+  }
+  const masked = maskCommentsForAugment(source);
+  const lines = source.split(/\r?\n/);
+  const maskedLines = masked.split(/\r?\n/);
+  let offset = 0;
+  let heredocId = null;
+  let braceDepth = 0;
+  let pending = null;
+  const flushPending = (endLine) => {
+    if (!pending)
+      return;
+    let parsed = null;
+    if (grammarId === "dart")
+      parsed = parseDartImport(pending.text);
+    else if (grammarId === "php")
+      parsed = parsePhpUse(pending.text);
+    for (const entry of parsed ? Array.isArray(parsed) ? parsed : [parsed] : []) {
+      entries.push({
+        index: pending.startOffset,
+        entry: { ...entry, startLine: pending.startLine, endLine }
+      });
+    }
+    pending = null;
+  };
+  for (let li = 0;li < lines.length; li++) {
+    const line = lines[li];
+    const trimmed = line.trim();
+    const maskedTrimmed = maskedLines[li]?.trim() ?? "";
+    const startLine = lineNumberAt(source, offset);
+    if (grammarId === "ruby") {
+      if (heredocId !== null) {
+        if (maskedTrimmed === heredocId)
+          heredocId = null;
+      } else {
+        const open2 = maskedTrimmed.match(rubyHeredocOpenRe);
+        if (open2)
+          heredocId = open2[1];
+        else {
+          const parsed = parseRubyRequire(trimmed);
+          if (parsed) {
+            entries.push({
+              index: offset,
+              entry: { ...parsed, startLine, endLine: startLine }
+            });
+          }
+        }
+      }
+      offset = advanceLineOffset(source, offset, line.length);
+      continue;
+    }
+    if (grammarId === "php") {
+      for (const ch of maskedLines[li] ?? "") {
+        if (ch === "{")
+          braceDepth++;
+        else if (ch === "}")
+          braceDepth = Math.max(0, braceDepth - 1);
+      }
+    }
+    if (pending) {
+      pending.text += ` ${trimmed}`;
+      pending.lines++;
+      if (trimmed.includes(";") || pending.lines > 10) {
+        flushPending(startLine);
+      } else if (trimmed === "") {
+        pending = null;
+      }
+      offset = advanceLineOffset(source, offset, line.length);
+      continue;
+    }
+    const startsStatement = grammarId === "dart" ? /^(import|export)\s/.test(maskedTrimmed) : /^use\s/.test(maskedTrimmed);
+    const inClassBody = grammarId === "php" && braceDepth > 0;
+    if (startsStatement && !inClassBody) {
+      if (trimmed.includes(";")) {
+        let parsed = null;
+        if (grammarId === "dart")
+          parsed = parseDartImport(trimmed);
+        else if (grammarId === "php")
+          parsed = parsePhpUse(trimmed);
+        for (const entry of parsed ? Array.isArray(parsed) ? parsed : [parsed] : []) {
+          entries.push({
+            index: offset,
+            entry: { ...entry, startLine, endLine: startLine }
+          });
+        }
+      } else {
+        pending = { startOffset: offset, startLine, text: trimmed, lines: 1 };
+      }
+    }
+    offset = advanceLineOffset(source, offset, line.length);
+  }
+  flushPending(lineNumberAt(source, offset));
+  return entries;
 }
 function safeMatches(lang, pattern, root) {
   if (!_QueryCtor)
@@ -50944,28 +51554,52 @@ function parseSwiftImport(text) {
 }
 function parseDartImport(text) {
   const t = text.trim();
-  const m = t.match(/^import\s+['"]([^'"]+)['"]\s+as\s+(\w+)/);
-  if (m) {
+  const exportMatch = t.match(/^export\s+['"]([^'"]+)['"](?:\s+show\s+([^;]+))?/);
+  if (exportMatch) {
+    const shown = exportMatch[2]?.split(",").map((part) => part.trim()).filter(Boolean);
+    const bindings = shown && shown.length > 0 ? shown.map((name) => ({ imported: name, local: name })) : [{ imported: "*", local: "*" }];
     return {
-      specifier: m[1],
-      importType: "named",
-      bindings: [{ imported: m[1], local: m[2] }]
+      specifier: exportMatch[1],
+      importType: shown && shown.length > 0 ? "named" : "namespace",
+      bindings,
+      reExport: true,
+      exportedBindings: bindings.map((binding) => ({
+        imported: binding.imported,
+        exported: binding.local
+      }))
     };
   }
-  const simple = t.match(/^import\s+['"]([^'"]+)['"]/);
-  if (simple) {
-    return { specifier: simple[1], importType: "namespace", bindings: [] };
+  const importMatch = t.match(/^import\s+['"]([^'"]+)['"]([^;]*)/);
+  if (importMatch) {
+    const clause = importMatch[2];
+    const alias = clause?.match(/\bas\s+\w+/);
+    const shown = clause?.match(/\bshow\s+([^;]+)/)?.[1].split(",").map((part) => part.trim()).filter(Boolean);
+    const primary = {
+      specifier: importMatch[1],
+      importType: !alias && shown && shown.length > 0 ? "named" : "namespace",
+      bindings: !alias && shown && shown.length > 0 ? shown.map((name) => ({ imported: name, local: name })) : []
+    };
+    const conditional = clause?.match(/\bif\s*\([^)]*\)\s*['"]([^'"]+)['"]/);
+    if (conditional) {
+      return [
+        primary,
+        { specifier: conditional[1], importType: "namespace", bindings: [] }
+      ];
+    }
+    return primary;
   }
   return null;
 }
 function parseRubyRequire(text) {
   const t = text.trim();
+  const isRequireRelative = /^require_relative\b/.test(t);
   const stripped = t.replace(/^(?:require(?:_relative)?)\s+['"]?/, "").replace(/['"]$/, "");
   if (!stripped || stripped === t)
     return null;
-  const isRelative = stripped.startsWith("./") || stripped.startsWith("../");
+  const specifier = isRequireRelative && !stripped.startsWith(".") ? `./${stripped}` : stripped;
+  const isRelative = specifier.startsWith("./") || specifier.startsWith("../");
   return {
-    specifier: stripped,
+    specifier,
     importType: isRelative ? "default" : "namespace",
     bindings: []
   };
@@ -50977,7 +51611,7 @@ function parsePhpUse(text) {
     return {
       specifier: m[1],
       importType: "named",
-      bindings: [{ imported: m[1], local: m[2] }]
+      bindings: [{ imported: m[1].split("\\").pop() ?? m[1], local: m[2] }]
     };
   }
   const simple = t.match(/^use\s+(?:(?:function|const)\s+)?([^;\s]+)\s*;?\s*$/i);
@@ -51053,7 +51687,10 @@ var IMPORT_ANCESTOR_TYPES = new Set([
   "use_declaration",
   "using_directive",
   "namespace_use_declaration",
-  "library_import"
+  "namespace_use_clause",
+  "library_import",
+  "library_export",
+  "export_directive"
 ]);
 function isInsideImportStatement(node) {
   return hasAncestorOfType(node, IMPORT_ANCESTOR_TYPES);
@@ -51100,7 +51737,13 @@ var SYMBOL_EXTENSIONS = new Set([
   ".py",
   ".pyw",
   ".rs",
-  ".go"
+  ".go",
+  ".dart",
+  ".rb",
+  ".rake",
+  ".gemspec",
+  ".php",
+  ".phtml"
 ]);
 var SKIP_DIRECTORIES = new Set([
   "node_modules",
@@ -51527,6 +52170,346 @@ function extractGoSymbols(filePath, cwd) {
     return a.name.localeCompare(b.name);
   });
 }
+var memoSource = null;
+var memoStarts = [0];
+function lineStartsOf(content) {
+  if (memoSource !== content) {
+    const starts = [0];
+    for (let i = 0;i < content.length; i++) {
+      if (content[i] === `
+`)
+        starts.push(i + 1);
+    }
+    memoSource = content;
+    memoStarts = starts;
+  }
+  return memoStarts;
+}
+function lineNumberAt2(content, index) {
+  const starts = lineStartsOf(content);
+  let lo = 0;
+  let hi = starts.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    if (starts[mid] <= index)
+      lo = mid;
+    else
+      hi = mid - 1;
+  }
+  return lo + 1;
+}
+function advanceLineOffset2(source, offset, lineLength) {
+  const after = offset + lineLength;
+  if (source[after] === "\r" && source[after + 1] === `
+`)
+    return after + 2;
+  if (source[after] === `
+` || source[after] === "\r")
+    return after + 1;
+  return after;
+}
+function lineTextAt(content, index) {
+  const lineStart = content.lastIndexOf(`
+`, Math.max(0, index - 1)) + 1;
+  const lineEnd = content.indexOf(`
+`, lineStart);
+  return content.substring(lineStart, lineEnd === -1 ? content.length : lineEnd).trim().substring(0, 120);
+}
+function findMatchingBrace2(content, openIndex) {
+  if (content[openIndex] !== "{")
+    return null;
+  let depth = 0;
+  for (let i = openIndex;i < content.length; i++) {
+    const ch = content[i];
+    if (ch === "{")
+      depth++;
+    else if (ch === "}") {
+      depth--;
+      if (depth === 0)
+        return i;
+    }
+  }
+  return null;
+}
+function stripLineCommentsForScan(content) {
+  let out = "";
+  let inBlock = false;
+  let quote = null;
+  for (let i = 0;i < content.length; i++) {
+    const ch = content[i];
+    const two = content.substring(i, i + 2);
+    if (quote !== null) {
+      if (ch === "\\") {
+        out += "  ";
+        i++;
+        continue;
+      }
+      if (ch === quote) {
+        quote = null;
+        out += ch;
+      } else {
+        out += ch === `
+` ? `
+` : " ";
+      }
+      continue;
+    }
+    if (!inBlock && two === "/*") {
+      inBlock = true;
+      out += "  ";
+      i++;
+      continue;
+    }
+    if (inBlock) {
+      if (two === "*/") {
+        inBlock = false;
+        out += "  ";
+        i++;
+      } else {
+        out += ch === `
+` ? `
+` : " ";
+      }
+      continue;
+    }
+    if (two === "//" || ch === "#") {
+      out += two === "//" ? "  " : " ";
+      if (two === "//")
+        i++;
+      while (i + 1 < content.length && content[i + 1] !== `
+`) {
+        out += " ";
+        i++;
+      }
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      if (ch === content[i + 1] && ch === content[i + 2]) {
+        out += ch + ch + ch;
+        i += 2;
+        while (i + 1 < content.length) {
+          if (content[i + 1] === ch && content[i + 2] === ch && content[i + 3] === ch) {
+            out += ch + ch + ch;
+            i += 3;
+            break;
+          }
+          out += content[i + 1] === `
+` ? `
+` : " ";
+          i++;
+        }
+        continue;
+      }
+      quote = ch;
+      out += ch;
+      continue;
+    }
+    out += ch;
+  }
+  return out;
+}
+function addUniqueSymbol(symbols, seen, candidate) {
+  const key = `${candidate.name}:${candidate.kind}`;
+  if (seen.has(key))
+    return;
+  seen.add(key);
+  symbols.push(candidate);
+}
+function sortSymbols(symbols) {
+  return symbols.sort((a, b) => {
+    if (a.line !== b.line)
+      return a.line - b.line;
+    return a.name.localeCompare(b.name);
+  });
+}
+function extractDartSymbols(filePath, cwd) {
+  const raw = readValidatedSourceFile(filePath, cwd);
+  if (raw === null)
+    return [];
+  const content = stripLineCommentsForScan(raw);
+  const symbols = [];
+  const seen = new Set;
+  const typeBodies = [];
+  for (const match of content.matchAll(/\b(extension\s+type|class|mixin|enum|extension|typedef)\s+(?!on\b)([A-Za-z_][A-Za-z0-9_]*)/g)) {
+    const kindWord = match[1].trim().split(/\s+/).pop() ?? match[1];
+    const kind = kindWord === "enum" ? "enum" : kindWord === "class" ? "class" : "type";
+    const bodyStart = content.indexOf("{", match.index);
+    const bodyEnd = bodyStart === -1 ? null : findMatchingBrace2(content, bodyStart);
+    if (bodyStart !== -1 && bodyEnd !== null) {
+      typeBodies.push({ start: bodyStart, end: bodyEnd, name: match[2] });
+    }
+    addUniqueSymbol(symbols, seen, {
+      name: match[2],
+      kind,
+      exported: !match[2].startsWith("_"),
+      signature: lineTextAt(raw, match.index),
+      line: lineNumberAt2(raw, match.index)
+    });
+  }
+  const dartFunctionRe = /\b(?:void|[A-Za-z_][A-Za-z0-9_<>,?]*)\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(/g;
+  const KEYWORD_NAME_SKIP = new Set([
+    "if",
+    "for",
+    "while",
+    "switch",
+    "return",
+    "else",
+    "throw",
+    "new",
+    "await",
+    "yield",
+    "case",
+    "catch",
+    "Function"
+  ]);
+  const KEYWORD_TYPE_SKIP = new Set([
+    "return",
+    "else",
+    "throw",
+    "new",
+    "await",
+    "yield",
+    "case",
+    "catch",
+    "final",
+    "const"
+  ]);
+  for (const match of content.matchAll(dartFunctionRe)) {
+    if (KEYWORD_NAME_SKIP.has(match[1]))
+      continue;
+    if (KEYWORD_TYPE_SKIP.has(match[0].split(/\s+/)[0]))
+      continue;
+    const enclosing = typeBodies.find((body) => match.index >= body.start && match.index <= body.end);
+    addUniqueSymbol(symbols, seen, {
+      name: enclosing ? `${enclosing.name}.${match[1]}` : match[1],
+      kind: enclosing ? "method" : "function",
+      exported: !match[1].startsWith("_"),
+      signature: lineTextAt(raw, match.index),
+      line: lineNumberAt2(raw, match.index)
+    });
+  }
+  return sortSymbols(symbols);
+}
+function extractRubySymbols(filePath, cwd) {
+  const raw = readValidatedSourceFile(filePath, cwd);
+  if (raw === null)
+    return [];
+  const symbols = [];
+  const seen = new Set;
+  const byName = new Map;
+  let offset = 0;
+  let currentVisibility = "public";
+  const visibilityStack = [];
+  let endLevel = 0;
+  let heredocId = null;
+  for (const line of raw.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (heredocId !== null) {
+      if (trimmed === heredocId)
+        heredocId = null;
+    } else {
+      const open2 = trimmed.match(/(?:^|[=(,[]\s*|(?:puts|print|raise|return|p)\s+)<<[~-]?['"]?([A-Za-z_][A-Za-z0-9_]*)['"]?/);
+      if (open2)
+        heredocId = open2[1];
+      if (trimmed === "private" || trimmed === "protected") {
+        currentVisibility = trimmed;
+      }
+      const targeted = trimmed.match(/^(private|protected)\s+((?::[A-Za-z_][A-Za-z0-9_?!]*\s*,\s*)*:[A-Za-z_][A-Za-z0-9_?!]*)$/);
+      if (targeted) {
+        for (const part of targeted[2].split(",")) {
+          const sym = byName.get(part.trim().replace(/^:/, ""));
+          if (sym) {
+            sym.exported = false;
+          }
+        }
+      }
+      const moduleMatch = trimmed.match(/^module\s+([A-Z][A-Za-z0-9_:]*)/);
+      const classMatch = trimmed.match(/^class\s+([A-Z][A-Za-z0-9_:]*)/);
+      if (moduleMatch || classMatch) {
+        visibilityStack.push({
+          visibility: currentVisibility,
+          atEndLevel: endLevel
+        });
+        currentVisibility = "public";
+        endLevel++;
+      }
+      const constMatch = trimmed.match(/^([A-Z][A-Za-z0-9_]*)\s*=/);
+      const methodMatch = trimmed.match(/^def\s+(?:(self)\.)?([A-Za-z_][A-Za-z0-9_?!]*)/);
+      if (methodMatch)
+        endLevel++;
+      const lineIndex = offset + Math.max(0, line.indexOf(trimmed));
+      if (moduleMatch || classMatch || constMatch || methodMatch) {
+        const singleton = Boolean(methodMatch?.[1]);
+        const shortName = methodMatch?.[2];
+        const name = moduleMatch?.[1] ?? classMatch?.[1] ?? constMatch?.[1] ?? (singleton && shortName ? `self.${shortName}` : shortName);
+        const visibility = singleton ? "public" : currentVisibility;
+        const candidate = {
+          name,
+          kind: moduleMatch ? "type" : classMatch ? "class" : constMatch ? "const" : "method",
+          exported: methodMatch ? visibility !== "private" && !(shortName ?? "").startsWith("_") : true,
+          signature: trimmed.substring(0, 100),
+          line: lineNumberAt2(raw, lineIndex)
+        };
+        addUniqueSymbol(symbols, seen, candidate);
+        byName.set(name, candidate);
+      }
+      const ends = trimmed.match(/\bend\b/g)?.length ?? 0;
+      if (ends > 0) {
+        endLevel -= ends;
+        while (visibilityStack.length > 0 && endLevel <= visibilityStack[visibilityStack.length - 1].atEndLevel) {
+          currentVisibility = visibilityStack.pop().visibility;
+        }
+      }
+    }
+    offset = advanceLineOffset2(raw, offset, line.length);
+  }
+  return sortSymbols(symbols);
+}
+function extractPhpSymbols(filePath, cwd) {
+  const raw = readValidatedSourceFile(filePath, cwd);
+  if (raw === null)
+    return [];
+  const content = stripLineCommentsForScan(raw);
+  const symbols = [];
+  const seen = new Set;
+  const typeRanges = [];
+  for (const match of content.matchAll(/\bnamespace\s+([A-Za-z_\\][A-Za-z0-9_\\]*)\s*[;{]/g)) {
+    addUniqueSymbol(symbols, seen, {
+      name: match[1],
+      kind: "type",
+      exported: true,
+      signature: lineTextAt(raw, match.index),
+      line: lineNumberAt2(raw, match.index)
+    });
+  }
+  for (const match of content.matchAll(/\b(?:final\s+|abstract\s+|readonly\s+)?(class|interface|trait|enum)\s+([A-Za-z_][A-Za-z0-9_]*)/g)) {
+    const bodyStart = content.indexOf("{", match.index);
+    const bodyEnd = bodyStart === -1 ? null : findMatchingBrace2(content, bodyStart);
+    if (bodyStart !== -1 && bodyEnd !== null) {
+      typeRanges.push({ start: bodyStart, end: bodyEnd });
+    }
+    addUniqueSymbol(symbols, seen, {
+      name: match[2],
+      kind: match[1] === "class" ? "class" : match[1] === "enum" ? "enum" : "interface",
+      exported: !match[2].startsWith("_"),
+      signature: lineTextAt(raw, match.index),
+      line: lineNumberAt2(raw, match.index)
+    });
+  }
+  for (const match of content.matchAll(/\b(?:(public|protected|private|static|final|abstract)\s+){0,6}function\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(/g)) {
+    const insideType = typeRanges.some((range) => match.index >= range.start && match.index <= range.end);
+    const modifiers = match[0].slice(0, match[0].indexOf("function"));
+    const visibility = modifiers.match(/\b(public|protected|private)\b/)?.[1];
+    addUniqueSymbol(symbols, seen, {
+      name: match[2],
+      kind: insideType ? "method" : "function",
+      exported: visibility !== "private" && !match[2].startsWith("_"),
+      signature: lineTextAt(raw, match.index),
+      line: lineNumberAt2(raw, match.index)
+    });
+  }
+  return sortSymbols(symbols);
+}
 function findSourceFiles(cwd, maxFiles) {
   const files = [];
   walkDir(cwd, cwd, files, maxFiles);
@@ -51590,6 +52573,18 @@ function searchWorkspaceSymbols(cwd, name, exportedOnly = true) {
       case ".go":
         syms = extractGoSymbols(relFile, cwd);
         break;
+      case ".dart":
+        syms = _internals65.extractDartSymbols(relFile, cwd);
+        break;
+      case ".rb":
+      case ".rake":
+      case ".gemspec":
+        syms = _internals65.extractRubySymbols(relFile, cwd);
+        break;
+      case ".php":
+      case ".phtml":
+        syms = _internals65.extractPhpSymbols(relFile, cwd);
+        break;
       default:
         continue;
     }
@@ -51628,7 +52623,7 @@ function searchWorkspaceSymbols(cwd, name, exportedOnly = true) {
   };
 }
 var symbols = createSwarmTool({
-  description: "Extract all exported symbols from a source file: functions with signatures, " + "classes with public members, interfaces, types, enums, constants. " + "Supports TypeScript/JavaScript, Python, Rust, and Go. Use for architect planning, " + "designer scaffolding, and understanding module public API surface.",
+  description: "Extract all exported symbols from a source file: functions with signatures, " + "classes with public members, interfaces, types, enums, constants. " + "Supports TypeScript/JavaScript, Python, Rust, Go, Dart, Ruby, and PHP. " + "Use for architect planning, designer scaffolding, and understanding module " + "public API surface.",
   args: {
     file: exports_external.string().optional().describe('File path to extract symbols from (e.g., "src/auth/login.ts"). Required when not using workspace mode.'),
     exported_only: exports_external.boolean().default(true).describe("If true, only return exported/public symbols. If false, include all top-level symbols."),
@@ -51712,10 +52707,22 @@ var symbols = createSwarmTool({
       case ".go":
         syms = extractGoSymbols(file, cwd);
         break;
+      case ".dart":
+        syms = _internals65.extractDartSymbols(file, cwd);
+        break;
+      case ".rb":
+      case ".rake":
+      case ".gemspec":
+        syms = _internals65.extractRubySymbols(file, cwd);
+        break;
+      case ".php":
+      case ".phtml":
+        syms = _internals65.extractPhpSymbols(file, cwd);
+        break;
       default:
         return JSON.stringify({
           file,
-          error: `Unsupported file extension: ${ext}. Supported: .ts, .tsx, .js, .jsx, .mjs, .cjs, .py, .pyw, .rs, .go`,
+          error: `Unsupported file extension: ${ext}. Supported: .ts, .tsx, .js, .jsx, .mjs, .cjs, .py, .pyw, .rs, .go, .dart, .rb, .rake, .gemspec, .php, .phtml`,
           symbols: []
         }, null, 2);
     }
@@ -51732,6 +52739,11 @@ var symbols = createSwarmTool({
     }, null, 2);
   }
 });
+var _internals65 = {
+  extractDartSymbols,
+  extractRubySymbols,
+  extractPhpSymbols
+};
 
 // src/tools/repo-graph/ontology.ts
 import * as path73 from "path";
@@ -52333,14 +53345,20 @@ var ONTOLOGY_FINDING_SEVERITY_SET = new Set(ONTOLOGY_FINDING_SEVERITY_VALUES);
 var IMPORT_TYPE_SET = new Set(IMPORT_TYPE_VALUES);
 
 // src/tools/repo-graph/builder.ts
-var _internals65 = {
+var _internals66 = {
   now: Date.now,
   safeRealpathSync,
   extractTSSymbols,
   extractPythonSymbols,
   extractRustSymbols,
   extractGoSymbols,
+  extractDartSymbols,
+  extractRubySymbols,
+  extractPhpSymbols,
   parseFileImports,
+  parseDartFileImports,
+  parseRubyFileImports,
+  parsePhpFileImports,
   extractFileOntology,
   stripComments: stripComments2,
   computeUsedSymbols,
@@ -52498,6 +53516,15 @@ function parseFileImports(rawContent, sourceFile, workspaceRoot) {
   if (ext === ".cs" || ext === ".csx") {
     return parseCSharpFileImports(rawContent);
   }
+  if (ext === ".dart") {
+    return parseDartFileImports(rawContent);
+  }
+  if (ext === ".rb" || ext === ".rake" || ext === ".gemspec") {
+    return parseRubyFileImports(rawContent);
+  }
+  if (ext === ".php" || ext === ".phtml" || sourceFile?.endsWith(".blade.php")) {
+    return parsePhpFileImports(rawContent);
+  }
   const imports = [];
   const content = stripComments2(rawContent);
   const importRegex = /import\s+(?:\{[\s\S]*?\}|(?:\*\s+as\s+\w+)|\w+)\s+from\s+['"`]([^'"`\0\t\r\n]+)['"`]|import\s+['"`]([^'"`\0\t\r\n]+)['"`]|require\s*\(\s*['"`]([^'"`\0\t\r\n]+)['"`]\s*\)|export\s*\{[^}]*\}\s*from\s+['"`]([^'"`\0\t\r\n]+)['"`]|export\s+\*(?:\s+as\s+\w+)?\s+from\s+['"`]([^'"`\0\t\r\n]+)['"`]|import\s*\(\s*['"`]([^'"`\0\t\r\n]+)['"`]\s*\)/g;
@@ -52611,6 +53638,41 @@ function parseCSharpFileImports(rawContent) {
   }
   return imports;
 }
+function parseDartFileImports(rawContent) {
+  const imports = [];
+  for (const match of rawContent.matchAll(/^[ \t]*(import|export)[ \t]+['"]([^'"]+)['"]([^;]*)/gm)) {
+    const clause = match[3];
+    const shown = clause?.match(/\bshow\s+([^;]+)/)?.[1].split(",").map((part) => part.trim()).filter(Boolean);
+    const alias = clause?.match(/\bas\s+\w+/);
+    const bindings = !alias && shown && shown.length > 0 ? shown.map((name) => ({ imported: name, local: name })) : [];
+    const parsed = makeParsedImport(match[2], bindings.length > 0 ? "named" : "namespace", bindings, match[1] === "export");
+    if (parsed)
+      imports.push(parsed);
+  }
+  return imports;
+}
+function parseRubyFileImports(rawContent) {
+  const imports = [];
+  for (const match of rawContent.matchAll(/^[ \t]*(require_relative|require)[ \t]+['"]([^'"]+)['"]/gm)) {
+    const relative10 = match[1] === "require_relative";
+    const specifier = relative10 && !match[2].startsWith(".") ? `./${match[2]}` : match[2];
+    const parsed = makeParsedImport(specifier, relative10 ? "default" : "namespace", []);
+    if (parsed)
+      imports.push(parsed);
+  }
+  return imports;
+}
+function parsePhpFileImports(rawContent) {
+  const imports = [];
+  for (const match of rawContent.matchAll(/^[ \t]*use[ \t]+(?:(?:function|const)[ \t]+)?([^;\s]+)(?:[ \t]+as[ \t]+(\w+))?[ \t]*;?[ \t]*\r?$/gim)) {
+    const imported = match[1].split("\\").pop() ?? match[1];
+    const bindings = match[2] ? [{ imported, local: match[2] }] : [];
+    const parsed = makeParsedImport(match[1], bindings.length > 0 ? "named" : "namespace", bindings);
+    if (parsed)
+      imports.push(parsed);
+  }
+  return imports;
+}
 function parsePythonFileImports(rawContent, sourceFile) {
   const imports = [];
   const isPackageInit = sourceFile ? ["__init__.py", "__init__.pyw"].includes(path74.basename(sourceFile)) : false;
@@ -52882,7 +53944,7 @@ function recordManifestDir(manifestDirs, absoluteRoot, dir, entryName) {
 function isWalkBudgetExceeded(ctx) {
   if (ctx.abortReason !== undefined)
     return true;
-  if (_internals65.now() - ctx.startedAt > ctx.walkBudgetMs) {
+  if (_internals66.now() - ctx.startedAt > ctx.walkBudgetMs) {
     ctx.abortReason = "budget";
     return true;
   }
@@ -52914,7 +53976,7 @@ async function walkRepoGraphInputs(dir, options) {
   const ctx = {
     stats,
     seenRealPaths: new Set,
-    startedAt: _internals65.now(),
+    startedAt: _internals66.now(),
     walkBudgetMs: options?.walkBudgetMs ?? DEFAULT_WALK_BUDGET_MS,
     maxFiles: options?.maxFiles ?? DEFAULT_WALK_FILE_CAP,
     followSymlinks: options?.followSymlinks ?? false,
@@ -53015,7 +54077,7 @@ async function walkRepoGraphInputs(dir, options) {
     unreadableDirectories,
     unreadableFiles,
     probedFiles: metadata.length,
-    elapsedMs: Math.max(0, _internals65.now() - ctx.startedAt)
+    elapsedMs: Math.max(0, _internals66.now() - ctx.startedAt)
   };
 }
 var RANGE_WIDENED_GRAMMARS = new Set([
@@ -53023,7 +54085,10 @@ var RANGE_WIDENED_GRAMMARS = new Set([
   "kotlin",
   "csharp",
   "cpp",
-  "swift"
+  "swift",
+  "dart",
+  "ruby",
+  "php"
 ]);
 
 // src/tools/repo-graph/query.ts
@@ -53057,7 +54122,7 @@ var MAX_RELATIVE_PATH_LENGTH = 4096;
 var WINDOWS_RENAME_MAX_RETRIES2 = 5;
 var WINDOWS_RENAME_RETRY_DELAY_MS = 100;
 var probeCache = new Map;
-var _internals66 = {
+var _internals67 = {
   now: Date.now,
   walkRepoGraphInputs,
   open: fsPromises3.open,
@@ -53096,11 +54161,11 @@ async function writeFingerprintAtomic(root, data) {
   const temp = path75.join(path75.dirname(target), `.repo-graph.fingerprint.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2, 10)}.tmp`);
   validateSymlinkBoundary(temp, root);
   try {
-    await _internals66.bunWrite(temp, data);
+    await _internals67.bunWrite(temp, data);
     let lastError;
     for (let attempt = 0;attempt < WINDOWS_RENAME_MAX_RETRIES2; attempt++) {
       try {
-        await _internals66.fsRename(temp, target);
+        await _internals67.fsRename(temp, target);
         lastError = undefined;
         break;
       } catch (error2) {
@@ -53109,20 +54174,20 @@ async function writeFingerprintAtomic(root, data) {
         if (code !== "EEXIST" && code !== "EPERM" && code !== "EBUSY" || attempt === WINDOWS_RENAME_MAX_RETRIES2 - 1) {
           break;
         }
-        await new Promise((resolve26) => setTimeout(resolve26, _internals66.retryDelayMs));
+        await new Promise((resolve26) => setTimeout(resolve26, _internals67.retryDelayMs));
       }
     }
     if (lastError !== undefined)
       throw lastError;
   } finally {
     try {
-      await _internals66.fsUnlink(temp);
+      await _internals67.fsUnlink(temp);
     } catch {}
   }
 }
 async function refuseFingerprint(root) {
   try {
-    await _internals66.fsUnlink(fingerprintPath(root));
+    await _internals67.fsUnlink(fingerprintPath(root));
   } catch {}
   invalidateFreshnessCache(root);
   return false;
@@ -53189,7 +54254,7 @@ function diagnosticPaths(root, diagnostics) {
 async function writeFingerprint(root, graph, options) {
   invalidateFreshnessCache(root);
   try {
-    const walk = await _internals66.walkRepoGraphInputs(root, {
+    const walk = await _internals67.walkRepoGraphInputs(root, {
       walkBudgetMs: options?.walkBudgetMs,
       maxFiles: options?.maxFiles,
       followSymlinks: options?.followSymlinks,
@@ -53270,7 +54335,7 @@ async function writeFingerprint(root, graph, options) {
 
 // src/tools/repo-graph/storage.ts
 var WINDOWS_RENAME_RETRY_DELAY_MS2 = 100;
-var _internals67 = {
+var _internals68 = {
   safeRealpathSync,
   fsRename: fsPromises4.rename.bind(fsPromises4),
   retryDelayMs: WINDOWS_RENAME_RETRY_DELAY_MS2,
@@ -54535,15 +55600,15 @@ async function handleMemoryUnlinkCommand(directory, args) {
 }
 
 // src/services/plan-service.ts
-var _internals68 = {
+var _internals69 = {
   loadPlanJsonOnly,
   derivePlanMarkdown,
   readSwarmFileAsync
 };
 async function getPlanData(directory, phaseArg) {
-  const plan = await _internals68.loadPlanJsonOnly(directory);
+  const plan = await _internals69.loadPlanJsonOnly(directory);
   if (plan) {
-    const fullMarkdown = _internals68.derivePlanMarkdown(plan);
+    const fullMarkdown = _internals69.derivePlanMarkdown(plan);
     if (phaseArg === undefined || phaseArg === null || phaseArg === "") {
       return {
         hasPlan: true,
@@ -54586,7 +55651,7 @@ async function getPlanData(directory, phaseArg) {
       isLegacy: false
     };
   }
-  const planContent = await _internals68.readSwarmFileAsync(directory, "plan.md");
+  const planContent = await _internals69.readSwarmFileAsync(directory, "plan.md");
   if (!planContent) {
     return {
       hasPlan: false,
@@ -54683,7 +55748,7 @@ async function handlePlanCommand(directory, args) {
   return formatPlanMarkdown(planData);
 }
 // src/commands/post-mortem.ts
-var _internals69 = {
+var _internals70 = {
   createCuratorLLMDelegate,
   runCuratorPostMortem
 };
@@ -54731,10 +55796,10 @@ async function handlePostMortemCommand(directory, args, options) {
     };
     if (options?.sessionID) {
       try {
-        pmOptions.llmDelegate = _internals69.createCuratorLLMDelegate(directory, "postmortem", options.sessionID);
+        pmOptions.llmDelegate = _internals70.createCuratorLLMDelegate(directory, "postmortem", options.sessionID);
       } catch {}
     }
-    const result = await _internals69.runCuratorPostMortem(directory, pmOptions);
+    const result = await _internals70.runCuratorPostMortem(directory, pmOptions);
     const lines = [];
     if (result.success) {
       lines.push("## Post-Mortem Report Generated");
@@ -55023,7 +56088,7 @@ function resolveGhBinaryCandidates(options = {}) {
 function resolveGhBinary() {
   if (ghBinaryTestPin !== undefined)
     return ghBinaryTestPin;
-  return _internals70.resolveExecutableFromPath(resolveGhBinaryCandidates());
+  return _internals71.resolveExecutableFromPath(resolveGhBinaryCandidates());
 }
 function normalizeRepo(value) {
   if (value === undefined || value === null || value === "")
@@ -55144,7 +56209,7 @@ var gh_evidence = createSwarmTool({
     if (!Array.isArray(fields)) {
       return JSON.stringify(fields, null, 2);
     }
-    const executable = _internals70.resolveGhBinary();
+    const executable = _internals71.resolveGhBinary();
     if (!executable) {
       return JSON.stringify({
         error: true,
@@ -55163,7 +56228,7 @@ var gh_evidence = createSwarmTool({
     if (isLogFailedMode) {
       ghArgs.push("--log-failed");
     }
-    const run = await _internals70.runExternalTool({
+    const run = await _internals71.runExternalTool({
       executable,
       args: ghArgs,
       cwd: directory,
@@ -55247,7 +56312,7 @@ var gh_evidence = createSwarmTool({
     }, null, 2);
   }
 });
-var _internals70 = {
+var _internals71 = {
   resolveGhBinaryCandidates,
   resolveExecutableFromPath,
   resolveGhBinary,
@@ -55354,7 +56419,7 @@ function formatMergeGroupStatus(status, conclusion, htmlUrl) {
   }
   return parts.join(" ");
 }
-var _internals71 = {
+var _internals72 = {
   formatRelativeTime,
   formatMergeGroupStatus,
   listActive,
@@ -55362,7 +56427,7 @@ var _internals71 = {
   parseMergeGroupRuns
 };
 async function handlePrMonitorStatusCommand(directory, _args, sessionID, source) {
-  const allActive = await _internals71.listActive(directory);
+  const allActive = await _internals72.listActive(directory);
   const allSessions = source === "cli";
   const subs = allSessions ? allActive : allActive.filter((record) => record.sessionID === sessionID);
   if (subs.length === 0) {
@@ -55378,7 +56443,7 @@ async function handlePrMonitorStatusCommand(directory, _args, sessionID, source)
     const index = i + 1;
     lines.push(`  ${index}. ${sub.repoFullName}#${sub.prNumber}`);
     lines.push(`     URL: ${sub.prUrl}`);
-    const mergeGroupRuns = await _internals71.listMergeGroupRuns(directory, sub.repoFullName, sub.prNumber);
+    const mergeGroupRuns = await _internals72.listMergeGroupRuns(directory, sub.repoFullName, sub.prNumber);
     if (mergeGroupRuns.runs.length > 0) {
       lines.push("     Merge-group runs:");
       for (const run of mergeGroupRuns.runs) {
@@ -55519,7 +56584,7 @@ async function handlePrSubscribeCommand(directory, args, sessionID) {
   const repoFullName = `${prInfo.owner}/${prInfo.repo}`;
   const prUrl = `https://github.com/${prInfo.owner}/${prInfo.repo}/pull/${prInfo.number}`;
   try {
-    const config = _internals72.loadPluginConfig(directory);
+    const config = _internals73.loadPluginConfig(directory);
     const prMonitorConfig = config.pr_monitor;
     if (!prMonitorConfig?.enabled) {
       return [
@@ -55529,7 +56594,7 @@ async function handlePrSubscribeCommand(directory, args, sessionID) {
       ].join(`
 `);
     }
-    await _internals72.subscribe(directory, {
+    await _internals73.subscribe(directory, {
       sessionID,
       prNumber: prInfo.number,
       repoFullName,
@@ -55557,7 +56622,7 @@ async function handlePrSubscribeCommand(directory, args, sessionID) {
 `);
   }
 }
-var _internals72 = {
+var _internals73 = {
   loadPluginConfig,
   subscribe
 };
@@ -55580,9 +56645,9 @@ async function handlePrUnsubscribeCommand(directory, args, sessionID) {
 `);
   }
   const refToken = rest[0];
-  const prInfo = _internals73.parsePrRef(refToken, directory);
+  const prInfo = _internals74.parsePrRef(refToken, directory);
   if (!prInfo) {
-    if (_internals73.looksLikePrRef(refToken)) {
+    if (_internals74.looksLikePrRef(refToken)) {
       return [
         `Error: Could not resolve PR reference from "${refToken}".`,
         "",
@@ -55603,8 +56668,8 @@ async function handlePrUnsubscribeCommand(directory, args, sessionID) {
   const repoFullName = `${prInfo.owner}/${prInfo.repo}`;
   const prUrl = `https://github.com/${prInfo.owner}/${prInfo.repo}/pull/${prInfo.number}`;
   try {
-    const correlationId = _internals73.buildCorrelationId(sessionID, repoFullName, prInfo.number);
-    const result = await _internals73.unsubscribe(directory, correlationId);
+    const correlationId = _internals74.buildCorrelationId(sessionID, repoFullName, prInfo.number);
+    const result = await _internals74.unsubscribe(directory, correlationId);
     if (!result) {
       return [
         `Not subscribed to ${prUrl}`,
@@ -55631,7 +56696,7 @@ async function handlePrUnsubscribeCommand(directory, args, sessionID) {
 `);
   }
 }
-var _internals73 = {
+var _internals74 = {
   unsubscribe,
   buildCorrelationId,
   parsePrRef,
@@ -55681,7 +56746,7 @@ function normalizeRelativePathForPlatform(value, platform) {
 }
 function isRegularFile(candidate) {
   try {
-    return _internals74.statSync(candidate).isFile();
+    return _internals75.statSync(candidate).isFile();
   } catch {
     return false;
   }
@@ -55689,21 +56754,21 @@ function isRegularFile(candidate) {
 function readTextFileBounded(filePath, maxBytes) {
   let fd;
   try {
-    fd = _internals74.openSync(filePath, "r");
-    const stats = _internals74.fstatSync(fd);
+    fd = _internals75.openSync(filePath, "r");
+    const stats = _internals75.fstatSync(fd);
     if (!stats.isFile() || !Number.isSafeInteger(stats.size) || stats.size < 0 || stats.size > maxBytes) {
       return null;
     }
     const bytes = Buffer.alloc(stats.size);
     let offset = 0;
     while (offset < bytes.byteLength) {
-      const bytesRead = _internals74.readSync(fd, bytes, offset, bytes.byteLength - offset, null);
+      const bytesRead = _internals75.readSync(fd, bytes, offset, bytes.byteLength - offset, null);
       if (bytesRead === 0)
         break;
       offset += bytesRead;
     }
     const overflowProbe = Buffer.alloc(1);
-    if (_internals74.readSync(fd, overflowProbe, 0, 1, null) > 0)
+    if (_internals75.readSync(fd, overflowProbe, 0, 1, null) > 0)
       return null;
     return bytes.subarray(0, offset).toString("utf8");
   } catch {
@@ -55711,7 +56776,7 @@ function readTextFileBounded(filePath, maxBytes) {
   } finally {
     if (fd !== undefined) {
       try {
-        _internals74.closeSync(fd);
+        _internals75.closeSync(fd);
       } catch {}
     }
   }
@@ -55732,7 +56797,7 @@ function getAncestorDirectories(directory) {
   }
   return roots;
 }
-function getTrustedShimNames(linter, platform = _internals74.platform()) {
+function getTrustedShimNames(linter, platform = _internals75.platform()) {
   const isWindows = platform === "win32";
   if (linter === "biome") {
     return isWindows ? ["biome.exe", "biome.cmd", "biome.ps1"] : ["biome"];
@@ -55749,7 +56814,7 @@ function getPackageManifestPath(searchRoot, linter) {
   return path81.join(getPackageRootFromSearchRoot(searchRoot, linter), "package.json");
 }
 function getPackageDisplayPath(searchRoot, linter) {
-  return path81.join(searchRoot, NODE_MODULES, BIN_DIRECTORY, linter === "biome" ? _internals74.platform() === "win32" ? "biome.exe" : "biome" : _internals74.platform() === "win32" ? "eslint" : "eslint");
+  return path81.join(searchRoot, NODE_MODULES, BIN_DIRECTORY, linter === "biome" ? _internals75.platform() === "win32" ? "biome.exe" : "biome" : _internals75.platform() === "win32" ? "eslint" : "eslint");
 }
 function getBiomeNativePackage(platform, arch) {
   const archMap = platform === "darwin" ? { arm64: "@biomejs/cli-darwin-arm64", x64: "@biomejs/cli-darwin-x64" } : platform === "linux" ? {
@@ -55764,7 +56829,7 @@ function getBiomeNativePackage(platform, arch) {
     return null;
   return archMap[arch] ?? null;
 }
-function getBiomeNativeExecutable(searchRoot, platform = _internals74.platform(), arch = _internals74.arch()) {
+function getBiomeNativeExecutable(searchRoot, platform = _internals75.platform(), arch = _internals75.arch()) {
   const nativePackage = getBiomeNativePackage(platform, arch);
   if (!nativePackage)
     return null;
@@ -55800,8 +56865,8 @@ function resolveCanonicalPackageCommand(searchRoot, linter, source) {
   let canonicalCandidate;
   try {
     const packageRoot = path81.dirname(manifestPath);
-    canonicalPackageRoot = _internals74.realpathSync(packageRoot);
-    canonicalCandidate = _internals74.realpathSync(path81.resolve(packageRoot, relativeBinPath));
+    canonicalPackageRoot = _internals75.realpathSync(packageRoot);
+    canonicalCandidate = _internals75.realpathSync(path81.resolve(packageRoot, relativeBinPath));
   } catch {
     return null;
   }
@@ -55813,7 +56878,7 @@ function resolveCanonicalPackageCommand(searchRoot, linter, source) {
     return null;
   return {
     linter,
-    executable: _internals74.execPath(),
+    executable: _internals75.execPath(),
     argsPrefix: [canonicalCandidate],
     displayPrefix: [getPackageDisplayPath(searchRoot, linter)],
     source
@@ -55854,7 +56919,7 @@ function resolveLocalLinterCommand(linter, directory) {
   }
   return null;
 }
-function findPathShimCandidate(linter, envPath = _internals74.pathEnv(), platform = _internals74.platform()) {
+function findPathShimCandidate(linter, envPath = _internals75.pathEnv(), platform = _internals75.platform()) {
   const entries = envPath.split(path81.delimiter).filter(Boolean);
   const shimNames = getTrustedShimNames(linter, platform).filter((name) => name.endsWith(".cmd") || name.endsWith(".ps1") || platform !== "win32");
   for (const entry of entries) {
@@ -55884,7 +56949,7 @@ function getExpectedShimSuffixes(linter) {
     normalizeRelativePathForPlatform(nodeModulesPackageOnlySuffix, "linux")
   ];
 }
-function resolvePathShimTarget(shimPath, linter, platform = _internals74.platform()) {
+function resolvePathShimTarget(shimPath, linter, platform = _internals75.platform()) {
   const contents = readTextFileBounded(shimPath, MAX_PATH_SHIM_BYTES);
   if (contents === null)
     return null;
@@ -55931,7 +56996,7 @@ function resolvePathShimTarget(shimPath, linter, platform = _internals74.platfor
     return null;
   let canonicalShimDir;
   try {
-    canonicalShimDir = _internals74.realpathSync(path81.dirname(shimPath));
+    canonicalShimDir = _internals75.realpathSync(path81.dirname(shimPath));
   } catch {
     return null;
   }
@@ -55940,7 +57005,7 @@ function resolvePathShimTarget(shimPath, linter, platform = _internals74.platfor
     return null;
   let canonicalTarget;
   try {
-    canonicalTarget = _internals74.realpathSync(resolvedTarget);
+    canonicalTarget = _internals75.realpathSync(resolvedTarget);
   } catch {
     return null;
   }
@@ -55950,7 +57015,7 @@ function resolvePathShimTarget(shimPath, linter, platform = _internals74.platfor
   }
   let canonicalShimParent;
   try {
-    canonicalShimParent = _internals74.realpathSync(path81.dirname(canonicalShimDir));
+    canonicalShimParent = _internals75.realpathSync(path81.dirname(canonicalShimDir));
   } catch {
     return null;
   }
@@ -55964,8 +57029,8 @@ function resolvePathShimTarget(shimPath, linter, platform = _internals74.platfor
   return canonicalTarget;
 }
 function resolvePathLinterCommand(linter, directory) {
-  const platform = _internals74.platform();
-  const envPath = _internals74.pathEnv();
+  const platform = _internals75.platform();
+  const envPath = _internals75.pathEnv();
   const nativeNames = platform === "win32" ? linter === "biome" ? ["biome.exe"] : ["eslint.exe"] : linter === "biome" ? ["biome"] : ["eslint"];
   const nativeExecutable = resolveExecutableFromPath(nativeNames, envPath, platform);
   if (nativeExecutable) {
@@ -55985,7 +57050,7 @@ function resolvePathLinterCommand(linter, directory) {
     return null;
   return {
     linter,
-    executable: _internals74.execPath(),
+    executable: _internals75.execPath(),
     argsPrefix: [shimTarget],
     displayPrefix: [path81.join(directory, NODE_MODULES, BIN_DIRECTORY, linter)],
     source: "path-shim"
@@ -56022,7 +57087,7 @@ function buildExecutionError(mode, command, linter, result) {
   };
 }
 async function probeResolvedCommand(command, cwd, abortSignal) {
-  const result = await _internals74.runExternalTool({
+  const result = await _internals75.runExternalTool({
     executable: command.executable,
     args: [...command.argsPrefix, "--version"],
     cwd,
@@ -56040,7 +57105,7 @@ async function resolveLinterCommand(linter, directory) {
 async function detectResolvedLinter(directory, abortSignal) {
   if (!directory)
     return null;
-  if (!_internals74.existsSync(directory))
+  if (!_internals75.existsSync(directory))
     return null;
   const cwd = toAbsoluteDirectory(directory);
   for (const linter of SUPPORTED_LINTERS) {
@@ -56054,12 +57119,12 @@ async function detectResolvedLinter(directory, abortSignal) {
   return null;
 }
 function detectRuff(cwd) {
-  if (_internals74.existsSync(path81.join(cwd, "ruff.toml")))
+  if (_internals75.existsSync(path81.join(cwd, "ruff.toml")))
     return hasAdditionalCommand("ruff");
   try {
     const pyproject = path81.join(cwd, "pyproject.toml");
-    if (_internals74.existsSync(pyproject)) {
-      const content = _internals74.readFileSync(pyproject, "utf-8");
+    if (_internals75.existsSync(pyproject)) {
+      const content = _internals75.readFileSync(pyproject, "utf-8");
       if (content.includes("[tool.ruff]"))
         return hasAdditionalCommand("ruff");
     }
@@ -56067,32 +57132,32 @@ function detectRuff(cwd) {
   return false;
 }
 function detectClippy(cwd) {
-  return _internals74.existsSync(path81.join(cwd, "Cargo.toml")) && hasAdditionalCommand("cargo");
+  return _internals75.existsSync(path81.join(cwd, "Cargo.toml")) && hasAdditionalCommand("cargo");
 }
 function detectGolangciLint(cwd) {
-  return _internals74.existsSync(path81.join(cwd, "go.mod")) && hasAdditionalCommand("golangci-lint");
+  return _internals75.existsSync(path81.join(cwd, "go.mod")) && hasAdditionalCommand("golangci-lint");
 }
 function readTextFileSafe(filePath) {
   try {
-    return _internals74.readFileSync(filePath, "utf-8");
+    return _internals75.readFileSync(filePath, "utf-8");
   } catch {
     return "";
   }
 }
 function resolveAdditionalExecutable(name) {
-  const platform = _internals74.platform();
+  const platform = _internals75.platform();
   if (platform !== "win32") {
-    return _internals74.isCommandAvailable(name) ? name : null;
+    return _internals75.isCommandAvailable(name) ? name : null;
   }
-  return resolveExecutableFromPath([`${name}.exe`], _internals74.pathEnv(), platform);
+  return resolveExecutableFromPath([`${name}.exe`], _internals75.pathEnv(), platform);
 }
 function resolveWindowsCommandInterpreter() {
-  const candidate = _internals74.comSpec();
+  const candidate = _internals75.comSpec();
   if (!candidate || !path81.isAbsolute(candidate) || path81.basename(candidate).toLowerCase() !== "cmd.exe" || !isRegularFile(candidate)) {
     return null;
   }
   try {
-    const canonical = _internals74.realpathSync(candidate);
+    const canonical = _internals75.realpathSync(candidate);
     return path81.basename(canonical).toLowerCase() === "cmd.exe" ? canonical : null;
   } catch {
     return null;
@@ -56104,7 +57169,7 @@ function buildWindowsBatchCommand(wrapperPath, args) {
     return null;
   let canonicalWrapper;
   try {
-    canonicalWrapper = _internals74.realpathSync(wrapperPath);
+    canonicalWrapper = _internals75.realpathSync(wrapperPath);
   } catch {
     return null;
   }
@@ -56118,13 +57183,13 @@ function buildWindowsBatchCommand(wrapperPath, args) {
   return [interpreter, "/d", "/s", "/v:off", "/c", command];
 }
 function resolveWindowsBatchCommandFromPath(name, args) {
-  if (_internals74.platform() !== "win32")
+  if (_internals75.platform() !== "win32")
     return null;
-  const wrapper = resolveExecutableFromPath(WINDOWS_BATCH_WRAPPER_EXTENSIONS.map((extension) => `${name}${extension}`), _internals74.pathEnv(), "win32");
+  const wrapper = resolveExecutableFromPath(WINDOWS_BATCH_WRAPPER_EXTENSIONS.map((extension) => `${name}${extension}`), _internals75.pathEnv(), "win32");
   return wrapper ? buildWindowsBatchCommand(wrapper, args) : null;
 }
 function resolveContainedWindowsBatchCommand(cwd, fileName, args) {
-  if (_internals74.platform() !== "win32")
+  if (_internals75.platform() !== "win32")
     return null;
   const candidate = path81.join(cwd, fileName);
   if (!isRegularFile(candidate))
@@ -56132,8 +57197,8 @@ function resolveContainedWindowsBatchCommand(cwd, fileName, args) {
   let canonicalCwd;
   let canonicalCandidate;
   try {
-    canonicalCwd = _internals74.realpathSync(cwd);
-    canonicalCandidate = _internals74.realpathSync(candidate);
+    canonicalCwd = _internals75.realpathSync(cwd);
+    canonicalCandidate = _internals75.realpathSync(candidate);
   } catch {
     return null;
   }
@@ -56154,22 +57219,22 @@ function hasAdditionalCommand(name) {
 }
 function resolvePhpVendorCommand(cwd, name) {
   const relativeProxy = path81.join("vendor", "bin", name);
-  if (!_internals74.existsSync(path81.join(cwd, relativeProxy)))
+  if (!_internals75.existsSync(path81.join(cwd, relativeProxy)))
     return null;
-  if (_internals74.platform() !== "win32")
+  if (_internals75.platform() !== "win32")
     return [relativeProxy];
   const phpExecutable = resolveAdditionalExecutable("php");
   return phpExecutable ? [phpExecutable, relativeProxy] : null;
 }
 function hasCheckstyleGradleSignal(cwd) {
-  const gradleFiles = ["build.gradle", "build.gradle.kts"].map((file) => path81.join(cwd, file)).filter((file) => _internals74.existsSync(file));
-  return _internals74.existsSync(path81.join(cwd, "checkstyle.xml")) || _internals74.existsSync(path81.join(cwd, "config", "checkstyle", "checkstyle.xml")) || gradleFiles.some((file) => /\bcheckstyle\b/i.test(readTextFileSafe(file)));
+  const gradleFiles = ["build.gradle", "build.gradle.kts"].map((file) => path81.join(cwd, file)).filter((file) => _internals75.existsSync(file));
+  return _internals75.existsSync(path81.join(cwd, "checkstyle.xml")) || _internals75.existsSync(path81.join(cwd, "config", "checkstyle", "checkstyle.xml")) || gradleFiles.some((file) => /\bcheckstyle\b/i.test(readTextFileSafe(file)));
 }
 function resolveCheckstyleCommand(cwd) {
-  const hasMavenProject = _internals74.existsSync(path81.join(cwd, "pom.xml"));
+  const hasMavenProject = _internals75.existsSync(path81.join(cwd, "pom.xml"));
   const hasGradleSignal = hasCheckstyleGradleSignal(cwd);
   if (hasGradleSignal) {
-    if (_internals74.platform() === "win32") {
+    if (_internals75.platform() === "win32") {
       const gradlew = resolveContainedWindowsBatchCommand(cwd, "gradlew.bat", [
         "checkstyleMain"
       ]);
@@ -56177,7 +57242,7 @@ function resolveCheckstyleCommand(cwd) {
         return gradlew;
     } else {
       const gradlew = path81.join(cwd, "gradlew");
-      if (_internals74.existsSync(gradlew))
+      if (_internals75.existsSync(gradlew))
         return [gradlew, "checkstyleMain"];
     }
     const gradle = buildAdditionalCommand("gradle", ["checkstyleMain"]);
@@ -56191,7 +57256,7 @@ function resolveCheckstyleCommand(cwd) {
   }
   return null;
 }
-function isUnsafeShellWrapperExecutable(executable, platform = _internals74.platform()) {
+function isUnsafeShellWrapperExecutable(executable, platform = _internals75.platform()) {
   return platform === "win32" && UNSAFE_SHELL_WRAPPER_EXTENSIONS.has(path81.extname(executable).toLowerCase());
 }
 function detectCheckstyle(cwd) {
@@ -56199,7 +57264,7 @@ function detectCheckstyle(cwd) {
 }
 function hasRootKotlinFile(cwd) {
   try {
-    return _internals74.readdirSync(cwd).some((f) => f.endsWith(".kt") || f.endsWith(".kts"));
+    return _internals75.readdirSync(cwd).some((f) => f.endsWith(".kt") || f.endsWith(".kts"));
   } catch {
     return false;
   }
@@ -56209,27 +57274,27 @@ function buildGradleHasKotlinSignal(cwd) {
   return /\b(kotlin|org\.jetbrains\.kotlin|ktlint)\b/i.test(content);
 }
 function detectKtlint(cwd) {
-  const hasKotlin = _internals74.existsSync(path81.join(cwd, "build.gradle.kts")) || _internals74.existsSync(path81.join(cwd, "build.gradle")) && buildGradleHasKotlinSignal(cwd) || hasRootKotlinFile(cwd);
+  const hasKotlin = _internals75.existsSync(path81.join(cwd, "build.gradle.kts")) || _internals75.existsSync(path81.join(cwd, "build.gradle")) && buildGradleHasKotlinSignal(cwd) || hasRootKotlinFile(cwd);
   return hasKotlin && hasAdditionalCommand("ktlint");
 }
 function detectPhpLinter(cwd) {
-  if ((_internals74.existsSync(path81.join(cwd, "phpstan.neon")) || _internals74.existsSync(path81.join(cwd, "phpstan.neon.dist"))) && resolvePhpVendorCommand(cwd, "phpstan") !== null) {
+  if ((_internals75.existsSync(path81.join(cwd, "phpstan.neon")) || _internals75.existsSync(path81.join(cwd, "phpstan.neon.dist"))) && resolvePhpVendorCommand(cwd, "phpstan") !== null) {
     return "phpstan";
   }
-  if (_internals74.existsSync(path81.join(cwd, "pint.json")) && resolvePhpVendorCommand(cwd, "pint") !== null) {
+  if (_internals75.existsSync(path81.join(cwd, "pint.json")) && resolvePhpVendorCommand(cwd, "pint") !== null) {
     return "pint";
   }
-  if (_internals74.existsSync(path81.join(cwd, ".php-cs-fixer.php")) && resolvePhpVendorCommand(cwd, "php-cs-fixer") !== null) {
+  if (_internals75.existsSync(path81.join(cwd, ".php-cs-fixer.php")) && resolvePhpVendorCommand(cwd, "php-cs-fixer") !== null) {
     return "php-cs-fixer";
   }
-  if (_internals74.existsSync(path81.join(cwd, "phpcs.xml")) && resolvePhpVendorCommand(cwd, "phpcs") !== null) {
+  if (_internals75.existsSync(path81.join(cwd, "phpcs.xml")) && resolvePhpVendorCommand(cwd, "phpcs") !== null) {
     return "phpcs";
   }
   return null;
 }
 function detectDotnetFormat(cwd) {
   try {
-    const files = _internals74.readdirSync(cwd);
+    const files = _internals75.readdirSync(cwd);
     const hasCsproj = files.some((f) => f.endsWith(".csproj") || f.endsWith(".sln"));
     return hasCsproj && hasAdditionalCommand("dotnet");
   } catch {
@@ -56237,14 +57302,14 @@ function detectDotnetFormat(cwd) {
   }
 }
 function detectCppcheck(cwd) {
-  if (_internals74.existsSync(path81.join(cwd, "CMakeLists.txt"))) {
+  if (_internals75.existsSync(path81.join(cwd, "CMakeLists.txt"))) {
     return hasAdditionalCommand("cppcheck");
   }
   try {
     const dirsToCheck = [cwd, path81.join(cwd, "src")];
     const hasCpp = dirsToCheck.some((dir) => {
       try {
-        return _internals74.readdirSync(dir).some((f) => /\.(c|cpp|cc|cxx|h|hpp)$/.test(f));
+        return _internals75.readdirSync(dir).some((f) => /\.(c|cpp|cc|cxx|h|hpp)$/.test(f));
       } catch {
         return false;
       }
@@ -56255,13 +57320,13 @@ function detectCppcheck(cwd) {
   }
 }
 function detectSwiftlint(cwd) {
-  return _internals74.existsSync(path81.join(cwd, "Package.swift")) && hasAdditionalCommand("swiftlint");
+  return _internals75.existsSync(path81.join(cwd, "Package.swift")) && hasAdditionalCommand("swiftlint");
 }
 function detectDartAnalyze(cwd) {
-  return _internals74.existsSync(path81.join(cwd, "pubspec.yaml")) && hasAdditionalCommand("dart");
+  return _internals75.existsSync(path81.join(cwd, "pubspec.yaml")) && hasAdditionalCommand("dart");
 }
 function detectRubocop(cwd) {
-  return (_internals74.existsSync(path81.join(cwd, "Gemfile")) || _internals74.existsSync(path81.join(cwd, "gems.rb")) || _internals74.existsSync(path81.join(cwd, ".rubocop.yml"))) && (hasAdditionalCommand("rubocop") || hasAdditionalCommand("bundle"));
+  return (_internals75.existsSync(path81.join(cwd, "Gemfile")) || _internals75.existsSync(path81.join(cwd, "gems.rb")) || _internals75.existsSync(path81.join(cwd, ".rubocop.yml"))) && (hasAdditionalCommand("rubocop") || hasAdditionalCommand("bundle"));
 }
 function detectAdditionalLinter(cwd) {
   if (detectRuff(cwd))
@@ -56306,7 +57371,7 @@ async function runResolvedLint(command, mode, directory, abortSignal) {
       error: "Command exceeds maximum allowed length"
     };
   }
-  const runResult = await _internals74.runExternalTool({
+  const runResult = await _internals75.runExternalTool({
     executable: command.executable,
     args: [...command.argsPrefix, ...lintArgs],
     cwd: toAbsoluteDirectory(directory),
@@ -56384,7 +57449,7 @@ function getAdditionalLinterCommand(linter, mode, cwd) {
   }
 }
 async function runLint(linter, mode, directory, abortSignal) {
-  const resolved = await _internals74.resolveLinterCommand(linter, directory);
+  const resolved = await _internals75.resolveLinterCommand(linter, directory);
   if (!resolved) {
     return {
       success: false,
@@ -56425,7 +57490,7 @@ async function runAdditionalLint(linter, mode, cwd, abortSignal) {
       error: `No safely executable ${linter} command found`
     };
   }
-  const runResult = await _internals74.runExternalTool({
+  const runResult = await _internals75.runExternalTool({
     executable,
     args,
     cwd: toAbsoluteDirectory(cwd),
@@ -56433,7 +57498,7 @@ async function runAdditionalLint(linter, mode, cwd, abortSignal) {
     maxStdoutBytes: MAX_OUTPUT_BYTES2,
     maxStderrBytes: MAX_OUTPUT_BYTES2,
     abortSignal,
-    windowsVerbatimArguments: _internals74.platform() === "win32" && path81.basename(executable).toLowerCase() === "cmd.exe"
+    windowsVerbatimArguments: _internals75.platform() === "win32" && path81.basename(executable).toLowerCase() === "cmd.exe"
   });
   if (runResult.status !== "completed") {
     return buildExecutionError(mode, command, linter, runResult);
@@ -56480,15 +57545,15 @@ var lint = createSwarmTool({
     }
     const { mode } = args;
     const cwd = directory;
-    const resolvedLinter = await _internals74.detectResolvedLinter(directory, ctx?.abort);
+    const resolvedLinter = await _internals75.detectResolvedLinter(directory, ctx?.abort);
     if (resolvedLinter) {
-      const result = await _internals74.runResolvedLint(resolvedLinter, mode, directory, ctx?.abort);
+      const result = await _internals75.runResolvedLint(resolvedLinter, mode, directory, ctx?.abort);
       return JSON.stringify(result, null, 2);
     }
-    const additionalLinter = _internals74.detectAdditionalLinter(cwd);
+    const additionalLinter = _internals75.detectAdditionalLinter(cwd);
     if (additionalLinter) {
       warn(`[lint] Using ${additionalLinter} linter for this project`);
-      const result = await _internals74.runAdditionalLint(additionalLinter, mode, cwd, ctx?.abort);
+      const result = await _internals75.runAdditionalLint(additionalLinter, mode, cwd, ctx?.abort);
       return JSON.stringify(result, null, 2);
     }
     const errorResult = {
@@ -56502,7 +57567,7 @@ For Rust: rustup component add clippy`
     return JSON.stringify(errorResult, null, 2);
   }
 });
-var _internals74 = {
+var _internals75 = {
   MAX_PACKAGE_MANIFEST_BYTES,
   MAX_PATH_SHIM_BYTES,
   arch: () => process.arch,
@@ -56906,14 +57971,14 @@ function readBoundedFile(filePath, expectedPathStat) {
   let fd = null;
   try {
     const flags = fs33.constants.O_RDONLY | (O_NOFOLLOW !== undefined ? O_NOFOLLOW : 0);
-    fd = _internals75.openFile(filePath, flags);
+    fd = _internals76.openFile(filePath, flags);
   } catch {
     return { status: "incomplete", reason: "read_error" };
   }
   let outcome;
   let closeFailed = false;
   try {
-    const stat9 = _internals75.fstatFile(fd);
+    const stat9 = _internals76.fstatFile(fd);
     const descriptorIdentity = getStableFileIdentity(stat9);
     const initialSize = stat9.size;
     if (!stat9.isFile()) {
@@ -56925,14 +57990,14 @@ function readBoundedFile(filePath, expectedPathStat) {
       const buffer = Buffer.allocUnsafe(bufferLength);
       let bytesRead = 0;
       while (bytesRead < buffer.length) {
-        const count = _internals75.readFileChunk(fd, buffer, bytesRead, buffer.length - bytesRead, null);
+        const count = _internals76.readFileChunk(fd, buffer, bytesRead, buffer.length - bytesRead, null);
         if (count === 0)
           break;
         bytesRead += count;
       }
-      const postStat = _internals75.fstatFile(fd);
+      const postStat = _internals76.fstatFile(fd);
       const postDescriptorIdentity = getStableFileIdentity(postStat);
-      const postPathStat = _internals75.lstatFile(filePath);
+      const postPathStat = _internals76.lstatFile(filePath);
       const postPathIdentity = getStableFileIdentity(postPathStat);
       if (!postStat.isFile() || postDescriptorIdentity === null || postDescriptorIdentity !== descriptorIdentity || postPathStat.isSymbolicLink() || !postPathStat.isFile() || postPathIdentity === null || postPathIdentity !== descriptorIdentity) {
         outcome = { status: "incomplete", reason: "read_error" };
@@ -56954,7 +58019,7 @@ function readBoundedFile(filePath, expectedPathStat) {
   } finally {
     if (fd !== null) {
       try {
-        _internals75.closeFile(fd);
+        _internals76.closeFile(fd);
       } catch {
         closeFailed = true;
       }
@@ -56967,7 +58032,7 @@ function readBoundedFile(filePath, expectedPathStat) {
 function scanFileForSecrets(filePath, mode) {
   const findings = [];
   try {
-    const lstat3 = _internals75.lstatFile(filePath);
+    const lstat3 = _internals76.lstatFile(filePath);
     if (lstat3.isSymbolicLink()) {
       return mode === "explicit" ? { status: "incomplete", reason: "symlink" } : { status: "skipped", reason: "symlink" };
     }
@@ -57146,8 +58211,8 @@ async function collectScannableFiles(dir, excludeExact, excludeGlobs, scanDir, v
       while (true) {
         if (state.entriesSinceYield >= DISCOVERY_YIELD_INTERVAL) {
           state.entriesSinceYield = 0;
-          await _internals75.yieldToEventLoop();
-          if (_internals75.now() >= state.deadline) {
+          await _internals76.yieldToEventLoop();
+          if (_internals76.now() >= state.deadline) {
             state.deadlineExceeded = true;
             recordIncompletePath(state.incompletePaths, scanDir, currentDir, "deadline");
             stoppedEarly = true;
@@ -57210,7 +58275,7 @@ async function collectScannableFiles(dir, excludeExact, excludeGlobs, scanDir, v
       }
     } finally {
       try {
-        _internals75.closeDirectory(directory);
+        _internals76.closeDirectory(directory);
       } catch (error2) {
         if (error2.code !== "ERR_DIR_CLOSED") {
           state.cleanupFailed = true;
@@ -57332,7 +58397,7 @@ var secretscan = createSwarmTool({
         symlinkSkipped: 0
       };
       const visited = new Set;
-      const deadline = _internals75.now() + SCAN_TIME_BUDGET_MS;
+      const deadline = _internals76.now() + SCAN_TIME_BUDGET_MS;
       const discovery = {
         files: [],
         totalCandidates: 0,
@@ -57344,7 +58409,7 @@ var secretscan = createSwarmTool({
         directoriesQueued: 1,
         unexaminedDirectories: 0
       };
-      await _internals75.yieldToEventLoop();
+      await _internals76.yieldToEventLoop();
       await collectScannableFiles(scanDir, excludeExact, excludeGlobs, scanDir, visited, stats, discovery);
       const files = discovery.files;
       files.sort(compareFilePaths);
@@ -57363,7 +58428,7 @@ var secretscan = createSwarmTool({
       let skippedFiles = stats.skippedFiles;
       let incompleteFiles = stats.fileErrors + Math.max(0, discovery.totalCandidates - filesToScan.length) + (discovery.deadlineExceeded || discovery.cleanupFailed ? 1 : 0) + discovery.unexaminedDirectories;
       for (let index = 0;index < filesToScan.length; index++) {
-        if (_internals75.now() >= deadline) {
+        if (_internals76.now() >= deadline) {
           for (const remaining of filesToScan.slice(index)) {
             recordIncompletePath(discovery.incompletePaths, scanDir, remaining, "deadline");
           }
@@ -57399,7 +58464,7 @@ var secretscan = createSwarmTool({
           }
         }
         if (index + 1 < filesToScan.length) {
-          await _internals75.yieldToEventLoop();
+          await _internals76.yieldToEventLoop();
         }
       }
       allFindings.sort((a, b) => {
@@ -57462,7 +58527,7 @@ var secretscan = createSwarmTool({
 });
 async function runSecretscan(directory) {
   try {
-    const result = await _internals75.secretscan.execute({ directory }, {});
+    const result = await _internals76.secretscan.execute({ directory }, {});
     const jsonStr = typeof result === "string" ? result : result.output;
     return JSON.parse(jsonStr);
   } catch (e) {
@@ -57513,10 +58578,10 @@ async function runSecretscanOnFiles(files, directory) {
     if (files.length > filesToScan.length) {
       recordIncompletePath(incompletePaths, canonicalRoot, canonicalRoot, "max_files");
     }
-    const deadline = _internals75.now() + SCAN_TIME_BUDGET_MS;
-    await _internals75.yieldToEventLoop();
+    const deadline = _internals76.now() + SCAN_TIME_BUDGET_MS;
+    await _internals76.yieldToEventLoop();
     for (let index = 0;index < filesToScan.length; index++) {
-      if (_internals75.now() >= deadline) {
+      if (_internals76.now() >= deadline) {
         for (const remaining of filesToScan.slice(index)) {
           const remainingPath = path82.isAbsolute(remaining) ? path82.resolve(remaining) : path82.resolve(rawRoot, remaining);
           recordIncompletePath(incompletePaths, canonicalRoot, remainingPath, "deadline");
@@ -57543,7 +58608,7 @@ async function runSecretscanOnFiles(files, directory) {
       }
       let lstat3;
       try {
-        lstat3 = _internals75.lstatFile(resolvedPath);
+        lstat3 = _internals76.lstatFile(resolvedPath);
       } catch (error2) {
         const err = error2;
         if (err.code === "ENOENT") {
@@ -57612,7 +58677,7 @@ async function runSecretscanOnFiles(files, directory) {
           assertNever(outcome);
       }
       if (index + 1 < filesToScan.length) {
-        await _internals75.yieldToEventLoop();
+        await _internals76.yieldToEventLoop();
       }
     }
     findings.sort((a, b) => {
@@ -57642,7 +58707,7 @@ async function runSecretscanOnFiles(files, directory) {
     };
   }
 }
-var _internals75 = {
+var _internals76 = {
   secretscan,
   runSecretscan,
   runSecretscanOnFiles,
@@ -57926,7 +58991,7 @@ async function buildImpactMapInternal(cwd) {
   }
   return impactMap;
 }
-var _internals76 = {
+var _internals77 = {
   validateProjectRoot,
   normalizePath: normalizePath2,
   isCacheStale,
@@ -57941,8 +59006,8 @@ var _internals76 = {
   _clearGoModuleCache
 };
 async function buildImpactMap(cwd) {
-  const impactMap = await _internals76.buildImpactMapInternal(cwd);
-  await _internals76.saveImpactMap(cwd, impactMap);
+  const impactMap = await _internals77.buildImpactMapInternal(cwd);
+  await _internals77.saveImpactMap(cwd, impactMap);
   return impactMap;
 }
 async function loadImpactMap(cwd, options) {
@@ -57956,7 +59021,7 @@ async function loadImpactMap(cwd, options) {
         const hasValidValues = Object.values(map).every((v) => Array.isArray(v) && v.every((item) => typeof item === "string"));
         if (hasValidValues) {
           const generatedAt = new Date(data.generatedAt).getTime();
-          if (!_internals76.isCacheStale(map, generatedAt)) {
+          if (!_internals77.isCacheStale(map, generatedAt)) {
             return map;
           }
           if (options?.skipRebuild) {
@@ -57976,13 +59041,13 @@ async function loadImpactMap(cwd, options) {
   if (options?.skipRebuild) {
     return {};
   }
-  return _internals76.buildImpactMap(cwd);
+  return _internals77.buildImpactMap(cwd);
 }
 async function saveImpactMap(cwd, impactMap) {
   if (!path83.isAbsolute(cwd)) {
     throw new Error(`saveImpactMap requires an absolute project root path, got: "${cwd}"`);
   }
-  _internals76.validateProjectRoot(cwd);
+  _internals77.validateProjectRoot(cwd);
   const cacheDir2 = path83.join(cwd, ".swarm", "cache");
   const cachePath = path83.join(cacheDir2, "impact-map.json");
   if (!fs34.existsSync(cacheDir2)) {
@@ -58006,7 +59071,7 @@ async function analyzeImpact(changedFiles, cwd, budget) {
     };
   }
   const validFiles = changedFiles.filter((f) => typeof f === "string" && f.length > 0 && !f.includes("\x00"));
-  const impactMap = await _internals76.loadImpactMap(cwd);
+  const impactMap = await _internals77.loadImpactMap(cwd);
   const impactedTestsSet = new Set;
   const untestedFiles = [];
   let visitedCount = 0;
@@ -58283,7 +59348,7 @@ function batchAppendTestRuns(records, workingDir) {
   }
   const historyPath = getHistoryPath(workingDir);
   const historyDir = path84.dirname(historyPath);
-  _internals77.validateProjectRoot(workingDir);
+  _internals78.validateProjectRoot(workingDir);
   if (!fs35.existsSync(historyDir)) {
     fs35.mkdirSync(historyDir, { recursive: true });
   }
@@ -58406,7 +59471,7 @@ function getAllHistory(workingDir) {
   records.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
   return records;
 }
-var _internals77 = {
+var _internals78 = {
   validateProjectRoot
 };
 
@@ -58419,7 +59484,7 @@ var MAX_SAFE_TEST_FILES = 50;
 var MAX_SAFE_SOURCE_FILES = 1;
 async function estimateFanOut(sourceFiles, cwd) {
   try {
-    const impactMap = await _internals78.loadImpactMap(cwd, {
+    const impactMap = await _internals79.loadImpactMap(cwd, {
       skipRebuild: true
     });
     const uniqueTestFiles = new Set;
@@ -58590,7 +59655,7 @@ function resolveNativeTarget(target, workingDir) {
   if (relative14.startsWith("..") || path85.isAbsolute(relative14)) {
     return { success: false, error: "Native target path escapes project root" };
   }
-  if (!_internals78.isCommandAvailable(target.framework === "go-test" ? "go" : "ctest")) {
+  if (!_internals79.isCommandAvailable(target.framework === "go-test" ? "go" : "ctest")) {
     return {
       success: false,
       error: `Native target framework "${target.framework}" is unavailable`
@@ -58651,45 +59716,45 @@ function hasDevDependency(devDeps, ...patterns) {
   return hasPackageJsonDependency(devDeps, ...patterns);
 }
 function detectGoTest(cwd) {
-  return _internals78.existsSync(path85.join(cwd, "go.mod")) && _internals78.isCommandAvailable("go");
+  return _internals79.existsSync(path85.join(cwd, "go.mod")) && _internals79.isCommandAvailable("go");
 }
 function detectJavaMaven(cwd) {
-  return _internals78.existsSync(path85.join(cwd, "pom.xml")) && _internals78.isCommandAvailable("mvn");
+  return _internals79.existsSync(path85.join(cwd, "pom.xml")) && _internals79.isCommandAvailable("mvn");
 }
 function detectGradle(cwd) {
-  const hasBuildFile = _internals78.existsSync(path85.join(cwd, "build.gradle")) || _internals78.existsSync(path85.join(cwd, "build.gradle.kts"));
-  const hasGradlew = _internals78.existsSync(path85.join(cwd, "gradlew")) || _internals78.existsSync(path85.join(cwd, "gradlew.bat"));
-  return hasBuildFile && (hasGradlew || _internals78.isCommandAvailable("gradle"));
+  const hasBuildFile = _internals79.existsSync(path85.join(cwd, "build.gradle")) || _internals79.existsSync(path85.join(cwd, "build.gradle.kts"));
+  const hasGradlew = _internals79.existsSync(path85.join(cwd, "gradlew")) || _internals79.existsSync(path85.join(cwd, "gradlew.bat"));
+  return hasBuildFile && (hasGradlew || _internals79.isCommandAvailable("gradle"));
 }
 function detectDotnetTest(cwd) {
   try {
-    const files = _internals78.readdirSync(cwd);
+    const files = _internals79.readdirSync(cwd);
     const hasCsproj = files.some((f) => f.endsWith(".csproj"));
-    return hasCsproj && _internals78.isCommandAvailable("dotnet");
+    return hasCsproj && _internals79.isCommandAvailable("dotnet");
   } catch {
     return false;
   }
 }
 function detectCTest(cwd) {
-  const hasSource = _internals78.existsSync(path85.join(cwd, "CMakeLists.txt"));
-  const hasBuildCache = _internals78.existsSync(path85.join(cwd, "CMakeCache.txt")) || _internals78.existsSync(path85.join(cwd, "build", "CMakeCache.txt"));
-  return (hasSource || hasBuildCache) && _internals78.isCommandAvailable("ctest");
+  const hasSource = _internals79.existsSync(path85.join(cwd, "CMakeLists.txt"));
+  const hasBuildCache = _internals79.existsSync(path85.join(cwd, "CMakeCache.txt")) || _internals79.existsSync(path85.join(cwd, "build", "CMakeCache.txt"));
+  return (hasSource || hasBuildCache) && _internals79.isCommandAvailable("ctest");
 }
 function detectSwiftTest(cwd) {
-  return _internals78.existsSync(path85.join(cwd, "Package.swift")) && _internals78.isCommandAvailable("swift");
+  return _internals79.existsSync(path85.join(cwd, "Package.swift")) && _internals79.isCommandAvailable("swift");
 }
 function detectDartTest(cwd) {
-  return _internals78.existsSync(path85.join(cwd, "pubspec.yaml")) && (_internals78.isCommandAvailable("dart") || _internals78.isCommandAvailable("flutter"));
+  return _internals79.existsSync(path85.join(cwd, "pubspec.yaml")) && (_internals79.isCommandAvailable("dart") || _internals79.isCommandAvailable("flutter"));
 }
 function detectRSpec(cwd) {
-  const hasRSpecFile = _internals78.existsSync(path85.join(cwd, ".rspec"));
-  const hasGemfile = _internals78.existsSync(path85.join(cwd, "Gemfile"));
-  const hasSpecDir = _internals78.existsSync(path85.join(cwd, "spec"));
+  const hasRSpecFile = _internals79.existsSync(path85.join(cwd, ".rspec"));
+  const hasGemfile = _internals79.existsSync(path85.join(cwd, "Gemfile"));
+  const hasSpecDir = _internals79.existsSync(path85.join(cwd, "spec"));
   const hasRSpec = hasRSpecFile || hasGemfile && hasSpecDir;
-  return hasRSpec && (_internals78.isCommandAvailable("bundle") || _internals78.isCommandAvailable("rspec"));
+  return hasRSpec && (_internals79.isCommandAvailable("bundle") || _internals79.isCommandAvailable("rspec"));
 }
 function detectMinitest(cwd) {
-  return _internals78.existsSync(path85.join(cwd, "test")) && (_internals78.existsSync(path85.join(cwd, "Gemfile")) || _internals78.existsSync(path85.join(cwd, "Rakefile"))) && _internals78.isCommandAvailable("ruby");
+  return _internals79.existsSync(path85.join(cwd, "test")) && (_internals79.existsSync(path85.join(cwd, "Gemfile")) || _internals79.existsSync(path85.join(cwd, "Rakefile"))) && _internals79.isCommandAvailable("ruby");
 }
 var DISPATCH_FRAMEWORK_MAP = {
   bun: "bun",
@@ -58782,8 +59847,8 @@ async function detectTestFramework(cwd) {
   const baseDir = cwd;
   try {
     const packageJsonPath = path85.join(baseDir, "package.json");
-    if (_internals78.existsSync(packageJsonPath)) {
-      const content = _internals78.readFileSync(packageJsonPath, "utf-8");
+    if (_internals79.existsSync(packageJsonPath)) {
+      const content = _internals79.readFileSync(packageJsonPath, "utf-8");
       const pkg = JSON.parse(content);
       const _deps = pkg.dependencies || {};
       const devDeps = pkg.devDependencies || {};
@@ -58802,7 +59867,7 @@ async function detectTestFramework(cwd) {
         return "jest";
       if (hasDevDependency(devDeps, "mocha", "@types/mocha"))
         return "mocha";
-      if (_internals78.existsSync(path85.join(baseDir, "bun.lockb")) || _internals78.existsSync(path85.join(baseDir, "bun.lock"))) {
+      if (_internals79.existsSync(path85.join(baseDir, "bun.lockb")) || _internals79.existsSync(path85.join(baseDir, "bun.lock"))) {
         if (scripts.test?.includes("bun"))
           return "bun";
       }
@@ -58812,28 +59877,28 @@ async function detectTestFramework(cwd) {
     const pyprojectTomlPath = path85.join(baseDir, "pyproject.toml");
     const setupCfgPath = path85.join(baseDir, "setup.cfg");
     const requirementsTxtPath = path85.join(baseDir, "requirements.txt");
-    if (_internals78.existsSync(pyprojectTomlPath)) {
-      const content = _internals78.readFileSync(pyprojectTomlPath, "utf-8");
+    if (_internals79.existsSync(pyprojectTomlPath)) {
+      const content = _internals79.readFileSync(pyprojectTomlPath, "utf-8");
       if (content.includes("[tool.pytest"))
         return "pytest";
       if (content.includes("pytest"))
         return "pytest";
     }
-    if (_internals78.existsSync(setupCfgPath)) {
-      const content = _internals78.readFileSync(setupCfgPath, "utf-8");
+    if (_internals79.existsSync(setupCfgPath)) {
+      const content = _internals79.readFileSync(setupCfgPath, "utf-8");
       if (content.includes("[pytest]"))
         return "pytest";
     }
-    if (_internals78.existsSync(requirementsTxtPath)) {
-      const content = _internals78.readFileSync(requirementsTxtPath, "utf-8");
+    if (_internals79.existsSync(requirementsTxtPath)) {
+      const content = _internals79.readFileSync(requirementsTxtPath, "utf-8");
       if (content.includes("pytest"))
         return "pytest";
     }
   } catch {}
   try {
     const cargoTomlPath = path85.join(baseDir, "Cargo.toml");
-    if (_internals78.existsSync(cargoTomlPath)) {
-      const content = _internals78.readFileSync(cargoTomlPath, "utf-8");
+    if (_internals79.existsSync(cargoTomlPath)) {
+      const content = _internals79.readFileSync(cargoTomlPath, "utf-8");
       if (content.includes("[dev-dependencies]")) {
         if (content.includes("tokio") || content.includes("mockall") || content.includes("pretty_assertions")) {
           return "cargo";
@@ -58845,7 +59910,7 @@ async function detectTestFramework(cwd) {
     const pesterConfigPath = path85.join(baseDir, "pester.config.ps1");
     const pesterConfigJsonPath = path85.join(baseDir, "pester.config.ps1.json");
     const pesterPs1Path = path85.join(baseDir, "tests.ps1");
-    if (_internals78.existsSync(pesterConfigPath) || _internals78.existsSync(pesterConfigJsonPath) || _internals78.existsSync(pesterPs1Path)) {
+    if (_internals79.existsSync(pesterConfigPath) || _internals79.existsSync(pesterConfigJsonPath) || _internals79.existsSync(pesterPs1Path)) {
       return "pester";
     }
   } catch {}
@@ -58873,12 +59938,12 @@ async function detectTestFramework(cwd) {
   return "none";
 }
 function detectPhpTest(cwd) {
-  if (_internals78.existsSync(path85.join(cwd, "artisan")) && _internals78.existsSync(path85.join(cwd, "composer.json"))) {
+  if (_internals79.existsSync(path85.join(cwd, "artisan")) && _internals79.existsSync(path85.join(cwd, "composer.json"))) {
     return "php-artisan";
   }
-  if (_internals78.existsSync(path85.join(cwd, "Pest.php")))
+  if (_internals79.existsSync(path85.join(cwd, "Pest.php")))
     return "pest";
-  if (_internals78.existsSync(path85.join(cwd, "phpunit.xml")) || _internals78.existsSync(path85.join(cwd, "phpunit.xml.dist"))) {
+  if (_internals79.existsSync(path85.join(cwd, "phpunit.xml")) || _internals79.existsSync(path85.join(cwd, "phpunit.xml.dist"))) {
     return "phpunit";
   }
   return null;
@@ -59301,9 +60366,9 @@ function buildTestCommand(framework, scope, files, coverage, baseDir, bail, targ
       return args;
     }
     case "dart-test":
-      return _internals78.isCommandAvailable("flutter") ? ["flutter", "test", ...files] : ["dart", "test", ...files];
+      return _internals79.isCommandAvailable("flutter") ? ["flutter", "test", ...files] : ["dart", "test", ...files];
     case "rspec": {
-      const args = _internals78.isCommandAvailable("bundle") ? ["bundle", "exec", "rspec"] : ["rspec"];
+      const args = _internals79.isCommandAvailable("bundle") ? ["bundle", "exec", "rspec"] : ["rspec"];
       if (bail)
         args.push("--fail-fast");
       if (scope !== "all" && files.length > 0) {
@@ -59850,7 +60915,7 @@ async function runTests(framework, scope, files, coverage, timeout_ms, cwd, bail
         resolve30({ kind: "timeout" });
       }, timeout_ms);
     });
-    proc = _internals78.bunSpawn(command, {
+    proc = _internals79.bunSpawn(command, {
       stdin: "ignore",
       stdout: "pipe",
       stderr: "pipe",
@@ -60445,7 +61510,7 @@ var test_runner = createSwarmTool({
         return JSON.stringify(errorResult, null, 2);
       }
       try {
-        const impactResult = await _internals78.analyzeImpact(sourceFiles, workingDir, MAX_SAFE_TEST_FILES);
+        const impactResult = await _internals79.analyzeImpact(sourceFiles, workingDir, MAX_SAFE_TEST_FILES);
         if (impactResult.budgetExceeded) {
           const errorResult = {
             success: false,
@@ -60536,7 +61601,7 @@ var test_runner = createSwarmTool({
     return JSON.stringify(result, null, 2);
   }
 });
-var _internals78 = {
+var _internals79 = {
   analyzeImpact,
   loadImpactMap,
   isCommandAvailable,
@@ -60641,9 +61706,9 @@ function getVersionFileVersion(dir) {
 async function runVersionCheck(dir, _timeoutMs) {
   const startTime = Date.now();
   try {
-    const packageVersion = _internals79.getPackageVersion(dir);
-    const changelogVersion = _internals79.getChangelogVersion(dir);
-    const versionFileVersion = _internals79.getVersionFileVersion(dir);
+    const packageVersion = _internals80.getPackageVersion(dir);
+    const changelogVersion = _internals80.getChangelogVersion(dir);
+    const versionFileVersion = _internals80.getVersionFileVersion(dir);
     const versions = [];
     if (packageVersion)
       versions.push(`package.json: ${packageVersion}`);
@@ -60832,7 +61897,7 @@ async function runTestsCheck(_dir, scope, timeoutMs) {
 async function runSecretsCheck(dir, timeoutMs) {
   const startTime = Date.now();
   try {
-    const secretsPromise = _internals79.runSecretscan(dir);
+    const secretsPromise = _internals80.runSecretscan(dir);
     const timeoutPromise = new Promise((_, reject) => {
       setTimeout(() => {
         reject(new Error(`Secrets check timed out after ${timeoutMs}ms`));
@@ -61199,7 +62264,7 @@ async function runPreflight(dir, phase, config) {
   const reportId = `preflight-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
   let validatedDir;
   try {
-    validatedDir = _internals79.validateDirectoryPath(dir);
+    validatedDir = _internals80.validateDirectoryPath(dir);
   } catch (error2) {
     return {
       id: reportId,
@@ -61219,7 +62284,7 @@ async function runPreflight(dir, phase, config) {
   }
   let validatedTimeout;
   try {
-    validatedTimeout = _internals79.validateTimeout(config?.checkTimeoutMs, DEFAULT_CONFIG.checkTimeoutMs);
+    validatedTimeout = _internals80.validateTimeout(config?.checkTimeoutMs, DEFAULT_CONFIG.checkTimeoutMs);
   } catch (error2) {
     return {
       id: reportId,
@@ -61260,12 +62325,12 @@ async function runPreflight(dir, phase, config) {
   });
   const checks = [];
   log("[Preflight] Running lint check...");
-  const lintResult = await _internals79.runLintCheck(validatedDir, cfg.linter, cfg.checkTimeoutMs);
+  const lintResult = await _internals80.runLintCheck(validatedDir, cfg.linter, cfg.checkTimeoutMs);
   checks.push(lintResult);
   log(`[Preflight] Lint check: ${lintResult.status} ${lintResult.message}`);
   if (!cfg.skipTests) {
     log("[Preflight] Running tests check...");
-    const testsResult = await _internals79.runTestsCheck(validatedDir, cfg.testScope, cfg.checkTimeoutMs);
+    const testsResult = await _internals80.runTestsCheck(validatedDir, cfg.testScope, cfg.checkTimeoutMs);
     checks.push(testsResult);
     log(`[Preflight] Tests check: ${testsResult.status} ${testsResult.message}`);
   } else {
@@ -61277,7 +62342,7 @@ async function runPreflight(dir, phase, config) {
   }
   if (!cfg.skipSecrets) {
     log("[Preflight] Running secrets check...");
-    const secretsResult = await _internals79.runSecretsCheck(validatedDir, cfg.checkTimeoutMs);
+    const secretsResult = await _internals80.runSecretsCheck(validatedDir, cfg.checkTimeoutMs);
     checks.push(secretsResult);
     log(`[Preflight] Secrets check: ${secretsResult.status} ${secretsResult.message}`);
   } else {
@@ -61289,7 +62354,7 @@ async function runPreflight(dir, phase, config) {
   }
   if (!cfg.skipEvidence) {
     log("[Preflight] Running evidence check...");
-    const evidenceResult = await _internals79.runEvidenceCheck(validatedDir);
+    const evidenceResult = await _internals80.runEvidenceCheck(validatedDir);
     checks.push(evidenceResult);
     log(`[Preflight] Evidence check: ${evidenceResult.status} ${evidenceResult.message}`);
   } else {
@@ -61300,12 +62365,12 @@ async function runPreflight(dir, phase, config) {
     });
   }
   log("[Preflight] Running requirement coverage check...");
-  const reqCoverageResult = await _internals79.runRequirementCoverageCheck(validatedDir, phase);
+  const reqCoverageResult = await _internals80.runRequirementCoverageCheck(validatedDir, phase);
   checks.push(reqCoverageResult);
   log(`[Preflight] Requirement coverage check: ${reqCoverageResult.status} ${reqCoverageResult.message}`);
   if (!cfg.skipVersion) {
     log("[Preflight] Running version check...");
-    const versionResult = await _internals79.runVersionCheck(validatedDir, cfg.checkTimeoutMs);
+    const versionResult = await _internals80.runVersionCheck(validatedDir, cfg.checkTimeoutMs);
     checks.push(versionResult);
     log(`[Preflight] Version check: ${versionResult.status} ${versionResult.message}`);
   } else {
@@ -61368,10 +62433,10 @@ function formatPreflightMarkdown(report) {
 async function handlePreflightCommand(directory, _args) {
   const plan = await loadPlan(directory);
   const phase = plan?.current_phase ?? 1;
-  const report = await _internals79.runPreflight(directory, phase);
-  return _internals79.formatPreflightMarkdown(report);
+  const report = await _internals80.runPreflight(directory, phase);
+  return _internals80.formatPreflightMarkdown(report);
 }
-var _internals79 = {
+var _internals80 = {
   runPreflight,
   formatPreflightMarkdown,
   handlePreflightCommand,
@@ -62655,7 +63720,7 @@ function pruneOldResetBackups(backupsRoot, warnings) {
 }
 
 // src/commands/reset.ts
-var _internals80 = {
+var _internals81 = {
   backupSwarmStateBeforeReset
 };
 async function handleResetCommand(directory, args) {
@@ -62695,7 +63760,7 @@ async function handleResetCommand(directory, args) {
   ];
   const results = [];
   try {
-    const backup = _internals80.backupSwarmStateBeforeReset(directory, "reset", [
+    const backup = _internals81.backupSwarmStateBeforeReset(directory, "reset", [
       ...filesToReset,
       "summaries"
     ]);
@@ -62837,7 +63902,7 @@ function clearTrajectoryStep(sessionId) {
 }
 
 // src/commands/reset-session.ts
-var _internals81 = {
+var _internals82 = {
   cleanupOrphanedBranches,
   backupSwarmStateBeforeReset,
   recoverStaleCoderSettlements
@@ -62850,7 +63915,7 @@ function errorMessage(err) {
 async function handleResetSessionCommand(directory, _args) {
   const results = [];
   try {
-    const backup = _internals81.backupSwarmStateBeforeReset(directory, "reset-session", ["session"]);
+    const backup = _internals82.backupSwarmStateBeforeReset(directory, "reset-session", ["session"]);
     if (backup.backupDir && backup.copied.length > 0) {
       const rel = path89.relative(directory, backup.backupDir);
       results.push(`\uD83D\uDCE6 Backed up session state to ${rel}/ (restore by copying files back into .swarm/session/)`);
@@ -62912,7 +63977,7 @@ async function handleResetSessionCommand(directory, _args) {
   results.push(`\u2705 Cleared ${activeAgentCount} active-agent mapping(s)`);
   let preserveWorktrees = false;
   try {
-    const { results: settlementResults, truncated } = await _internals81.recoverStaleCoderSettlements(directory, {
+    const { results: settlementResults, truncated } = await _internals82.recoverStaleCoderSettlements(directory, {
       force: true
     });
     if (settlementResults.length === 0) {
@@ -62972,7 +64037,7 @@ async function handleResetSessionCommand(directory, _args) {
     results.push(`\u26A0\uFE0F Failed to remove .swarm-worktrees/: ${errorMessage(err)}`);
   }
   try {
-    const branchResult = await _internals81.cleanupOrphanedBranches(directory, []);
+    const branchResult = await _internals82.cleanupOrphanedBranches(directory, []);
     if (branchResult.removed.length > 0) {
       results.push(`\u2705 Removed ${branchResult.removed.length} orphan swarm-lane branch(es)`);
     }
@@ -63367,8 +64432,8 @@ async function runGit2(directory, args, options) {
   };
   let proc;
   try {
-    const gitExecutable = await _internals82.resolveGitExecutable();
-    proc = _internals82.bunSpawn([gitExecutable, "-c", "core.quotepath=false", ...args], spawnOptions);
+    const gitExecutable = await _internals83.resolveGitExecutable();
+    proc = _internals83.bunSpawn([gitExecutable, "-c", "core.quotepath=false", ...args], spawnOptions);
   } catch (error2) {
     return {
       ok: false,
@@ -63451,8 +64516,8 @@ function sameCanonicalDirectory(left, right) {
   if (samePath(left, right))
     return true;
   try {
-    const leftStat = _internals82.lstatBigIntSync(left);
-    const rightStat = _internals82.lstatBigIntSync(right);
+    const leftStat = _internals83.lstatBigIntSync(left);
+    const rightStat = _internals83.lstatBigIntSync(right);
     return leftStat.isDirectory() && rightStat.isDirectory() && !leftStat.isSymbolicLink() && !rightStat.isSymbolicLink() && (leftStat.dev !== 0n || leftStat.ino !== 0n) && sameFileIdentity(leftStat, rightStat);
   } catch {
     return false;
@@ -63557,18 +64622,18 @@ function hashWorkingTreeIdentity(root, rawPath, budget) {
     }
   });
   try {
-    if (_internals82.now() > budget.deadlineMs) {
+    if (_internals83.now() > budget.deadlineMs) {
       return deadlineExceeded("working-tree content identity deadline expired before file hashing started");
     }
-    const pathStat = _internals82.lstatBigIntSync(candidate);
+    const pathStat = _internals83.lstatBigIntSync(candidate);
     if (!pathStat.isFile() || pathStat.isSymbolicLink())
       return { identity: null };
-    const canonicalBeforeOpen = _internals82.realpathSync(candidate);
+    const canonicalBeforeOpen = _internals83.realpathSync(candidate);
     if (!isContained(root, canonicalBeforeOpen))
       return { identity: null };
-    handle = _internals82.openSync(canonicalBeforeOpen, "r");
-    const openedBeforeRead = _internals82.fstatBigIntSync(handle);
-    const canonicalAfterOpen = _internals82.realpathSync(candidate);
+    handle = _internals83.openSync(canonicalBeforeOpen, "r");
+    const openedBeforeRead = _internals83.fstatBigIntSync(handle);
+    const canonicalAfterOpen = _internals83.realpathSync(candidate);
     if (!openedBeforeRead.isFile() || !compareStats(pathStat, openedBeforeRead) || !samePath(canonicalBeforeOpen, canonicalAfterOpen) || !isContained(root, canonicalAfterOpen)) {
       return { identity: null };
     }
@@ -63586,17 +64651,17 @@ function hashWorkingTreeIdentity(root, rawPath, budget) {
     const buffer = Buffer.alloc(64 * 1024);
     let offset = 0;
     while (offset < fileBytes) {
-      if (_internals82.now() > budget.deadlineMs) {
+      if (_internals83.now() > budget.deadlineMs) {
         return deadlineExceeded("working-tree content identity deadline expired while hashing file content");
       }
-      const read = _internals82.readSync(handle, buffer, 0, Math.min(buffer.byteLength, fileBytes - offset), offset);
+      const read = _internals83.readSync(handle, buffer, 0, Math.min(buffer.byteLength, fileBytes - offset), offset);
       if (read === 0)
         break;
       hash2.update(buffer.subarray(0, read));
       offset += read;
     }
-    const openedAfterRead = _internals82.fstatBigIntSync(handle);
-    const canonicalAfterRead = _internals82.realpathSync(candidate);
+    const openedAfterRead = _internals83.fstatBigIntSync(handle);
+    const canonicalAfterRead = _internals83.realpathSync(candidate);
     if (!compareStats(openedBeforeRead, openedAfterRead) || !samePath(canonicalBeforeOpen, canonicalAfterRead) || !isContained(root, canonicalAfterRead) || offset !== fileBytes) {
       return { identity: null };
     }
@@ -63613,7 +64678,7 @@ function hashWorkingTreeIdentity(root, rawPath, budget) {
   } finally {
     if (handle !== undefined) {
       try {
-        _internals82.closeSync(handle);
+        _internals83.closeSync(handle);
       } catch {}
     }
   }
@@ -63625,7 +64690,7 @@ async function buildReviewManifest(root, selector, files, completeness, timeoutM
   const missingIdentityBindings = new Set;
   const workingTreeBudget = selector.kind === "range" ? undefined : {
     remainingBytes: WORKTREE_IDENTITY_TOTAL_BYTES,
-    deadlineMs: _internals82.now() + Math.min(timeoutMs, WORKTREE_IDENTITY_MAX_DURATION_MS)
+    deadlineMs: _internals83.now() + Math.min(timeoutMs, WORKTREE_IDENTITY_MAX_DURATION_MS)
   };
   const orderedScopes = [...files.values()].sort((left, right) => compareUtf8Bytes(left.newPath ?? left.oldPath ?? "", right.newPath ?? right.oldPath ?? ""));
   const oldTreeForSelector = selector.kind === "working-tree" ? revisionContext.headSha : selector.kind === "range" ? selector.operator === "..." ? revisionContext.mergeBase : revisionContext.baseSha : revisionContext.mergeBase;
@@ -63765,7 +64830,7 @@ function readSafeUntracked(root, rawPath, maxFileBytes) {
   }
   let handle;
   try {
-    const pathStat = _internals82.lstatBigIntSync(candidate);
+    const pathStat = _internals83.lstatBigIntSync(candidate);
     if (pathStat.isSymbolicLink()) {
       return {
         truncated: false,
@@ -63786,7 +64851,7 @@ function readSafeUntracked(root, rawPath, maxFileBytes) {
         }
       };
     }
-    const canonicalBeforeOpen = _internals82.realpathSync(candidate);
+    const canonicalBeforeOpen = _internals83.realpathSync(candidate);
     if (!isContained(root, canonicalBeforeOpen)) {
       return {
         truncated: false,
@@ -63797,9 +64862,9 @@ function readSafeUntracked(root, rawPath, maxFileBytes) {
         }
       };
     }
-    handle = _internals82.openSync(canonicalBeforeOpen, "r");
-    const openedBeforeRead = _internals82.fstatBigIntSync(handle);
-    const canonicalAfterOpen = _internals82.realpathSync(candidate);
+    handle = _internals83.openSync(canonicalBeforeOpen, "r");
+    const openedBeforeRead = _internals83.fstatBigIntSync(handle);
+    const canonicalAfterOpen = _internals83.realpathSync(candidate);
     if (!openedBeforeRead.isFile() || !sameFileSnapshot(pathStat, openedBeforeRead) || !samePath(canonicalBeforeOpen, canonicalAfterOpen) || !isContained(root, canonicalAfterOpen)) {
       return {
         truncated: false,
@@ -63814,13 +64879,13 @@ function readSafeUntracked(root, rawPath, maxFileBytes) {
     const bytes = Buffer.alloc(requested);
     let count = 0;
     while (count < requested) {
-      const read = _internals82.readSync(handle, bytes, count, requested - count, count);
+      const read = _internals83.readSync(handle, bytes, count, requested - count, count);
       if (read === 0)
         break;
       count += read;
     }
-    const openedAfterRead = _internals82.fstatBigIntSync(handle);
-    const canonicalAfterRead = _internals82.realpathSync(candidate);
+    const openedAfterRead = _internals83.fstatBigIntSync(handle);
+    const canonicalAfterRead = _internals83.realpathSync(candidate);
     if (!sameFileSnapshot(openedBeforeRead, openedAfterRead) || !samePath(canonicalBeforeOpen, canonicalAfterRead) || !isContained(root, canonicalAfterRead) || openedBeforeRead.size <= BigInt(maxFileBytes) && BigInt(count) !== openedBeforeRead.size) {
       return {
         truncated: false,
@@ -63872,7 +64937,7 @@ function readSafeUntracked(root, rawPath, maxFileBytes) {
   } finally {
     if (handle !== undefined) {
       try {
-        _internals82.closeSync(handle);
+        _internals83.closeSync(handle);
       } catch {}
     }
   }
@@ -63910,7 +64975,7 @@ async function collectReviewDiff(options) {
   const maxUntrackedFileBytes = boundedPositiveInteger(options.maxUntrackedFileBytes, DEFAULT_MAX_UNTRACKED_FILE_BYTES, MAX_UNTRACKED_FILE_BYTES);
   let root;
   try {
-    root = _internals82.realpathSync(options.directory);
+    root = _internals83.realpathSync(options.directory);
   } catch (error2) {
     return {
       status: "error",
@@ -63933,7 +64998,7 @@ async function collectReviewDiff(options) {
   }
   let gitRoot;
   try {
-    gitRoot = _internals82.realpathSync(topLevel.stdout.trim());
+    gitRoot = _internals83.realpathSync(topLevel.stdout.trim());
   } catch {
     return {
       status: "error",
@@ -64234,7 +65299,7 @@ async function collectReviewDiff(options) {
   const clean = canonicalText.trim().length === 0 && untrackedCount === 0 && skipReasons.length === 0;
   return { status: clean ? "clean" : "ok", ...scope };
 }
-var _internals82 = {
+var _internals83 = {
   bunSpawn,
   realpathSync: fs41.realpathSync,
   lstatBigIntSync: (path92) => fs41.lstatSync(path92, { bigint: true }),
@@ -64296,7 +65361,7 @@ function resolveReceiptsDir(directory) {
 function resolveReceiptIndexPath(directory) {
   return path92.join(resolveReceiptsDir(directory), "index.json");
 }
-var _internals83 = {
+var _internals84 = {
   openSync: fs42.openSync,
   lstatBigIntSync: (path93) => fs42.lstatSync(path93, { bigint: true }),
   fstatBigIntSync: (fd) => fs42.fstatSync(fd, { bigint: true })
@@ -64308,7 +65373,7 @@ function pathsEqual(left, right) {
 }
 function captureCanonicalDirectory(directory, label, expected) {
   const resolved = path92.resolve(directory);
-  const stat9 = _internals83.lstatBigIntSync(resolved);
+  const stat9 = _internals84.lstatBigIntSync(resolved);
   if (!stat9.isDirectory() || stat9.isSymbolicLink()) {
     throw new Error(`${label} must be a real directory`);
   }
@@ -64394,7 +65459,7 @@ function assertDirectReceiptFile(context, filePath, mustExist) {
     throw new Error("review receipt file escapes its expected directory");
   }
   try {
-    const stat9 = _internals83.lstatBigIntSync(resolved);
+    const stat9 = _internals84.lstatBigIntSync(resolved);
     if (!stat9.isFile() || stat9.isSymbolicLink()) {
       throw new Error("review receipt path must be a real file");
     }
@@ -64418,7 +65483,7 @@ function readReviewReceiptText(directory, receiptPath, maxBytes = 1048576) {
     const resolved = assertDirectReceiptFile(context, receiptPath, true);
     if (path92.extname(resolved) !== ".json")
       return null;
-    const pathBeforeOpen = _internals83.lstatBigIntSync(resolved);
+    const pathBeforeOpen = _internals84.lstatBigIntSync(resolved);
     if (!pathBeforeOpen.isFile() || pathBeforeOpen.isSymbolicLink() || pathBeforeOpen.size < 0n || pathBeforeOpen.size > BigInt(maxBytes)) {
       return null;
     }
@@ -64426,10 +65491,10 @@ function readReviewReceiptText(directory, receiptPath, maxBytes = 1048576) {
     if (!pathsEqual(canonicalBeforeOpen, resolved))
       return null;
     assertReceiptContextCurrent(context);
-    descriptor = _internals83.openSync(canonicalBeforeOpen, "r");
-    const openedBeforeRead = _internals83.fstatBigIntSync(descriptor);
+    descriptor = _internals84.openSync(canonicalBeforeOpen, "r");
+    const openedBeforeRead = _internals84.fstatBigIntSync(descriptor);
     assertReceiptContextCurrent(context);
-    const pathAfterOpen = _internals83.lstatBigIntSync(resolved);
+    const pathAfterOpen = _internals84.lstatBigIntSync(resolved);
     const canonicalAfterOpen = fs42.realpathSync(resolved);
     if (!openedBeforeRead.isFile() || openedBeforeRead.size < 0n || openedBeforeRead.size > BigInt(maxBytes) || !sameFileSnapshot2(pathBeforeOpen, openedBeforeRead) || !sameFileSnapshot2(openedBeforeRead, pathAfterOpen) || !pathsEqual(canonicalBeforeOpen, canonicalAfterOpen)) {
       return null;
@@ -64442,9 +65507,9 @@ function readReviewReceiptText(directory, receiptPath, maxBytes = 1048576) {
         break;
       bytesRead += count;
     }
-    const openedAfterRead = _internals83.fstatBigIntSync(descriptor);
+    const openedAfterRead = _internals84.fstatBigIntSync(descriptor);
     assertReceiptContextCurrent(context);
-    const pathAfterRead = _internals83.lstatBigIntSync(resolved);
+    const pathAfterRead = _internals84.lstatBigIntSync(resolved);
     const canonicalAfterRead = fs42.realpathSync(resolved);
     if (bytesRead !== buffer.length || !sameFileSnapshot2(openedBeforeRead, openedAfterRead) || !sameFileSnapshot2(openedAfterRead, pathAfterRead) || !pathsEqual(canonicalBeforeOpen, canonicalAfterRead)) {
       return null;
@@ -64997,7 +66062,7 @@ var RETRYABLE_CAPTURE_FAILURE_CODES = new Set([
 ]);
 var REVIEWER_SCOPE_CAPTURE_CHUNK_BYTES = 262144;
 var REVIEWER_SCOPE_CAPTURE_BATCH_DEADLINE_MS = 1e4;
-var _internals84 = {
+var _internals85 = {
   open: fs43.openSync,
   fstat: (fd, options) => fs43.fstatSync(fd, options),
   read: fs43.readSync,
@@ -65034,7 +66099,7 @@ function deletedPathIsContained(canonicalRoot, absolute) {
   let current = path93.dirname(absolute);
   for (;; ) {
     try {
-      const canonical = _internals84.realpathSync(current);
+      const canonical = _internals85.realpathSync(current);
       return canonicalRoot === canonical || isWithinRoot2(canonicalRoot, canonical);
     } catch (error2) {
       if (error2.code !== "ENOENT")
@@ -65080,7 +66145,7 @@ function captureReviewerScopeFileFingerprint(directory, file, options = {}) {
   let canonicalParent;
   const absolute = path93.resolve(directory, normalized);
   try {
-    canonicalRoot = _internals84.realpathSync(path93.resolve(directory));
+    canonicalRoot = _internals85.realpathSync(path93.resolve(directory));
   } catch {
     return {
       kind: "capture_failed",
@@ -65090,13 +66155,13 @@ function captureReviewerScopeFileFingerprint(directory, file, options = {}) {
     };
   }
   try {
-    canonicalParent = _internals84.realpathSync(path93.dirname(absolute));
+    canonicalParent = _internals85.realpathSync(path93.dirname(absolute));
   } catch (error2) {
     if (error2.code === "ENOENT") {
       let secondObservation = null;
       let secondFailed = false;
       try {
-        secondObservation = _internals84.realpathSync(path93.dirname(absolute));
+        secondObservation = _internals85.realpathSync(path93.dirname(absolute));
       } catch (secondError) {
         if (secondError.code !== "ENOENT") {
           return {
@@ -65113,7 +66178,7 @@ function captureReviewerScopeFileFingerprint(directory, file, options = {}) {
         canonicalParent = secondObservation;
       } else {
         try {
-          _internals84.lstat(absolute);
+          _internals85.lstat(absolute);
           return {
             kind: "capture_failed",
             file: normalized,
@@ -65159,7 +66224,7 @@ function captureReviewerScopeFileFingerprint(directory, file, options = {}) {
   }
   let before;
   try {
-    before = _internals84.lstat(absolute);
+    before = _internals85.lstat(absolute);
   } catch (error2) {
     if (error2.code === "ENOENT") {
       return deletedPathIsContained(canonicalRoot, absolute) ? { kind: "captured_deleted", file: normalized } : {
@@ -65186,7 +66251,7 @@ function captureReviewerScopeFileFingerprint(directory, file, options = {}) {
     };
   }
   try {
-    const canonicalTarget = _internals84.realpathSync(absolute);
+    const canonicalTarget = _internals85.realpathSync(absolute);
     if (!isWithinRoot2(canonicalRoot, canonicalTarget) || path93.dirname(canonicalTarget) !== canonicalParent) {
       return {
         kind: "capture_failed",
@@ -65214,7 +66279,7 @@ function captureReviewerScopeFileFingerprint(directory, file, options = {}) {
   const openFlags = fs43.constants.O_RDONLY | (process.platform === "win32" ? 0 : fs43.constants.O_NOFOLLOW);
   let beforeBigInt;
   try {
-    beforeBigInt = _internals84.lstat(absolute, {
+    beforeBigInt = _internals85.lstat(absolute, {
       bigint: true
     });
   } catch {
@@ -65227,7 +66292,7 @@ function captureReviewerScopeFileFingerprint(directory, file, options = {}) {
   }
   let fd;
   try {
-    fd = _internals84.open(absolute, openFlags);
+    fd = _internals85.open(absolute, openFlags);
   } catch (error2) {
     const code = error2.code;
     if (code === "ENOENT" || code === "ELOOP") {
@@ -65257,7 +66322,7 @@ function captureReviewerScopeFileFingerprint(directory, file, options = {}) {
     };
   }
   try {
-    const openedBefore = _internals84.fstat(fd, { bigint: true });
+    const openedBefore = _internals85.fstat(fd, { bigint: true });
     if (!openedBefore.isFile()) {
       return {
         kind: "capture_failed",
@@ -65278,7 +66343,7 @@ function captureReviewerScopeFileFingerprint(directory, file, options = {}) {
     const chunk = Buffer.alloc(REVIEWER_SCOPE_CAPTURE_CHUNK_BYTES);
     let totalBytes = 0;
     for (;; ) {
-      if (options.deadlineAt !== undefined && _internals84.now() > options.deadlineAt) {
+      if (options.deadlineAt !== undefined && _internals85.now() > options.deadlineAt) {
         return {
           kind: "capture_failed",
           file: normalized,
@@ -65288,7 +66353,7 @@ function captureReviewerScopeFileFingerprint(directory, file, options = {}) {
       }
       let bytesRead;
       try {
-        bytesRead = _internals84.read(fd, chunk, 0, chunk.byteLength, null);
+        bytesRead = _internals85.read(fd, chunk, 0, chunk.byteLength, null);
       } catch (error2) {
         const code = error2.code;
         return {
@@ -65304,7 +66369,7 @@ function captureReviewerScopeFileFingerprint(directory, file, options = {}) {
       totalBytes += bytesRead;
       hash2.update(bytesRead === chunk.byteLength ? chunk : chunk.subarray(0, bytesRead));
     }
-    const openedAfter = _internals84.fstat(fd, { bigint: true });
+    const openedAfter = _internals85.fstat(fd, { bigint: true });
     if (!sameSnapshot(openedBefore, openedAfter)) {
       return {
         kind: "capture_failed",
@@ -65323,7 +66388,7 @@ function captureReviewerScopeFileFingerprint(directory, file, options = {}) {
     }
     let pathAfter;
     try {
-      pathAfter = _internals84.stat(absolute, { bigint: true });
+      pathAfter = _internals85.stat(absolute, { bigint: true });
     } catch {
       return {
         kind: "capture_failed",
@@ -65342,7 +66407,7 @@ function captureReviewerScopeFileFingerprint(directory, file, options = {}) {
     }
     let canonicalAfterRead;
     try {
-      canonicalAfterRead = _internals84.realpathSync(absolute);
+      canonicalAfterRead = _internals85.realpathSync(absolute);
     } catch {
       return {
         kind: "capture_failed",
@@ -65368,7 +66433,7 @@ function captureReviewerScopeFileFingerprint(directory, file, options = {}) {
   } finally {
     if (fd !== undefined) {
       try {
-        _internals84.close(fd);
+        _internals85.close(fd);
       } catch {}
     }
   }
@@ -65400,7 +66465,7 @@ var HEAD_OUTPUT_BYTES = 256;
 var HEAD_SHA_PATTERN = /^[0-9a-f]{40,64}$/i;
 var REVIEWER_TASK_SCOPE_DESCRIPTION = "reviewer-task-files-v2";
 var REVIEWER_TASK_SCOPE_HEADER = "opencode-swarm-reviewer-task-scope-v2";
-var _internals85 = {
+var _internals86 = {
   spawn: child_process6.spawn,
   realpath: fs44.promises.realpath,
   resolveGitExecutable
@@ -65427,7 +66492,7 @@ async function resolveHeadSha(directory) {
   let child;
   let timeoutHandle;
   try {
-    child = _internals85.spawn(_internals85.resolveGitExecutable(), ["rev-parse", "--verify", "HEAD"], {
+    child = _internals86.spawn(_internals86.resolveGitExecutable(), ["rev-parse", "--verify", "HEAD"], {
       cwd: directory,
       stdio: ["ignore", "pipe", "ignore"],
       timeout: HEAD_TIMEOUT_MS,
@@ -65511,7 +66576,7 @@ async function buildReviewerTaskScope(directory, modifiedFiles, maxBytes = DEFAU
   let realRoot;
   try {
     lexicalRoot = path94.resolve(directory);
-    realRoot = await _internals85.realpath(lexicalRoot);
+    realRoot = await _internals86.realpath(lexicalRoot);
   } catch {
     return { ok: false, code: "workspace_unresolvable", retryable: false };
   }
@@ -65784,7 +66849,7 @@ function parseReviewerOutput(text, options = {}) {
     outputMode: "legacy"
   };
 }
-var _internals86 = {
+var _internals87 = {
   delegationBegin: telemetry.delegationBegin,
   delegationEnd: telemetry.delegationEnd,
   resolveReviewerTaskScope,
@@ -66084,7 +67149,7 @@ function scopeFreshnessMismatches(reviewed, current) {
 }
 function createScopeVerifier(input, reviewed, maxBytes) {
   return async () => {
-    const current = await _internals87.collectReviewDiff({
+    const current = await _internals88.collectReviewDiff({
       directory: input.directory,
       selector: input.selector,
       maxBytes
@@ -66093,7 +67158,7 @@ function createScopeVerifier(input, reviewed, maxBytes) {
   };
 }
 async function stalePersistenceResult(input, maxBytes, message, modelCalls) {
-  const current = await _internals87.collectReviewDiff({
+  const current = await _internals88.collectReviewDiff({
     directory: input.directory,
     selector: input.selector,
     maxBytes
@@ -66481,7 +67546,7 @@ async function persistErrorResult(input, diff, result, error2, dispatches, promp
   evidence2.review.error = error2;
   addCost(evidence2, dispatches);
   try {
-    result.evidencePath = await _internals87.persistEvidence(input.directory, evidence2);
+    result.evidencePath = await _internals88.persistEvidence(input.directory, evidence2);
   } catch {
     if (input.config.final_review.mode === "gate") {
       result.blocked = true;
@@ -66498,7 +67563,7 @@ async function runReviewEngine(input) {
   const gateMode = input.config.final_review.mode === "gate";
   const maxBytes = input.trigger === "task_completion" ? input.config.max_diff_kb * 1024 : input.config.final_review.max_diff_bytes;
   const timeoutMs = input.trigger === "task_completion" ? input.config.timeout_ms : input.config.final_review.timeout_ms;
-  const diff = await _internals87.collectReviewDiff({
+  const diff = await _internals88.collectReviewDiff({
     directory: input.directory,
     selector: input.selector,
     maxBytes
@@ -66514,7 +67579,7 @@ async function runReviewEngine(input) {
     evidence3.policy.digest = evidence3.scope.manifest.review_policy_digest;
     let evidencePath2;
     try {
-      evidencePath2 = await _internals87.persistEvidence(input.directory, evidence3, { verifyCurrent: createScopeVerifier(input, diff, maxBytes) });
+      evidencePath2 = await _internals88.persistEvidence(input.directory, evidence3, { verifyCurrent: createScopeVerifier(input, diff, maxBytes) });
     } catch (error2) {
       if (error2 instanceof ReviewScopeStaleError) {
         return stalePersistenceResult(input, maxBytes, "Review scope changed before clean evidence could be committed.", 0);
@@ -66538,7 +67603,7 @@ async function runReviewEngine(input) {
   });
   const reviewManifest = await materializeAutoReviewManifest(input.directory, diff.manifest, input.config);
   if (input.phase !== undefined && (input.trigger === "phase_completion" || input.trigger === "plan_completion")) {
-    const existing = _internals87.readPhaseEvidence(input.directory, input.phase);
+    const existing = _internals88.readPhaseEvidence(input.directory, input.phase);
     const integrity = existing ? validateAutoReviewEvidenceIntegrity(input.directory, existing, {
       scopeHash: diff.scopeHash,
       phase: input.phase,
@@ -66666,7 +67731,7 @@ async function runReviewEngine(input) {
       validation: byId.get(finding.finding_id)
     }));
   }
-  const currentScope = await _internals87.collectReviewDiff({
+  const currentScope = await _internals88.collectReviewDiff({
     directory: input.directory,
     selector: input.selector,
     maxBytes
@@ -66747,7 +67812,7 @@ async function runReviewEngine(input) {
       findingValidations: findings.map((finding) => finding.validation).filter((item) => Boolean(item))
     });
     receiptId = receipt.id;
-    receiptPath = await _internals87.persistReceipt(input.directory, receipt, {
+    receiptPath = await _internals88.persistReceipt(input.directory, receipt, {
       verifyCurrent: createScopeVerifier(input, diff, maxBytes)
     });
     evidence2.receipt_path = receiptPath;
@@ -66777,7 +67842,7 @@ async function runReviewEngine(input) {
   }
   let evidencePath;
   try {
-    evidencePath = await _internals87.persistEvidence(input.directory, evidence2, {
+    evidencePath = await _internals88.persistEvidence(input.directory, evidence2, {
       verifyCurrent: createScopeVerifier(input, diff, maxBytes)
     });
   } catch (error2) {
@@ -66815,7 +67880,7 @@ async function runReviewEngine(input) {
   input.injectAdvisory?.(input.sessionID, advisoryMessage(input, result));
   return result;
 }
-var _internals87 = {
+var _internals88 = {
   collectReviewDiff,
   persistEvidence: persistAutoReviewEvidence,
   persistReceipt: persistReviewReceipt,
@@ -67086,7 +68151,7 @@ async function handleReviewCommand(ctx) {
   } catch (error2) {
     return `Review configuration error: ${error2 instanceof Error ? error2.message : String(error2)}`;
   }
-  const result = await _internals88.runReviewEngine({
+  const result = await _internals89.runReviewEngine({
     directory: ctx.directory,
     sessionID: ctx.sessionID,
     trigger: "manual",
@@ -67100,10 +68165,10 @@ async function handleReviewCommand(ctx) {
     validatorModel,
     validatorFallbackModels
   });
-  const evidence2 = _internals88.readEvidence(result.evidencePath, ctx.directory);
+  const evidence2 = _internals89.readEvidence(result.evidencePath, ctx.directory);
   return parsed.json ? renderJson(result, evidence2, parsed.selector) : renderHuman(result, evidence2, parsed.selector);
 }
-var _internals88 = {
+var _internals89 = {
   runReviewEngine,
   readEvidence
 };
@@ -67345,7 +68410,7 @@ async function handleRollbackCommand(directory, args) {
 // src/commands/sdd.ts
 import * as fs49 from "fs";
 import * as path99 from "path";
-var _internals89 = {
+var _internals90 = {
   writeProjectedSpecSync
 };
 var SWARM_SPEC_REL = path99.join(".swarm", "spec.md");
@@ -67745,7 +68810,7 @@ ${USAGE13}`;
 
 ${USAGE13}`;
     }
-    const result2 = _internals89.writeProjectedSpecSync(directory, {
+    const result2 = _internals90.writeProjectedSpecSync(directory, {
       source: "speckit",
       feature: resolution.feature,
       dryRun: parsed.dryRun,
@@ -67803,7 +68868,7 @@ ${formatList(result2.projection.warnings)}` : ""
     ].join(`
 `);
   }
-  const result = _internals89.writeProjectedSpecSync(directory, {
+  const result = _internals90.writeProjectedSpecSync(directory, {
     changeId: parsed.changeId,
     dryRun: parsed.dryRun,
     overwrite: parsed.overwrite
@@ -68030,7 +69095,7 @@ function writeFileFsyncedThenRename(tempPath, targetPath, data) {
     throw err;
   }
 }
-var _internals90 = {
+var _internals91 = {
   withEvidenceLock,
   writeFileFsyncedThenRename,
   writeFileSync: writeFileSyncAsync,
@@ -68049,7 +69114,7 @@ async function appendEvent2(directory, eventInput) {
     throw new Error(`invalid candidate id: ${eventInput.candidateId}`);
   }
   const filePath = ledgerPath(directory, eventInput.skillSlug, eventInput.candidateId);
-  return _internals90.withEvidenceLock(directory, path100.join(".swarm", "evolution", "skills", eventInput.skillSlug, eventInput.candidateId, "lifecycle.jsonl"), "skill-opt-ledger", "append-skill-opt-event", async () => {
+  return _internals91.withEvidenceLock(directory, path100.join(".swarm", "evolution", "skills", eventInput.skillSlug, eventInput.candidateId, "lifecycle.jsonl"), "skill-opt-ledger", "append-skill-opt-event", async () => {
     ensureCandidateDir(directory, eventInput.skillSlug, eventInput.candidateId);
     const existing = existsSync56(filePath) ? readFileSync42(filePath, "utf8") : "";
     const events = parseEventsFromText(existing);
@@ -68081,8 +69146,8 @@ async function appendEvent2(directory, eventInput) {
     const validContent = events.map((e) => JSON.stringify(e)).join(`
 `) + (events.length > 0 ? `
 ` : "");
-    _internals90.writeFileFsyncedThenRename(tempPath, filePath, validContent + line);
-    const verify = parseEventsFromText(_internals90.readFileSync(filePath, "utf8"));
+    _internals91.writeFileFsyncedThenRename(tempPath, filePath, validContent + line);
+    const verify = parseEventsFromText(_internals91.readFileSync(filePath, "utf8"));
     const last = verify.length > 0 ? verify[verify.length - 1] : null;
     if (!last || last.seq !== event.seq || last.hashAfter !== event.hashAfter) {
       throw new Error(`skill-opt ledger append verification failed for candidate ${event.candidateId} seq ${event.seq}`);
@@ -68186,7 +69251,7 @@ function writeStateProjection(directory, skillSlug, candidateId2, replay) {
     updatedAt: new Date().toISOString()
   };
   const tempPath = `${target}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
-  _internals90.writeFileFsyncedThenRename(tempPath, target, `${JSON.stringify(projection, null, 2)}
+  _internals91.writeFileFsyncedThenRename(tempPath, target, `${JSON.stringify(projection, null, 2)}
 `);
 }
 function writeArtifact(directory, skillSlug, candidateId2, fileName, content) {
@@ -68194,7 +69259,7 @@ function writeArtifact(directory, skillSlug, candidateId2, fileName, content) {
   const dir = ensureCandidateDir(directory, skillSlug, candidateId2);
   const target = path100.join(dir, fileName);
   const tempPath = `${target}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
-  _internals90.writeFileFsyncedThenRename(tempPath, target, content);
+  _internals91.writeFileFsyncedThenRename(tempPath, target, content);
   return target;
 }
 function readArtifact(directory, skillSlug, candidateId2, fileName) {
@@ -68287,16 +69352,16 @@ function currentCandidateState(directory, skillSlug, candidateId2) {
 function writeSkillFileAtomic(targetPath, content) {
   const tempPath = `${targetPath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
   try {
-    _internals91.writeFileSync(tempPath, content, "utf8");
-    _internals91.renameSync(tempPath, targetPath);
+    _internals92.writeFileSync(tempPath, content, "utf8");
+    _internals92.renameSync(tempPath, targetPath);
   } finally {
     try {
       if (existsSync57(tempPath))
-        _internals91.unlinkSync(tempPath);
+        _internals92.unlinkSync(tempPath);
     } catch {}
   }
 }
-var _internals91 = {
+var _internals92 = {
   writeFileSync: writeFileSync18,
   renameSync: renameSync16,
   unlinkSync: unlinkSync21
@@ -68753,7 +69818,7 @@ function buildGeneratorInputs(args) {
     }
   };
 }
-var _internals92 = {
+var _internals93 = {
   draftDeterministic: defaultDeterministicDraft
 };
 function defaultDeterministicDraft(inputs) {
@@ -68823,7 +69888,7 @@ function countChangedLines(a, b) {
   return changed;
 }
 function draftCandidate(inputs) {
-  const candidate2 = _internals92.draftDeterministic(inputs);
+  const candidate2 = _internals93.draftDeterministic(inputs);
   enforceTrustRegion(candidate2, inputs.budget);
   return candidate2;
 }
@@ -68866,7 +69931,7 @@ import * as path103 from "path";
 // src/hooks/spawn-helper.ts
 import * as child_process7 from "child_process";
 var WIN32_CMD_BINARIES = new Set(["npm", "npx", "pnpm", "yarn"]);
-var _internals93 = {
+var _internals94 = {
   spawn: child_process7.spawn
 };
 function spawnAsync(command, cwd, timeoutMs) {
@@ -68874,7 +69939,7 @@ function spawnAsync(command, cwd, timeoutMs) {
     try {
       const [rawCmd, ...args] = command;
       const cmd = process.platform === "win32" && WIN32_CMD_BINARIES.has(rawCmd) && !rawCmd.includes(".") ? `${rawCmd}.cmd` : rawCmd;
-      const proc = _internals93.spawn(cmd, args, {
+      const proc = _internals94.spawn(cmd, args, {
         cwd,
         stdio: ["ignore", "pipe", "pipe"]
       });
@@ -68940,7 +70005,7 @@ function spawnAsync(command, cwd, timeoutMs) {
 }
 
 // src/services/skill-optimizer/smoke.ts
-var _internals94 = {
+var _internals95 = {
   validateSkillPath,
   isSymbolicLink: (p) => {
     try {
@@ -68961,7 +70026,7 @@ var _internals94 = {
 async function validateSkillSmoke(input) {
   const notes = [];
   const repoRel = path103.join(".opencode", "skills", "generated", input.skillSlug, "SKILL.md");
-  if (!_internals94.validateSkillPath(repoRel)) {
+  if (!_internals95.validateSkillPath(repoRel)) {
     return {
       ok: false,
       verdict: "VIOLATED",
@@ -68970,16 +70035,16 @@ async function validateSkillSmoke(input) {
   }
   const skillRoot = path103.join(input.directory, ".opencode", "skills", "generated", input.skillSlug);
   if (existsSync58(skillRoot)) {
-    if (_internals94.isSymbolicLink(skillRoot)) {
+    if (_internals95.isSymbolicLink(skillRoot)) {
       return {
         ok: false,
         verdict: "VIOLATED",
         notes: ["skill root is a symlink (reparse denied)"]
       };
     }
-    const realRoot = _internals94.realpath(skillRoot);
-    const realProjectDir = _internals94.realpath(input.directory);
-    if (_internals94.escapedRoot(realProjectDir, realRoot)) {
+    const realRoot = _internals95.realpath(skillRoot);
+    const realProjectDir = _internals95.realpath(input.directory);
+    if (_internals95.escapedRoot(realProjectDir, realRoot)) {
       return {
         ok: false,
         verdict: "VIOLATED",
@@ -68997,7 +70062,7 @@ async function validateSkillSmoke(input) {
       notes: [`frontmatter: ${fmError}`]
     };
   }
-  const rejected = await _internals94.isRejectedSkillContent(input.directory, input.skillSlug, input.candidateContent);
+  const rejected = await _internals95.isRejectedSkillContent(input.directory, input.skillSlug, input.candidateContent);
   if (rejected) {
     return {
       ok: false,
@@ -69007,7 +70072,7 @@ async function validateSkillSmoke(input) {
       ]
     };
   }
-  const evalResult = await _internals94.evaluateSkillChange({
+  const evalResult = await _internals95.evaluateSkillChange({
     directory: input.directory,
     slug: input.skillSlug,
     candidateContent: input.candidateContent,
@@ -69026,7 +70091,7 @@ async function validateSkillSmoke(input) {
     notes.push(`phrase-eval passed (score ${evalResult.candidateScore.toFixed(2)})`);
   }
   if (input.checkCommand && input.checkCommand.length > 0) {
-    const cmdResult = await _internals94.spawnAsync(input.checkCommand, input.directory, input.checkTimeoutMs ?? 60000);
+    const cmdResult = await _internals95.spawnAsync(input.checkCommand, input.directory, input.checkTimeoutMs ?? 60000);
     if (!cmdResult || cmdResult.exitCode !== 0) {
       return {
         ok: false,
@@ -69096,7 +70161,7 @@ async function prepareCandidatePayloads(inputRoot, candidateId2, skillSlug, base
   candidate2.contentHash = await computeCandidateInputContentHash2(inputRoot, candidate2);
   return { baseline, candidate: candidate2 };
 }
-var _internals95 = {
+var _internals96 = {
   tryAcquireLock,
   emitTelemetry: emit,
   evaluateCandidateV1,
@@ -69104,7 +70169,7 @@ var _internals95 = {
 };
 async function acquireProjectLock(directory) {
   assertProjectRoot(directory);
-  const result = await _internals95.tryAcquireLock(directory, PROJECT_LOCK_PATH, "skill-opt-controller", "project-run");
+  const result = await _internals96.tryAcquireLock(directory, PROJECT_LOCK_PATH, "skill-opt-controller", "project-run");
   if (!result.acquired)
     return null;
   return async () => {
@@ -69118,7 +70183,7 @@ async function acquireProjectLock(directory) {
 async function acquireSkillLock(directory, skillSlug) {
   assertProjectRoot(directory);
   const lockPath = path104.join(".swarm", "evolution", "skills", skillSlug, ".skill.lock");
-  const result = await _internals95.tryAcquireLock(directory, lockPath, "skill-opt-controller", `skill-${skillSlug}`);
+  const result = await _internals96.tryAcquireLock(directory, lockPath, "skill-opt-controller", `skill-${skillSlug}`);
   if (!result.acquired)
     return null;
   return async () => {
@@ -69315,13 +70380,13 @@ async function runValidationWithTransientRetry(input, candidateContent, baseline
   while (true) {
     try {
       const evalInputRoot = input.inputRoot ?? input.directory;
-      const { baseline, candidate: candidate2 } = await _internals95.prepareCandidatePayloads(evalInputRoot, candidateId2, input.skillSlug, input.baselineModel, input.candidateModel, baselineContent, candidateContent);
+      const { baseline, candidate: candidate2 } = await _internals96.prepareCandidatePayloads(evalInputRoot, candidateId2, input.skillSlug, input.baselineModel, input.candidateModel, baselineContent, candidateContent);
       if (!input.dispatcher) {
         throw new Error("no evaluation dispatcher available (cannot run validation)");
       }
-      const { createModelEvaluationExecutor: createModelEvaluationExecutor2 } = await import("./runner-9mnkfjw7.js");
+      const { createModelEvaluationExecutor: createModelEvaluationExecutor2 } = await import("./runner-1aygs98c.js");
       const executor = createModelEvaluationExecutor2(input.dispatcher, input.sessionId);
-      const result = await _internals95.evaluateCandidateV1({
+      const result = await _internals96.evaluateCandidateV1({
         projectRoot: input.directory,
         inputRoot: input.inputRoot ?? input.directory,
         tasks: input.validationTasks,
@@ -69379,7 +70444,7 @@ async function runValidationWithTransientRetry(input, candidateContent, baseline
           deadband: input.config.deadband
         };
       }
-      _internals95.emitTelemetry?.("loop_detected", {
+      _internals96.emitTelemetry?.("loop_detected", {
         skillSlug: input.skillSlug,
         reason: message.slice(0, 160),
         source: "skill-opt-controller"
@@ -70228,7 +71293,7 @@ function getCompactionMetrics(sessionId) {
 }
 
 // src/services/status-service.ts
-var _internals96 = {
+var _internals97 = {
   loadLeanTurboRunState,
   hasActiveLeanTurbo,
   hasActiveFullAuto,
@@ -70502,11 +71567,11 @@ async function getStatusData(directory, agents, sessionId, options) {
   } catch {
     status.memoryCohort = { linked: false };
   }
-  status.fullAutoActive = _internals96.hasActiveFullAuto();
+  status.fullAutoActive = _internals97.hasActiveFullAuto();
   if (status.fullAutoActive) {
-    const sid = _internals96.getActiveFullAutoSessionID();
+    const sid = _internals97.getActiveFullAutoSessionID();
     if (sid) {
-      const runState = _internals96.loadFullAutoRunState(directory, sid);
+      const runState = _internals97.loadFullAutoRunState(directory, sid);
       if (runState?.lastEscalation) {
         status.fullAutoEscalation = {
           reason: runState.lastEscalation.reason,
@@ -70540,7 +71605,7 @@ async function getStatusData(directory, agents, sessionId, options) {
 }
 function enrichWithLeanTurbo(status, directory) {
   const turboMode = hasActiveTurboMode();
-  const leanActive = _internals96.hasActiveLeanTurbo();
+  const leanActive = _internals97.hasActiveLeanTurbo();
   let turboStrategy = "off";
   if (leanActive) {
     turboStrategy = "lean";
@@ -70571,7 +71636,7 @@ function enrichWithLeanTurbo(status, directory) {
     }
   }
   if (leanSessionID) {
-    const runState = _internals96.loadLeanTurboRunState(directory, leanSessionID);
+    const runState = _internals97.loadLeanTurboRunState(directory, leanSessionID);
     if (runState) {
       status.leanTurboPhase = runState.phase;
       status.leanMaxParallelCoders = runState.maxParallelCoders;
@@ -70931,7 +71996,7 @@ init_logger();
 var TURBO_BYPASS_DISCLOSURE = "Bypassed: Stage B (reviewer + test_engineer) for Tier 0-2 tasks; phase_complete Gates 1-5 " + "(completion-verify, drift-verifier, hallucination-guard, mutation-gate, phase-council). " + "Still enforced: Stage A (lint, imports, pre_check_batch); Tier 3 Stage B; Gate 5b " + "(architecture-supervisor); Gate 6 (final-council); Gate 7 (full-auto).";
 
 // src/commands/turbo.ts
-var _internals97 = {
+var _internals98 = {
   loadPluginConfigWithMeta
 };
 async function handleTurboCommand(directory, args, sessionID) {
@@ -70991,7 +72056,7 @@ async function handleTurboCommand(directory, args, sessionID) {
   if (arg0 === "on") {
     let strategy = "standard";
     try {
-      const { config } = _internals97.loadPluginConfigWithMeta(directory);
+      const { config } = _internals98.loadPluginConfigWithMeta(directory);
       if (config.turbo?.strategy === "lean") {
         strategy = "lean";
       }
@@ -71088,7 +72153,7 @@ function enableLeanTurbo(session, directory, sessionID) {
   let maxParallelCoders = 4;
   let conflictPolicy = "serialize";
   try {
-    const { config } = _internals97.loadPluginConfigWithMeta(directory);
+    const { config } = _internals98.loadPluginConfigWithMeta(directory);
     const leanConfig = config.turbo?.lean;
     if (leanConfig) {
       maxParallelCoders = leanConfig.max_parallel_coders ?? 4;
@@ -71296,7 +72361,7 @@ function findSimilarCommands(query) {
   }
   const scored = VALID_COMMANDS.map((cmd) => {
     const cmdLower = cmd.toLowerCase();
-    const fullScore = _internals98.levenshteinDistance(q, cmdLower);
+    const fullScore = _internals99.levenshteinDistance(q, cmdLower);
     let tokenScore = Infinity;
     if (cmd.includes(" ") || cmd.includes("-")) {
       const qTokens = q.split(/[\s-]+/);
@@ -71309,7 +72374,7 @@ function findSimilarCommands(query) {
         for (const ct of cmdTokens) {
           if (ct.length === 0)
             continue;
-          const dist = _internals98.levenshteinDistance(qt, ct);
+          const dist = _internals99.levenshteinDistance(qt, ct);
           if (dist < minDist)
             minDist = dist;
         }
@@ -71319,7 +72384,7 @@ function findSimilarCommands(query) {
     }
     const dashStrippedQ = q.replace(/-/g, "");
     const dashStrippedCmd = cmdLower.replace(/-/g, "");
-    const dashScore = _internals98.levenshteinDistance(dashStrippedQ, dashStrippedCmd);
+    const dashScore = _internals99.levenshteinDistance(dashStrippedQ, dashStrippedCmd);
     const score = Math.min(fullScore, tokenScore, dashScore);
     return { cmd, score };
   });
@@ -71354,16 +72419,16 @@ function buildDetailedHelp(commandName, entry) {
 async function handleHelpCommand(ctx) {
   const targetCommand = ctx.args.join(" ");
   if (!targetCommand) {
-    const { buildHelpText } = await import("./index-ka2vav7t.js");
+    const { buildHelpText } = await import("./index-8cn6545x.js");
     return buildHelpText();
   }
   const tokens = targetCommand.split(/\s+/);
-  const resolved = _internals98.resolveCommand(tokens);
+  const resolved = _internals99.resolveCommand(tokens);
   if (resolved) {
-    return _internals98.buildDetailedHelp(resolved.key, resolved.entry);
+    return _internals99.buildDetailedHelp(resolved.key, resolved.entry);
   }
-  const similar = _internals98.findSimilarCommands(targetCommand);
-  const { buildHelpText: fullHelp } = await import("./index-ka2vav7t.js");
+  const similar = _internals99.findSimilarCommands(targetCommand);
+  const { buildHelpText: fullHelp } = await import("./index-8cn6545x.js");
   if (similar.length > 0) {
     return `Command '/swarm ${targetCommand}' not found.
 
@@ -71474,7 +72539,7 @@ var COMMAND_REGISTRY = {
     toolNoArgs: true
   },
   help: {
-    handler: (ctx) => _internals98.handleHelpCommand(ctx),
+    handler: (ctx) => _internals99.handleHelpCommand(ctx),
     description: "Show help for swarm commands",
     category: "core",
     args: "[command]",
@@ -71543,7 +72608,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-nynjhbzk.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-1zbk21fq.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -71553,7 +72618,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail reset": {
     handler: async (ctx) => {
-      const { handleGuardrailReset } = await import("./guardrail-reset-hsfd5ykq.js");
+      const { handleGuardrailReset } = await import("./guardrail-reset-wb3ba243.js");
       return handleGuardrailReset(ctx.args, ctx.sessionID);
     },
     description: "Reset one exact active invocation/action circuit after repair",
@@ -71562,7 +72627,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-nynjhbzk.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-1zbk21fq.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -71572,7 +72637,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-reset": {
     handler: async (ctx) => {
-      const { handleGuardrailReset } = await import("./guardrail-reset-hsfd5ykq.js");
+      const { handleGuardrailReset } = await import("./guardrail-reset-wb3ba243.js");
       return handleGuardrailReset(ctx.args, ctx.sessionID);
     },
     description: "Reset one exact active invocation/action circuit after repair",
@@ -71582,7 +72647,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-log": {
     handler: async (ctx) => {
-      const { handleGuardrailLog } = await import("./guardrail-log-6bktj08e.js");
+      const { handleGuardrailLog } = await import("./guardrail-log-d20jewtr.js");
       return handleGuardrailLog(ctx.directory, ctx.args);
     },
     description: "Read the guardrail decision log (use --blocks-only for blocks)",
@@ -72588,7 +73653,7 @@ function validateToolPolicy() {
   }
   return { valid: warnings.length === 0, warnings };
 }
-var _internals98 = {
+var _internals99 = {
   handleHelpCommand,
   validateAliases,
   validateToolPolicy,
@@ -72598,16 +73663,16 @@ var _internals98 = {
   findSimilarCommands,
   buildDetailedHelp
 };
-var validation = _internals98.validateAliases();
+var validation = _internals99.validateAliases();
 if (!validation.valid) {
   throw new Error(`COMMAND_REGISTRY alias validation failed:
 ${validation.errors.join(`
 `)}`);
 }
-_internals98.emitValidationWarnings("COMMAND_REGISTRY alias warnings", validation.warnings);
+_internals99.emitValidationWarnings("COMMAND_REGISTRY alias warnings", validation.warnings);
 try {
-  const toolPolicyValidation = _internals98.validateToolPolicy();
-  _internals98.emitValidationWarnings("COMMAND_REGISTRY toolPolicy warnings", toolPolicyValidation.warnings);
+  const toolPolicyValidation = _internals99.validateToolPolicy();
+  _internals99.emitValidationWarnings("COMMAND_REGISTRY toolPolicy warnings", toolPolicyValidation.warnings);
 } catch (e) {
   warn(`COMMAND_REGISTRY toolPolicy validation failed (non-fatal): ${e.message}`);
 }
@@ -73516,6 +74581,7 @@ HARD CONSTRAINTS (apply regardless of skill load success):
 - Treat the controller Git-state result as final for the attempt: \`clean\` proceeds; \`stashable\` permits one preparation call; \`recovery-required\` or \`indeterminate\` means report the typed \`required_action\`, abort/clear any already-active gate, and STOP unless \`retryable: true\`. Never loop on stash against an unmerged index or in-progress Git operation.
 - RUN ALL BASE LANES: the default PR_REVIEW path covers all six repository-agnostic base dimensions from the skill on every PR. Use \`mode: "swarm-pr-review:base"\`, the exact \`workflow_lane\` identifiers, and the exact bound \`pr_head_sha\`. With the default \`pr_review_resilience\` policy enabled, depth tier M/L MUST stage attempt 0 as one singleton \`pr_review_wave_stage: "canary"\` batch followed by a \`"fanout"\` batch whose combined canary+fanout ownership partitions all six dimensions exactly once; tier L still requires six singleton combined lanes, and tier S keeps the legacy one-wave path. If a project disables \`pr_review_resilience\`, stay on the legacy one-wave base dispatch. The runtime rejects omitted stage metadata, partial, duplicate, mislabelled, or structurally invalid waves.
 - RETRY STRUCTURALLY: retry only unresolved failed base obligations in later \`swarm-pr-review:base\` async batches with the same exact \`pr_head_sha\`. Under staged resilience, attempts are numbered by \`pr_review_wave_attempt\`: attempt 0 plus at most two retry attempts (1 and 2), each with one singleton canary batch and then its matching fanout batch when obligations remain. Blocking \`dispatch_lanes\` and direct Task explorer/reviewer/critic dispatch are not provenance-equivalent and are rejected. If the runtime returns typed \`retry_exhausted\` or \`circuit_open\`, or if the second retry still cannot close coverage, collect every lane to settlement, do not probe downstream writers or micro lanes, call \`abort_pr_workflow\` with \`mode: "PR_REVIEW"\`, \`kind: "recovery"\`, and a non-empty one-line \`reason\` naming the failed lane or correlated failure and exhausted retries, then call \`prepare_pr_workflow_checkout\` with \`operation: "restore"\` before reporting the blocker.
+- RECOVER CONTRACT FAILURES EXPLICITLY: when collection reports \`workflow_lane_failure_class: "contract"\`, retry that one singleton base dimension once with \`pr_review_contract_retry: true\`; this retry is outside staged \`pr_review_wave_attempt\` accounting and cannot be combined with stage metadata. If exactly five base dimensions settle successfully and one dimension remains terminally failed with a typed \`contract\`, \`resource\`, or \`deadline\` class, the \`post_explorer\` findings write may explicitly submit \`partial_base_coverage: { missing_dimension: "<exact lane>" }\`. Never infer or omit this disclosure: the runtime verifies five-of-six, persists an immutable coverage receipt, and rejects any other partial shape.
 - USE ASYNC DISPATCH WITHOUT IDLING: each admissible base wave uses one \`dispatch_lanes_async\` call. With enabled tier-M/L staged resilience, this means one singleton canary call followed by one unresolved-only fanout call after canary admission; it never means one legacy call carrying the whole initial base wave. Record each \`batch_id\`, then keep doing non-dependent architect work while its lanes run. Poll with \`collect_lane_results\` without \`wait\` (or \`wait: false\`) to process settled lanes and continue independent work between polls; use \`wait: true\` only as the final join when no independent work remains.
 - EVALUATE ALL RISK FAMILIES: after the base explorer lanes settle, evaluate every repository-agnostic trigger row against the exact diff/context pack. Record applicable families as \`MATCHED\` and inapplicable families as provenance-free \`NOT_TRIGGERED\` with concrete absence evidence; \`unclassified-risk\` always remains \`MATCHED\`. Launch \`swarm-pr-review:micro\` lanes only for the \`MATCHED\` IDs. The first micro dispatch MUST pass the complete exact eleven-row \`trigger_evaluation\`, which freezes it for this session; any subsequent same-session micro batch may omit it and reuse the frozen ledger, while an explicitly supplied copy must remain exactly identical. Use each dispatched trigger ID as \`workflow_lane\`. Missing an evaluation row or a matched-family attestation is BLOCKED; a \`NOT_TRIGGERED\` family must not create a micro artifact.
 - RUN HEAD-BOUND VALIDATION: dispatch independent reviewers with \`mode: "swarm-pr-review:reviewer"\` and critics with \`mode: "swarm-pr-review:critic"\`, unique \`workflow_lane\` obligations, role-correct agents, and the same exact \`pr_head_sha\`. Critic dispatch is blocked until all declared reviewer obligations have successful artifacts.
@@ -74987,7 +76053,7 @@ function formatCommandNotFound(tokens) {
   const attemptedCommand = tokens[0] || "";
   const MAX_DISPLAY = 100;
   const displayCommand = attemptedCommand.length > MAX_DISPLAY ? `${attemptedCommand.slice(0, MAX_DISPLAY)}...` : attemptedCommand;
-  const similar = _internals98.findSimilarCommands(attemptedCommand);
+  const similar = _internals99.findSimilarCommands(attemptedCommand);
   const header = `Command \`/swarm ${displayCommand}\` not found.`;
   const suggestions = similar.length > 0 ? `Did you mean:
 ${similar.map((cmd) => `  - /swarm ${cmd}`).join(`
@@ -78007,7 +79073,7 @@ function getDisplayBudget() {
 async function rehydratePrSubscriptions(sessionID, directory) {
   const map = new Map;
   try {
-    const { listActive: listActive2 } = await import("./pr-subscriptions-cpnwvc6y.js");
+    const { listActive: listActive2 } = await import("./pr-subscriptions-q862pvz1.js");
     const records = await listActive2(directory);
     for (const record of records) {
       if (record.sessionID !== sessionID)
@@ -78320,8 +79386,8 @@ var WORKTREE_LIST_TIMEOUT_MS = 15000;
 async function preProvisionCollisionCheck(taskId, directory, _sessionId) {
   let proc;
   try {
-    proc = _internals100.bunSpawn([
-      _internals100.resolveGitExecutable(),
+    proc = _internals101.bunSpawn([
+      _internals101.resolveGitExecutable(),
       "-C",
       directory,
       "worktree",
@@ -78423,7 +79489,7 @@ function isLaneOwnedByCurrentSession(branchName, expectedSessionId) {
   return extracted === expectedSessionId;
 }
 async function inspectStandardWorktreeCollisionOwnership(identity) {
-  const collisionOwnership = await import("./worktree-collision-ownership-r8j31h06.js");
+  const collisionOwnership = await import("./worktree-collision-ownership-9v8e0dz7.js");
   return collisionOwnership.inspectStandardWorktreeCollisionOwnership(identity);
 }
 async function precreateStandardWorktreeSession(args) {
@@ -78450,12 +79516,12 @@ async function precreateStandardWorktreeSession(args) {
     return;
   }
   const laneIndex = allocateStandardLaneIndex(args.parentSessionID);
-  const lifecycleLock = await _internals100.tryAcquireWorktreeLifecycleLock(args.directory, WORKTREE_LIFECYCLE_LOCK_FILE, "worktree-provisioning", args.taskId);
+  const lifecycleLock = await _internals101.tryAcquireWorktreeLifecycleLock(args.directory, WORKTREE_LIFECYCLE_LOCK_FILE, "worktree-provisioning", args.taskId);
   if (!lifecycleLock.acquired) {
     hardStopStandardWorktreeLifecycle(args.parentSessionID, "STANDARD_WORKTREE_LIFECYCLE_BUSY: init orphan recovery is active; retry this coder dispatch after recovery completes.");
   }
   try {
-    const collision = await _internals100.preProvisionCollisionCheck(args.taskId, args.directory, args.parentSessionID);
+    const collision = await _internals101.preProvisionCollisionCheck(args.taskId, args.directory, args.parentSessionID);
     if (collision.uncertainty) {
       hardStopStandardWorktreeLifecycle(args.parentSessionID, `STANDARD_WORKTREE_COLLISION_SCAN_UNCERTAIN: ${collision.uncertainty}. Destructive cleanup and provisioning were blocked.`);
     }
@@ -78464,17 +79530,17 @@ async function precreateStandardWorktreeSession(args) {
         const ownerInfo = collision.ownerSessionId ? ` owned by session ${collision.ownerSessionId}` : " with uncertain ownership";
         hardStopStandardWorktreeLifecycle(args.parentSessionID, `PREPROVISION_COLLISION: task ${args.taskId} already has a lane on branch ${collision.existingBranch ?? "unknown"}${ownerInfo}; cleanup and provisioning were blocked.`);
       }
-      for (const dispatch of _internals100.standardWorktreeByCallID.values()) {
+      for (const dispatch of _internals101.standardWorktreeByCallID.values()) {
         if (dispatch.handle.branchName === collision.existingBranch) {
           hardStopStandardWorktreeLifecycle(args.parentSessionID, `PREPROVISION_COLLISION_ACTIVE: branch ${collision.existingBranch} is still tracked by an active standard-worktree dispatch.`);
         }
       }
-      for (const record of _internals100.awaitingMergeByCallID.values()) {
+      for (const record of _internals101.awaitingMergeByCallID.values()) {
         if (record.branch === collision.existingBranch) {
           hardStopStandardWorktreeLifecycle(args.parentSessionID, `PREPROVISION_COLLISION_AWAITING_MERGE: branch ${collision.existingBranch} is still awaiting merge-back.`);
         }
       }
-      const ownership = await _internals100.inspectStandardWorktreeCollisionOwnership({
+      const ownership = await _internals101.inspectStandardWorktreeCollisionOwnership({
         directory: args.directory,
         parentSessionId: args.parentSessionID,
         taskId: args.taskId,
@@ -78499,30 +79565,30 @@ async function precreateStandardWorktreeSession(args) {
         }
       }
       if (collisionPathExists) {
-        const preserveResult = await _internals100.preserveDirtyWorktreeAtPath(collision.worktreePath, collision.existingBranch, "denied", args.directory, worktreeConfig.worktree_dir);
+        const preserveResult = await _internals101.preserveDirtyWorktreeAtPath(collision.worktreePath, collision.existingBranch, "denied", args.directory, worktreeConfig.worktree_dir);
         if (preserveResult.outcome === "preserve-failed") {
           hardStopStandardWorktreeLifecycle(args.parentSessionID, `STANDARD_WORKTREE_PRESERVATION_FAILED_ABORT_CLEANUP: pre-provision collision for task ${args.taskId} could not be preserved (${preserveResult.error}). Cleanup and provisioning were blocked.`);
         }
-        const removeResult = await _internals100.removeWorktree(collision.worktreePath, args.directory, { force: true, worktreeDir: worktreeConfig.worktree_dir });
+        const removeResult = await _internals101.removeWorktree(collision.worktreePath, args.directory, { force: true, worktreeDir: worktreeConfig.worktree_dir });
         if ("error" in removeResult) {
           hardStopStandardWorktreeLifecycle(args.parentSessionID, `STANDARD_WORKTREE_COLLISION_REMOVE_FAILED: ${removeResult.error}. Provisioning was blocked.`);
         }
-        const cleanupResult = await _internals100.postMergeCleanup(args.directory, collision.existingBranch);
+        const cleanupResult = await _internals101.postMergeCleanup(args.directory, collision.existingBranch);
         if ("error" in cleanupResult) {
           hardStopStandardWorktreeLifecycle(args.parentSessionID, `STANDARD_WORKTREE_COLLISION_BRANCH_CLEANUP_FAILED: ${cleanupResult.error}. Provisioning was blocked.`);
         }
       } else {
-        const pruneResult = await _internals100.pruneStaleWorktreeMetadata(args.directory);
+        const pruneResult = await _internals101.pruneStaleWorktreeMetadata(args.directory);
         if ("error" in pruneResult) {
           hardStopStandardWorktreeLifecycle(args.parentSessionID, `STANDARD_WORKTREE_COLLISION_PRUNE_FAILED: ${pruneResult.error}. Provisioning was blocked without deleting the lane branch.`);
         }
       }
-      const verification = await _internals100.preProvisionCollisionCheck(args.taskId, args.directory, args.parentSessionID);
+      const verification = await _internals101.preProvisionCollisionCheck(args.taskId, args.directory, args.parentSessionID);
       if (verification.uncertainty || verification.collision) {
         hardStopStandardWorktreeLifecycle(args.parentSessionID, `STANDARD_WORKTREE_COLLISION_CLEANUP_UNVERIFIED: ${verification.uncertainty ?? "git still reports the colliding lane after cleanup"}. Provisioning was blocked.`);
       }
     }
-    _internals100.recordWorktreeProvisioningOwner(args.directory, {
+    _internals101.recordWorktreeProvisioningOwner(args.directory, {
       callID: args.callID,
       parentSessionId: args.parentSessionID,
       worktreeSessionId: args.parentSessionID,
@@ -78540,7 +79606,7 @@ async function precreateStandardWorktreeSession(args) {
   }
   let provisionResult;
   try {
-    provisionResult = await _internals100.provisionWorktree(args.directory, args.taskId, args.parentSessionID, {
+    provisionResult = await _internals101.provisionWorktree(args.directory, args.taskId, args.parentSessionID, {
       purpose: "lane",
       worktreeDir: worktreeConfig.worktree_dir,
       mergeStrategy: worktreeConfig.merge_strategy,
@@ -78548,11 +79614,11 @@ async function precreateStandardWorktreeSession(args) {
       scope: args.scope
     });
   } catch (error2) {
-    _internals100.removeWorktreeProvisioningOwner(args.directory, args.callID);
+    _internals101.removeWorktreeProvisioningOwner(args.directory, args.callID);
     throw error2;
   }
   if ("error" in provisionResult) {
-    _internals100.removeWorktreeProvisioningOwner(args.directory, args.callID);
+    _internals101.removeWorktreeProvisioningOwner(args.directory, args.callID);
     const message = `STANDARD_WORKTREE_PROVISION_FAILED: ${provisionResult.error}.`;
     handleStandardWorktreeFailure(args.parentSessionID, worktreeConfig.policy, message);
     return;
@@ -78571,7 +79637,7 @@ async function precreateStandardWorktreeSession(args) {
   const laneProfile = computeLaneRuntimeProfile(worktreeConfig.runtime_isolation, laneIndex, provisionResult.worktreePath);
   if (laneProfile) {
     try {
-      const { writeLaneProfileToDiskReal } = await import("./core-0v762txd.js");
+      const { writeLaneProfileToDiskReal } = await import("./core-xx0x5tfv.js");
       await writeLaneProfileToDiskReal(provisionResult.worktreePath, laneProfile.laneIndex, laneProfile.envOverrides);
     } catch {}
   }
@@ -78592,13 +79658,13 @@ async function precreateStandardWorktreeSession(args) {
     query: { directory: provisionResult.worktreePath }
   });
   if (!createResult.data?.id) {
-    await _internals100.removeWorktree(provisionResult.worktreePath, args.directory, {
+    await _internals101.removeWorktree(provisionResult.worktreePath, args.directory, {
       force: true,
       worktreeDir: worktreeConfig.worktree_dir
     }).catch((cleanupError) => {
       log(`[worktree-isolation] session-create failure cleanup could not remove lane ${provisionResult.worktreePath}: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
     });
-    _internals100.removeWorktreeProvisioningOwner(args.directory, args.callID);
+    _internals101.removeWorktreeProvisioningOwner(args.directory, args.callID);
     const createError = createResult.error;
     const detail = typeof createError === "string" ? createError : JSON.stringify(createError ?? "missing session id");
     const message = `STANDARD_WORKTREE_SESSION_CREATE_FAILED: ${detail}.`;
@@ -78626,8 +79692,8 @@ async function preserveBackgroundWorktreeOwnershipForCallId(callID) {
     return { outcome: "not-found" };
   let refProc;
   try {
-    refProc = _internals100.bunSpawn([
-      _internals100.resolveGitExecutable(),
+    refProc = _internals101.bunSpawn([
+      _internals101.resolveGitExecutable(),
       "-C",
       dispatch.handle.worktreePath,
       "rev-parse",
@@ -78671,8 +79737,8 @@ async function preserveBackgroundWorktreeOwnershipForCallId(callID) {
   const tag = `swarm-preserved-owner/${session}/${lane}/${callDigest}`;
   let tagProc;
   try {
-    tagProc = _internals100.bunSpawn([
-      _internals100.resolveGitExecutable(),
+    tagProc = _internals101.bunSpawn([
+      _internals101.resolveGitExecutable(),
       "-C",
       dispatch.handle.worktreePath,
       "tag",
@@ -78722,8 +79788,8 @@ async function preserveDirtyWorktreeForCallId(callID, reason, _directory, _workt
   }
   let statusProc;
   try {
-    statusProc = _internals100.bunSpawn([
-      _internals100.resolveGitExecutable(),
+    statusProc = _internals101.bunSpawn([
+      _internals101.resolveGitExecutable(),
       "-C",
       worktreePath,
       "status",
@@ -78765,7 +79831,7 @@ async function preserveDirtyWorktreeForCallId(callID, reason, _directory, _workt
   }
   let addProc;
   try {
-    addProc = _internals100.bunSpawn([_internals100.resolveGitExecutable(), "-C", worktreePath, "add", "-A"], {
+    addProc = _internals101.bunSpawn([_internals101.resolveGitExecutable(), "-C", worktreePath, "add", "-A"], {
       stdin: "ignore",
       stdout: "pipe",
       stderr: "pipe",
@@ -78799,8 +79865,8 @@ async function preserveDirtyWorktreeForCallId(callID, reason, _directory, _workt
   const commitMessage = `swarm-preserved: ${reason} for callID ${sanitizedCallID} at ${isoDate}`;
   let commitProc;
   try {
-    commitProc = _internals100.bunSpawn([
-      _internals100.resolveGitExecutable(),
+    commitProc = _internals101.bunSpawn([
+      _internals101.resolveGitExecutable(),
       "-C",
       worktreePath,
       "commit",
@@ -78838,8 +79904,8 @@ async function preserveDirtyWorktreeForCallId(callID, reason, _directory, _workt
   }
   let hashProc;
   try {
-    hashProc = _internals100.bunSpawn([
-      _internals100.resolveGitExecutable(),
+    hashProc = _internals101.bunSpawn([
+      _internals101.resolveGitExecutable(),
       "-C",
       worktreePath,
       "rev-parse",
@@ -78885,7 +79951,7 @@ async function preserveDirtyWorktreeForCallId(callID, reason, _directory, _workt
   const tagName = `swarm-preserved-${sanitizedCallID}-${shortHash}`;
   let tagProc;
   try {
-    tagProc = _internals100.bunSpawn([_internals100.resolveGitExecutable(), "-C", worktreePath, "tag", tagName], {
+    tagProc = _internals101.bunSpawn([_internals101.resolveGitExecutable(), "-C", worktreePath, "tag", tagName], {
       stdin: "ignore",
       stdout: "pipe",
       stderr: "pipe",
@@ -78921,8 +79987,8 @@ async function preserveDirtyWorktreeForCallId(callID, reason, _directory, _workt
 async function preserveDirtyWorktreeAtPath(worktreePath, branchName, reason, _directory, _worktree_dir) {
   let statusProc;
   try {
-    statusProc = _internals100.bunSpawn([
-      _internals100.resolveGitExecutable(),
+    statusProc = _internals101.bunSpawn([
+      _internals101.resolveGitExecutable(),
       "-C",
       worktreePath,
       "status",
@@ -78964,7 +80030,7 @@ async function preserveDirtyWorktreeAtPath(worktreePath, branchName, reason, _di
   }
   let addProc;
   try {
-    addProc = _internals100.bunSpawn([_internals100.resolveGitExecutable(), "-C", worktreePath, "add", "-A"], {
+    addProc = _internals101.bunSpawn([_internals101.resolveGitExecutable(), "-C", worktreePath, "add", "-A"], {
       stdin: "ignore",
       stdout: "pipe",
       stderr: "pipe",
@@ -78999,8 +80065,8 @@ async function preserveDirtyWorktreeAtPath(worktreePath, branchName, reason, _di
   const commitMessage = `swarm-preserved: ${reason} for worktree ${sanitizedPath} at ${isoDate}`;
   let commitProc;
   try {
-    commitProc = _internals100.bunSpawn([
-      _internals100.resolveGitExecutable(),
+    commitProc = _internals101.bunSpawn([
+      _internals101.resolveGitExecutable(),
       "-C",
       worktreePath,
       "commit",
@@ -79038,8 +80104,8 @@ async function preserveDirtyWorktreeAtPath(worktreePath, branchName, reason, _di
   }
   let hashProc;
   try {
-    hashProc = _internals100.bunSpawn([
-      _internals100.resolveGitExecutable(),
+    hashProc = _internals101.bunSpawn([
+      _internals101.resolveGitExecutable(),
       "-C",
       worktreePath,
       "rev-parse",
@@ -79085,7 +80151,7 @@ async function preserveDirtyWorktreeAtPath(worktreePath, branchName, reason, _di
   const tagName = `swarm-preserved-worktree-${sanitizedBranch}-${shortHash}`;
   let tagProc;
   try {
-    tagProc = _internals100.bunSpawn([_internals100.resolveGitExecutable(), "-C", worktreePath, "tag", tagName], {
+    tagProc = _internals101.bunSpawn([_internals101.resolveGitExecutable(), "-C", worktreePath, "tag", tagName], {
       stdin: "ignore",
       stdout: "pipe",
       stderr: "pipe",
@@ -79137,7 +80203,7 @@ async function cleanupStandardWorktreeForCallId(callID, reason, directory, workt
   let preserveResult;
   if (reason === "denied" || reason === "cancelled") {
     try {
-      preserveResult = await _internals100.preserveDirtyWorktreeForCallId(callID, reason, directory, worktree_dir);
+      preserveResult = await _internals101.preserveDirtyWorktreeForCallId(callID, reason, directory, worktree_dir);
     } catch (err) {
       log(`[swarm] cleanupStandardWorktreeForCallId: preserveDirtyWorktreeForCallId threw for ${callID}: ${err}`);
       preserveResult = {
@@ -79148,7 +80214,7 @@ async function cleanupStandardWorktreeForCallId(callID, reason, directory, workt
     }
     if (preserveResult.outcome === "clean") {
       try {
-        preserveResult = await _internals100.preserveDirtyWorktreeForCallId(callID, reason, directory, worktree_dir);
+        preserveResult = await _internals101.preserveDirtyWorktreeForCallId(callID, reason, directory, worktree_dir);
       } catch (err) {
         log(`[swarm] cleanupStandardWorktreeForCallId: final preservation check threw for ${callID}: ${err}`);
         preserveResult = {
@@ -79166,11 +80232,11 @@ async function cleanupStandardWorktreeForCallId(callID, reason, directory, workt
     pushAdvisory(session2, `STANDARD_WORKTREE_PRESERVATION_FAILED_ABORT_CLEANUP: dispatch ${callID} has dirty uncommitted work but preservation failed (${preserveResult.error}). Cleanup aborted to protect uncommitted work. Investigate and resolve manually. Worktree=${worktreePath}; branch=${branchName}.`);
     return;
   }
-  await _internals100.removeWorktree(worktreePath, directory, {
+  await _internals101.removeWorktree(worktreePath, directory, {
     force: true,
     worktreeDir: worktree_dir
   }).catch((err) => log(`[swarm] cleanupStandardWorktreeForCallId: removeWorktree failed for ${callID}: ${err}`));
-  await _internals100.postMergeCleanup(directory, branchName).catch((err) => log(`[swarm] cleanupStandardWorktreeForCallId: postMergeCleanup failed for ${callID}: ${err}`));
+  await _internals101.postMergeCleanup(directory, branchName).catch((err) => log(`[swarm] cleanupStandardWorktreeForCallId: postMergeCleanup failed for ${callID}: ${err}`));
   standardWorktreeByCallID.delete(callID);
   awaitingMergeByCallID.delete(callID);
   const session = ensureAgentSession(parentSessionID);
@@ -79189,7 +80255,7 @@ async function finishStandardWorktreeDispatch(directory, dispatch, config, callI
   const wtConfig = config ? resolveWorktreeIsolationConfig(config) : DEFAULT_WORKTREE_ISOLATION_CONFIG;
   const resolvedCallID = callID ?? dispatch.callID;
   const run = async () => {
-    const mergeResult = await _internals100.attemptMergeBackFromDirty(dispatch.handle.worktreePath, dispatch.handle.branchName, directory, getMergeStrategy({ merge_strategy: dispatch.mergeStrategy }), {
+    const mergeResult = await _internals101.attemptMergeBackFromDirty(dispatch.handle.worktreePath, dispatch.handle.branchName, directory, getMergeStrategy({ merge_strategy: dispatch.mergeStrategy }), {
       operationId: settlement.operationId,
       resume: settlement.resume,
       onBeforeMerge: settlement.onBeforeMerge
@@ -79229,7 +80295,7 @@ async function finishStandardWorktreeDispatch(directory, dispatch, config, callI
       }
       clearWorktreeMergeStatus(statusKey);
       try {
-        const { removeLaneProfileFromDiskReal } = await import("./core-0v762txd.js");
+        const { removeLaneProfileFromDiskReal } = await import("./core-xx0x5tfv.js");
         await removeLaneProfileFromDiskReal(dispatch.handle.worktreePath, dispatch.laneIndex);
       } catch {}
       const state = serializationStateBySessionID.get(dispatch.parentSessionID);
@@ -79347,7 +80413,7 @@ async function readLaneEnvFileFromDisk(worktreePath, laneIndex) {
   }
   return result;
 }
-var _internals100 = {
+var _internals101 = {
   provisionWorktree,
   removeWorktree,
   attemptMergeBackFromDirty,
@@ -79375,4 +80441,4 @@ var _internals100 = {
   resolveGitExecutable
 };
 
-export { resetActionCircuitExternally, getBlockingActionCircuit, parseLeanLaneIndex, computeLaneRuntimeProfile, MAX_TRACKED_STANDARD_WORKTREE_CALLS, awaitingMergeByCallID, standardWorktreeByCallID, standardWorktreeSerializationSessions, getStandardWorktreeDegradationReason, resetStandardWorktreeIsolationState, checkStandardWorktreeSerializationRelease, sanitizeWorktreeTaskId, preProvisionCollisionCheck, isLaneOwnedByCurrentSession, precreateStandardWorktreeSession, preserveBackgroundWorktreeOwnershipForCallId, preserveDirtyWorktreeForCallId, preserveDirtyWorktreeAtPath, cleanupStandardWorktreeForCallId, abortStandardWorktreeDispatch, finishStandardWorktreeDispatch, readLaneEnvFileFromDisk, _internals100 as _internals, dcNormalizeCommand, dcUnwrapWrappers, dcSplitSegments, dcExtractRecursiveRmTargets, dcEvaluateRecursiveDeleteTargets, dcCheckJunctionCreation, dcExtractWindowsCmdTargets, dcExtractPowerShellTargets, normalizeSwarmCommandInput, canonicalCommandKey, formatCommandNotFound, executeSwarmCommand, SWARM_COMMAND_TOOL_COMMANDS, SWARM_COMMAND_TOOL_ALLOWLIST, HUMAN_ONLY_SWARM_COMMANDS, classifySwarmCommandToolUse, classifySwarmCommandChatFallbackUse, detectPosixWrites, detectWindowsWrites, resolveWriteTargets, getAgentSession, handleAcknowledgeSpecDriftCommand, handleAgentsCommand, handleAnalyzeCommand, handleArchiveCommand, handleAutoProceedCommand, handleBenchmarkCommand, handleBrainstormCommand, handleCheckpointCommand, handleCiSimulateCommand, handleClarifyCommand, createCuratorLLMDelegate, _internals25 as _internals1, normalizeRecommendationEntryIdToken, parseKnowledgeRecommendations, parseKnowledgeRecommendationsWithDiagnostics, parseStructuredCuratorBlocks, readCuratorSummary, writeCuratorSummary, appendCuratorRecommendation, mergeCuratorPhaseSummary, filterPhaseEvents, checkPhaseCompliance, runCuratorInit, runCuratorPhase, applyCuratorKnowledgeUpdates, isHiveEligible, countDistinctProjects, checkHivePromotions, _internals29 as _internals2, createHivePromoterHook, promoteToHive, promoteFromSwarm, handleCloseCommand, handleCodebaseReviewCommand, handleConcurrencyCommand, handleConfigCommand, handleConsolidateCommand, handleCostsCommand, handleCouncilCommand, handleCurateCommand, handleDarkMatterCommand, handleDeepDiveCommand, handleDeepResearchCommand, getPluginConfigDir, getPluginCachePaths, getPluginLockFilePaths, VERSION_PINNED_LEAF, discoverVersionPinnedCachePaths, readCachePackageVersion, handleDiagnoseCommand, handleDoctorCommand, handleEvidenceCommand, handleEvidenceSummaryCommand, handleExportCommand, handleFullAutoCommand, handleGateAuditCommand, handleGateStatsCommand, handleHandoffCommand, handleHistoryCommand, handleKnowledgeQuarantineCommand, handleKnowledgeRestoreCommand, handleKnowledgeMigrateCommand, handleKnowledgeListCommand, handleKnowledgeUnactionableCommand, handleKnowledgeRetryHardeningCommand, handleLearningCommand, handleLinkCommand, safeRealpathSync, handleMemoryCommand, handleMemoryStatusCommand, handleMemoryValueLogCommand, handleMemoryMigrateCommand, handleMemoryImportCommand, handleMemoryExportCommand, handlePlanCommand, handlePreflightCommand, handlePromoteCommand, handleQaGatesCommand, handleRecoverCommand, handleResetCommand, handleResetSessionCommand, handleRetrieveCommand, handleReviewCommand, handleRollbackCommand, handleSddStatusCommand, handleSddValidateCommand, handleSddProjectCommand, handleSddCommand, handleSimulateCommand, handleSpecifyCommand, handleStatusCommand, handleSyncPlanCommand, handleTurboCommand, handleUnlinkCommand, handleWriteRetroCommand, handleHelpCommand, COMMAND_REGISTRY, VALID_COMMANDS, _internals98 as _internals3, resolveCommand };
+export { resetActionCircuitExternally, getBlockingActionCircuit, parseLeanLaneIndex, computeLaneRuntimeProfile, MAX_TRACKED_STANDARD_WORKTREE_CALLS, awaitingMergeByCallID, standardWorktreeByCallID, standardWorktreeSerializationSessions, getStandardWorktreeDegradationReason, resetStandardWorktreeIsolationState, checkStandardWorktreeSerializationRelease, sanitizeWorktreeTaskId, preProvisionCollisionCheck, isLaneOwnedByCurrentSession, precreateStandardWorktreeSession, preserveBackgroundWorktreeOwnershipForCallId, preserveDirtyWorktreeForCallId, preserveDirtyWorktreeAtPath, cleanupStandardWorktreeForCallId, abortStandardWorktreeDispatch, finishStandardWorktreeDispatch, readLaneEnvFileFromDisk, _internals101 as _internals, dcNormalizeCommand, dcUnwrapWrappers, dcSplitSegments, dcExtractRecursiveRmTargets, dcEvaluateRecursiveDeleteTargets, dcCheckJunctionCreation, dcExtractWindowsCmdTargets, dcExtractPowerShellTargets, normalizeSwarmCommandInput, canonicalCommandKey, formatCommandNotFound, executeSwarmCommand, SWARM_COMMAND_TOOL_COMMANDS, SWARM_COMMAND_TOOL_ALLOWLIST, HUMAN_ONLY_SWARM_COMMANDS, classifySwarmCommandToolUse, classifySwarmCommandChatFallbackUse, detectPosixWrites, detectWindowsWrites, resolveWriteTargets, getAgentSession, handleAcknowledgeSpecDriftCommand, handleAgentsCommand, handleAnalyzeCommand, handleArchiveCommand, handleAutoProceedCommand, handleBenchmarkCommand, handleBrainstormCommand, handleCheckpointCommand, handleCiSimulateCommand, handleClarifyCommand, createCuratorLLMDelegate, _internals25 as _internals1, normalizeRecommendationEntryIdToken, parseKnowledgeRecommendations, parseKnowledgeRecommendationsWithDiagnostics, parseStructuredCuratorBlocks, readCuratorSummary, writeCuratorSummary, appendCuratorRecommendation, mergeCuratorPhaseSummary, filterPhaseEvents, checkPhaseCompliance, runCuratorInit, runCuratorPhase, applyCuratorKnowledgeUpdates, isHiveEligible, countDistinctProjects, checkHivePromotions, _internals29 as _internals2, createHivePromoterHook, promoteToHive, promoteFromSwarm, handleCloseCommand, handleCodebaseReviewCommand, handleConcurrencyCommand, handleConfigCommand, handleConsolidateCommand, handleCostsCommand, handleCouncilCommand, handleCurateCommand, handleDarkMatterCommand, handleDeepDiveCommand, handleDeepResearchCommand, getPluginConfigDir, getPluginCachePaths, getPluginLockFilePaths, VERSION_PINNED_LEAF, discoverVersionPinnedCachePaths, readCachePackageVersion, handleDiagnoseCommand, handleDoctorCommand, handleEvidenceCommand, handleEvidenceSummaryCommand, handleExportCommand, handleFullAutoCommand, handleGateAuditCommand, handleGateStatsCommand, handleHandoffCommand, handleHistoryCommand, handleKnowledgeQuarantineCommand, handleKnowledgeRestoreCommand, handleKnowledgeMigrateCommand, handleKnowledgeListCommand, handleKnowledgeUnactionableCommand, handleKnowledgeRetryHardeningCommand, handleLearningCommand, handleLinkCommand, safeRealpathSync, handleMemoryCommand, handleMemoryStatusCommand, handleMemoryValueLogCommand, handleMemoryMigrateCommand, handleMemoryImportCommand, handleMemoryExportCommand, handlePlanCommand, handlePreflightCommand, handlePromoteCommand, handleQaGatesCommand, handleRecoverCommand, handleResetCommand, handleResetSessionCommand, handleRetrieveCommand, handleReviewCommand, handleRollbackCommand, handleSddStatusCommand, handleSddValidateCommand, handleSddProjectCommand, handleSddCommand, handleSimulateCommand, handleSpecifyCommand, handleStatusCommand, handleSyncPlanCommand, handleTurboCommand, handleUnlinkCommand, handleWriteRetroCommand, handleHelpCommand, COMMAND_REGISTRY, VALID_COMMANDS, _internals99 as _internals3, resolveCommand };