opencode-swarm 7.144.7 → 7.145.0

package/dist/memory/schema.d.ts

@@ -48,8 +48,8 @@ export declare const MemoryKindSchema: z.ZodEnum<{
 }>;
 export declare const MemorySourceSchema: z.ZodObject<{
     type: z.ZodEnum<{
-        file: "file";
         agent: "agent";
+        file: "file";
         tool: "tool";
         manual: "manual";
         test: "test";
@@ -113,8 +113,8 @@ export declare const MemoryRecordSchema: z.ZodObject<{
     }>;
     source: z.ZodObject<{
         type: z.ZodEnum<{
-            file: "file";
             agent: "agent";
+            file: "file";
             tool: "tool";
             manual: "manual";
             test: "test";
@@ -203,8 +203,8 @@ export declare const MemoryProposalSchema: z.ZodObject<{
         }>;
         source: z.ZodObject<{
             type: z.ZodEnum<{
-                file: "file";
                 agent: "agent";
+                file: "file";
                 tool: "tool";
                 manual: "manual";
                 test: "test";

package/dist/observability/catalog.d.ts

@@ -1,15 +1,16 @@
 /**
  * The event catalog (issue #2029).
  *
- * Exactly 43 entries, matching the `TelemetryEvent` union at
+ * Exactly 44 entries, matching the `TelemetryEvent` union at
  * `src/telemetry.ts:15-92`. Thirty-eight predate the #2029 contract; the 39th is
  * `agent_conflict_detected` (previously emitted through a force-cast past the
  * type system), the 40th is `close_archive_result` (issue #2030 — the
  * structured close/archive result event), the 41st is the bounded diagnostic
  * projection of authoritative knowledge-receipt transitions (issue #2031).
  * The 42nd is the human-only `knowledge_maintenance` quarantine audit
- * (issue #2033), and the 43rd is the aggregate `context_pruned` transcript
- * mutation audit. These late additions are instances of
+ * (issue #2033), the 43rd is the aggregate `context_pruned` transcript
+ * mutation audit, and the 44th is the bounded `residue_health` atomic-write
+ * residue audit (issue #2035). These late additions are instances of
  * the defect class this contract exists to close: an event kind entering the
  * stream with no registration.
  *
@@ -64,7 +65,7 @@ export interface CatalogEntry {
     /**
      * Whether an event of this kind must carry `trace.parentSpanId`.
      *
-     * `false` for all 43 entries today, and that is a truthful statement about
+     * `false` for all 44 entries today, and that is a truthful statement about
      * the current system rather than a placeholder: no producer supplies a
      * parent span, so `createObservation` never sets one. Setting this to `true`
      * for a kind whose producer cannot supply a parent would make every

package/dist/observability/envelope.d.ts

@@ -38,11 +38,11 @@ export declare const EventCategorySchema: z.ZodEnum<{
 export type EventCategory = z.infer<typeof EventCategorySchema>;
 /** Syslog-shaped severity ladder. */
 export declare const EventSeveritySchema: z.ZodEnum<{
-    error: "error";
     debug: "debug";
     info: "info";
     notice: "notice";
     warning: "warning";
+    error: "error";
     critical: "critical";
 }>;
 export type EventSeverity = z.infer<typeof EventSeveritySchema>;
@@ -297,11 +297,11 @@ export declare const ObservabilityEventSchema: z.ZodObject<{
         unrecognized: "unrecognized";
     }>;
     severity: z.ZodEnum<{
-        error: "error";
         debug: "debug";
         info: "info";
         notice: "notice";
         warning: "warning";
+        error: "error";
         critical: "critical";
     }>;
     occurredAt: z.ZodString;

package/dist/sandbox/executor.d.ts

@@ -19,6 +19,12 @@ export declare class SandboxError extends Error {
  * sandbox command syntax on any platform.
  */
 export declare function isValidEnvKey(key: string): boolean;
+/**
+ * Returns true when `key` belongs to one of the env-var families that must
+ * never be sourced from a repo-resident (untrusted) env file.
+ * See `UNTRUSTED_ENV_KEY_PREFIXES` for the rationale.
+ */
+export declare function isUntrustedEnvKey(key: string): boolean;
 /**
  * Interface for platform-specific sandbox executors.
  */

package/dist/services/swarm-residue.d.ts

@@ -0,0 +1,151 @@
+/**
+ * Shared atomic-write residue surface (issue #2035): read-only inventory,
+ * gated recoverable quarantine, manifest-backed rollback, and the ONE
+ * formatter every reporting surface (close clean stage, close dry-run,
+ * config doctor, diagnose) renders from — so close and doctor report the
+ * same inventory from a shared implementation by construction.
+ *
+ * Safety contract (issue #2035 reqs 4-7):
+ *  - The scanner never traverses outside the canonical project `.swarm/`
+ *    root, never follows symlinks (Dirent + lstat only), never infers
+ *    ownership from content, and never reads content except a bounded
+ *    sha256 at quarantine time.
+ *  - Quarantine MOVES (never deletes) only verified stale residue: exact
+ *    registered-grammar match with an instance token, age ≥
+ *    RESIDUE_STALE_AGE_MS, git-untracked, non-symlink, no active lock,
+ *    size ≤ RESIDUE_HASH_MAX_BYTES, parsed target present, and unchanged
+ *    (mtime+size) between scan and move (TOCTOU re-check — a lockless
+ *    writer still filling its temp mutates these).
+ *  - Everything else — recent, active, tracked, ambiguous, constant-name,
+ *    malformed, unmatched, outside-root — is PRESERVED and reported.
+ *  - Rollback is exact, manifest-verified, and idempotent.
+ */
+import { type SwarmTempGrammar } from '../utils/atomic-write';
+/** Age gate: a temp older than this is "old". 30 min exceeds any legitimate
+ * single bounded write (≤256 MiB + AV/rename-retry adds seconds), while still
+ * catching session-old residue at close time. */
+export declare const RESIDUE_STALE_AGE_MS: number;
+/** Bounded scan: stop (and report `truncated`) beyond this many entries. */
+export declare const MAX_RESIDUE_SCAN_ENTRIES = 20000;
+/** Bounded scan depth below `.swarm/`. */
+export declare const RESIDUE_SCAN_DEPTH = 8;
+/** Hash/move bound per residue file. Larger candidates are reported only. */
+export declare const RESIDUE_HASH_MAX_BYTES: number;
+/** `.swarm/` immediate-child subtrees the scanner never descends into. */
+export declare const RESIDUE_SKIP_DIRS: readonly string[];
+export interface ResidueEntry {
+    /** Path relative to the `.swarm/` root (never absolute — no path leak). */
+    relPath: string;
+    grammarId: string;
+    grammarEra: SwarmTempGrammar['era'];
+    bytes: number;
+    mtimeMs: number;
+    ageMs: number;
+    isSymlink: boolean;
+    tracked: 'tracked' | 'untracked' | 'unknown';
+    lockHeld: boolean;
+    proposedAction: 'quarantine' | 'report_only';
+    reasons: readonly string[];
+}
+export interface ResidueInventorySummary {
+    matched: number;
+    eligible: number;
+    ambiguous: number;
+    totalBytes: number;
+    oldestAgeMs: number;
+}
+export interface ResidueInventory {
+    swarmRoot: string;
+    scannedEntries: number;
+    truncated: boolean;
+    /** Oldest first. Constant-name grammar hits are included only when stale. */
+    entries: readonly ResidueEntry[];
+    summary: ResidueInventorySummary;
+    gitState: 'ok' | 'unknown';
+}
+/**
+ * Test seam (repo `_internals` convention — never mock.module). `now` drives
+ * age math; `queryTracked`/`activeLockTargets` isolate the git/lock signals.
+ */
+export declare const _internals: {
+    now: () => number;
+    /** Rename seam for the per-entry guarded move (PRR-005 regression tests). */
+    renameResidueEntry: (from: string, to: string) => void;
+    queryTracked: (projectRoot: string, swarmRoot: string) => {
+        tracked: Set<string> | undefined;
+    };
+    activeLockTargets: (directory: string) => Set<string>;
+    sha256File: (absPath: string) => string;
+};
+/** Read-only inventory of registered-grammar residue under `<directory>/.swarm`. */
+export declare function inventorySwarmResidue(directory: string): Promise<ResidueInventory>;
+export interface QuarantineManifestEntry {
+    original_rel_path: string;
+    stored_rel_path: string;
+    sha256: string;
+    bytes: number;
+    mtime_ms: number;
+    grammar_id: string;
+    reason: string;
+}
+export interface QuarantineManifest {
+    /**
+     * Manifest format version. Forward-compat POLICY (PR review PRR-009):
+     * rollback hard-rejects any version it does not know — a FUTURE schema
+     * bump MUST ship its own reader/migration before (or with) the writer,
+     * because payloads on disk are only recoverable through a manifest the
+     * current code can parse. Deliberate design: a partial-reader migration
+     * is more dangerous than a readable "unsupported manifest shape" error
+     * naming the version. Mixed-version operation is therefore unsafe by
+     * construction across schema bumps: downgrade with v2 batches present
+     * blocks rollback of those batches until the newer plugin returns.
+     */
+    schema_version: 1;
+    batch_id: string;
+    created_at: string;
+    trigger: string;
+    entries: QuarantineManifestEntry[];
+}
+export interface QuarantineOutcomeItem {
+    relPath: string;
+    status: 'quarantined' | 'preserved';
+    reasons: readonly string[];
+}
+export interface QuarantineResult {
+    inventory: ResidueInventory;
+    /** Batch dir relative to `.swarm/` — undefined when nothing was moved. */
+    batchRelDir?: string;
+    quarantined: number;
+    /** report_only entries preserved at their original location. */
+    preserved: readonly QuarantineOutcomeItem[];
+}
+/**
+ * Quarantine verified stale residue (moves only — never deletes). Callers
+ * that can mutate pass an explicit trigger; `dryRun: true` returns the exact
+ * plan without touching the filesystem (preview/confirmation path).
+ */
+export declare function quarantineSwarmResidue(directory: string, options?: {
+    trigger?: string;
+    dryRun?: boolean;
+}): Promise<QuarantineResult>;
+export interface RollbackOutcomeItem {
+    relPath: string;
+    status: 'restored' | 'already-restored' | 'collision' | 'missing-copy';
+}
+export interface RollbackResult {
+    batchRelDir: string;
+    items: readonly RollbackOutcomeItem[];
+    /** True when every manifest entry resolved and the batch dir was removed. */
+    drained: boolean;
+}
+/**
+ * Roll back a quarantine batch (default: latest). Idempotent and
+ * order-independent across batches: an occupied original is compared by
+ * checksum — identical copies are dropped (already restored), differing
+ * content is left in place and reported as a collision, never overwritten.
+ */
+export declare function rollbackResidueQuarantine(directory: string, batchId?: string): Promise<RollbackResult>;
+/** Bounded human rendering of an inventory (≤ maxEntries detail lines). */
+export declare function formatResidueInventoryLines(inv: ResidueInventory, options?: {
+    maxEntries?: number;
+}): string[];

package/dist/telemetry.d.ts

@@ -26,7 +26,7 @@ export type TelemetryEvent = 'session_started' | 'session_ended' | 'agent_activa
  * `prm_hard_stop` TRIGGER emitted by `src/prm/escalation.ts`. A trigger with
  * no matching delivery means the containment never reached the agent.
  */
- | 'prm_hard_stop_delivered' | 'agent_conflict_detected' | 'close_archive_result' | 'knowledge_receipt_transition' | 'knowledge_maintenance';
+ | 'prm_hard_stop_delivered' | 'agent_conflict_detected' | 'close_archive_result' | 'knowledge_receipt_transition' | 'knowledge_maintenance' | 'residue_health';
 /** Stable classification for how a reviewer-gate decision was established. */
 export type ReviewerGateEvidenceKind = 'genuine' | 'fallback' | 'data_quality' | 'block';
 /**
@@ -206,6 +206,25 @@ export declare const telemetry: {
             };
         }>;
     }): void;
+    /**
+     * Atomic-write residue health (issue #2035). Emitted after a residue
+     * quarantine run (close clean stage / doctor flag). Bounded payload:
+     * counts, one bounded age figure, total bytes, and per-grammar counts
+     * keyed by the frozen registry ids — never file names, paths, or content,
+     * enabling later reporting (PR 16/19) without leaking workspace layout.
+     */
+    residueHealth(data: {
+        trigger: string;
+        scanned: number;
+        matched: number;
+        eligible: number;
+        ambiguous: number;
+        quarantined: number;
+        preserved: number;
+        total_bytes: number;
+        oldest_age_ms: number;
+        grammar_counts: Record<string, number>;
+    }): void;
     /**
      * Issue #2063 C2 — the PRM hard-stop DENIAL was actually delivered to the
      * agent (thrown by the guardrails `toolBefore` consumer). `prm_hard_stop`

package/dist/tools/knowledge-receipt.d.ts

@@ -17,8 +17,8 @@ import { createSwarmTool } from './create-tool.js';
 declare const ignoredItem: z.ZodObject<{
     id: z.ZodString;
     reason: z.ZodEnum<{
-        other: "other";
         stale: "stale";
+        other: "other";
         superseded: "superseded";
         unsafe: "unsafe";
         too_generic: "too_generic";

package/dist/utils/atomic-write.d.ts

@@ -0,0 +1,185 @@
+/**
+ * Canonical atomic-write helper + temp-grammar registry (issue #2035).
+ *
+ * Single source of truth for:
+ *  - HOW production code atomically writes files under the project `.swarm/`
+ *    root: one same-directory write-temp→fsync→rename helper with exact
+ *    `finally` cleanup of its OWN temp only.
+ *  - WHAT temporary-file name grammars exist: a frozen registry derived from
+ *    the writer census so residue scanners classify candidates by exact
+ *    registered grammars instead of substring guesses.
+ *
+ * Why the registry lives here: every residue consumer (close clean stage,
+ * close dry-run, config doctor, diagnose, quarantine/rollback in
+ * `src/services/swarm-residue.ts`) must derive candidates from the SAME
+ * registered grammars, and every atomic writer must be classifiable against
+ * the same table (see `WRITER_CLASSIFICATION` and its ratchet test).
+ *
+ * Containment contract (issue #2035 req 1): the canonical target must live
+ * under a `.swarm/` root, determined by SPELLING — the nearest `.swarm` path
+ * segment between the filesystem root and the target. A pre-existing root
+ * must be a real directory (no symlinks), and no path segment between it and
+ * the target may be a symlink. Semantics are validateSwarmPath-INSPIRED but
+ * NOT identical — see the junction limitation on
+ * `assertSwarmContainedTarget`.
+ */
+import * as fs from 'node:fs';
+/**
+ * A registered temporary-file naming grammar.
+ *
+ * `match` is applied to the temp file's BASENAME only, case-sensitively —
+ * near-misses (unicode/case variants, trailing dots, ADS suffixes) must NOT
+ * match, so they are preserved untouched by every scanner.
+ */
+export interface SwarmTempGrammar {
+    /** Stable id used in reports, manifests, and telemetry (never renamed). */
+    readonly id: string;
+    readonly era: 'canonical' | 'current' | 'legacy';
+    /** Matches the temp basename. Capture group 1 = derivable target basename when `parsesTarget`. */
+    readonly match: RegExp;
+    /** The grammar embeds a per-invocation uniqueness token (ts/pid/uuid/random). */
+    readonly token: 'instance' | 'constant';
+    /** Trusted for quarantine when all eligibility gates pass (issue #2035 req 5). */
+    readonly quarantineEligible: boolean;
+    /** Whether a target basename can be parsed back out of the temp name. */
+    readonly parsesTarget: boolean;
+    /** Producing writer sites (file:line) — every known producer is listed. */
+    readonly producers: readonly string[];
+    /** Invariant reason the producer is NOT migrated to the canonical helper. */
+    readonly note?: string;
+}
+/**
+ * Every temp grammar a swarm writer has ever produced. Grammars marked
+ * `quarantineEligible: false` are constant-name temps: with no per-invocation
+ * token they are indistinguishable from an in-flight writer of ANY process or
+ * from an unrelated file, so scanners report them but never mutate them.
+ * ORDER MATTERS: `matchTempGrammar`/`parseTargetBasename` take the FIRST
+ * match, so more-specific grammars (uuid, two-token, .json-terminated) must
+ * be declared before the generic single-token family.
+ */
+export declare const SWARM_TEMP_GRAMMARS: readonly SwarmTempGrammar[];
+/** First registered grammar whose regex matches `basename`, or undefined. */
+export declare function matchTempGrammar(basename: string): SwarmTempGrammar | undefined;
+/**
+ * Parse the target basename a temp name was derived from (capture group 1).
+ * Returns null for prefix/leading-dot grammars with no derivable target.
+ */
+export declare function parseTargetBasename(basename: string): string | null;
+/**
+ * Structural classification of every file that constructs temp-file names
+ * (ratchet source for tests/unit/utils/atomic-write.test.ts — a new temp
+ * constructor must be classified here or the build fails):
+ *  - migrated:        writes through the canonical helper (registry lists its
+ *                     grammar only for historical residue discovery)
+ *  - registered-bespoke: keeps a dedicated writer with a documented invariant
+ *                     reason in the grammar `note` (issue #2035 req 2)
+ *  - external:        writes outside the `.swarm` containment boundary
+ *  - reader-only:     references temp names without constructing them
+ */
+export declare const WRITER_CLASSIFICATION: Readonly<Record<string, 'migrated' | 'registered-bespoke' | 'external' | 'reader-only'>>;
+/**
+ * Max depth considered when reasoning about `.swarm` path segments (advisory
+ * constant kept for diagnostics; containment itself is spelling-based).
+ */
+export declare const MAX_SWARM_ANCESTOR_DEPTH = 8;
+export interface SwarmContainment {
+    /** Project root that owns the `.swarm/` directory. */
+    projectRoot: string;
+    /** Canonical `.swarm/` directory containing the target. */
+    swarmRoot: string;
+}
+/**
+ * Reject obviously-invalid target spellings before any filesystem access:
+ * glob metacharacters, control chars/NUL, and unresolved environment-variable
+ * forms (`$VAR`, `%VAR%`, leading `~`). Quarantine/inventory paths and writer
+ * paths share this gate (issue #2035 req 7).
+ */
+export declare function assertWellFormedTargetPath(targetPath: string): void;
+/**
+ * Assert `targetPath` lives beneath a `.swarm/` root.
+ *
+ * The root is determined by SPELLING: the nearest `.swarm` path segment
+ * between the filesystem root and the target. Existence-based ancestor
+ * walking is deliberately avoided — a stray `.swarm` in an ancestor (e.g. the
+ * OS temp dir) would hijack the walk and reject legitimate first-writes whose
+ * own `.swarm` parent does not exist yet (invariant 4: ambiguous ancestor
+ * `.swarm` state fails closed). If the `.swarm` root exists it must be a real
+ * directory (no symlink), and no existing path segment between it and the
+ * target may be a symlink.
+ *
+ * KNOWN LIMITATION vs `validateSwarmPath` (src/hooks/utils.ts:157, PR review
+ * PRR-007): this check detects SYMLINKS via lstatSync().isSymbolicLink(),
+ * which returns FALSE for Windows directory JUNCTIONS (a distinct reparse
+ * class). validateSwarmPath resolves all reparse points via realpathSync. A
+ * junctioned `.swarm/` therefore passes this spelling-based gate. Mitigations
+ * in scope: junctions require same-user filesystem write access to create
+ * (outside the adversarial-local-process threat model invariant 4 excludes),
+ * targets are still spelling-bounded to the `.swarm` subtree, and the
+ * spell-time `.swarm` position must already exist in the user's path. Full
+ * junction parity would require realpath-resolution of every existing
+ * ancestor — deliberately out of budget for the write hot path.
+ *
+ * Project-boundary enforcement (`.git`/`.opencode` markers, invariant 4) is
+ * deliberately NOT re-checked here: that belongs to the tool-layer
+ * resolvers (`resolveWorkingDirectory`/`assertProjectRoot`), which have
+ * already validated the directory before any writer derived a target from
+ * it — validateSwarmPath applies the same split.
+ */
+export declare function assertSwarmContainedTarget(targetPath: string): SwarmContainment;
+/** Hard bound on a single atomic write (bounded-write requirement). */
+export declare const MAX_ATOMIC_WRITE_BYTES: number;
+export interface AtomicWriteOptions {
+    /** Skip the pre-rename fsync (tests / truly ephemeral data). */
+    readonly skipFsync?: boolean;
+    /**
+     * Override the bounded-write cap (default MAX_ATOMIC_WRITE_BYTES). Exposed
+     * so the bound itself is testable without allocating 256 MiB.
+     */
+    readonly maxBytes?: number;
+}
+/**
+ * Dependency-injection seam for failure-injection tests (repo convention;
+ * never mock.module — it leaks across bun:test files). Restore in afterEach.
+ *
+ * The defaults DELEGATE to the live `fs` namespace on every call (instead of
+ * capturing the function at module load) so sibling tests that patch
+ * `node:fs` via `mock.module` — while still calling through to the real
+ * implementation — observe these calls, matching the recording patterns in
+ * tests/unit/commands/atomic-writes.test.ts.
+ */
+export declare const _internals: {
+    randomSuffix: () => string;
+    writeSync: (fd: number, buffer: Uint8Array, offset: number, length: number) => number;
+    renameSync: (from: string, to: string) => ReturnType<typeof fs.renameSync>;
+    unlinkSync: (p: string) => ReturnType<typeof fs.unlinkSync>;
+    fsyncSync: (fd: number) => ReturnType<typeof fs.fsyncSync>;
+};
+/**
+ * Canonical atomic write under the project `.swarm/` root (issue #2035 req 1):
+ * contained target, unique non-predictable same-directory temp, bounded write,
+ * fsync+close where supported, platform-safe replace (bounded rename retry on
+ * Windows transient locks — never unlink-then-rename, which would break
+ * atomicity), and exact finally cleanup of this invocation's temp only.
+ *
+ * The payload is bounded (≤ MAX_ATOMIC_WRITE_BYTES), so the synchronous
+ * temp-write core is the same latency class as the previous per-caller
+ * write-temp implementations; the async signature preserves caller shapes.
+ */
+export declare function atomicWriteSwarmFile(targetPath: string, content: string | Uint8Array, options?: AtomicWriteOptions): Promise<void>;
+/** Synchronous variant of {@link atomicWriteSwarmFile} (same core). */
+export declare function atomicWriteSwarmFileSync(targetPath: string, content: string | Uint8Array, options?: AtomicWriteOptions): void;
+/**
+ * Canonical atomic write WITHOUT the `.swarm` containment requirement.
+ *
+ * Documented invariant reason this variant exists (issue #2035 req 2): the
+ * legacy shared writer `atomicWriteFile` (src/evidence/task-file.ts) serves
+ * DUAL destinations — `.swarm/evidence/**` files AND the linked/hive
+ * knowledge stores whose platform-data/link directories live OUTSIDE any
+ * `.swarm` root (src/hooks/knowledge-store.ts, knowledge-link.ts,
+ * memory-link.ts, family migrations). Those callers migrate to this variant
+ * so they still gain the canonical grammar, fsync, bounded retry, exact
+ * own-temp cleanup, and cache invalidation — everything except root
+ * containment, which their destinations make inapplicable. New `.swarm`
+ * callers MUST use {@link atomicWriteSwarmFile}.
+ */
+export declare function atomicWriteFileAnyRoot(targetPath: string, content: string | Uint8Array, options?: AtomicWriteOptions): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-swarm",
-	"version": "7.144.7",
+	"version": "7.145.0",
 	"description": "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",

package/dist/cli/curator-llm-factory-eny079d1.js

@@ -1,63 +0,0 @@
-// @bun
-import {
-  createCuratorLLMDelegate
-} from "./index-x4q96ejx.js";
-import"./index-gmdgap01.js";
-import"./index-00fk9c3b.js";
-import"./index-s1xefrx7.js";
-import"./index-134d35c1.js";
-import"./index-abtrcs16.js";
-import"./index-6z5jtf7d.js";
-import"./index-wknz5c8q.js";
-import"./index-y8552snf.js";
-import"./index-d879g58v.js";
-import"./index-70ha9e09.js";
-import"./index-c8s9a3zh.js";
-import"./index-9ss2m4rs.js";
-import"./index-f36ybbsv.js";
-import"./index-hkdgkkhb.js";
-import"./index-w9bnt74s.js";
-import"./index-pzsezhek.js";
-import"./index-c1cfsg9y.js";
-import"./index-vdha477y.js";
-import"./index-rtry5xyf.js";
-import"./index-zsrtt42s.js";
-import"./index-n4hwcsbd.js";
-import"./index-cwtpqm5f.js";
-import"./index-grkev1g6.js";
-import"./index-q7zy6dej.js";
-import"./index-jszgrk71.js";
-import"./index-7bvd5nh2.js";
-import"./index-556ja8an.js";
-import"./index-7sy3aa9m.js";
-import"./index-wx8zdh4a.js";
-import"./index-b44qqqt2.js";
-import"./index-zy7f84cs.js";
-import"./index-77h4xjn5.js";
-import"./index-qm0mz7rj.js";
-import"./index-bx20cv1v.js";
-import"./index-gprxjmm7.js";
-import"./index-n832052r.js";
-import"./index-fv0s19g9.js";
-import"./index-z6xqpmqg.js";
-import"./index-zq9gs0yk.js";
-import"./index-x4eqd82b.js";
-import"./index-v3y3qg48.js";
-import"./index-9e6fdz2h.js";
-import"./index-4rhhvd1a.js";
-import"./index-zjygnfay.js";
-import"./index-ae75rja9.js";
-import"./index-h1p08s3n.js";
-import"./index-9s8drsf9.js";
-import"./index-ed5ykebp.js";
-import"./index-bk5tah7q.js";
-import"./index-f9vvg5xb.js";
-import"./index-1jsmmx7y.js";
-import"./index-7g4c7s5r.js";
-import"./index-bpmtbmy9.js";
-import"./index-zj6t9zgx.js";
-import"./index-zgwm4ryv.js";
-import"./index-a76rekgs.js";
-export {
-  createCuratorLLMDelegate
-};

package/dist/cli/guardrail-explain-8gggptqj.js

@@ -1,64 +0,0 @@
-// @bun
-import {
-  handleGuardrailExplain
-} from "./index-yz0hfa4g.js";
-import"./index-x4q96ejx.js";
-import"./index-gmdgap01.js";
-import"./index-00fk9c3b.js";
-import"./index-s1xefrx7.js";
-import"./index-134d35c1.js";
-import"./index-abtrcs16.js";
-import"./index-6z5jtf7d.js";
-import"./index-wknz5c8q.js";
-import"./index-y8552snf.js";
-import"./index-d879g58v.js";
-import"./index-70ha9e09.js";
-import"./index-c8s9a3zh.js";
-import"./index-9ss2m4rs.js";
-import"./index-f36ybbsv.js";
-import"./index-hkdgkkhb.js";
-import"./index-w9bnt74s.js";
-import"./index-pzsezhek.js";
-import"./index-c1cfsg9y.js";
-import"./index-vdha477y.js";
-import"./index-rtry5xyf.js";
-import"./index-zsrtt42s.js";
-import"./index-n4hwcsbd.js";
-import"./index-cwtpqm5f.js";
-import"./index-grkev1g6.js";
-import"./index-q7zy6dej.js";
-import"./index-jszgrk71.js";
-import"./index-7bvd5nh2.js";
-import"./index-556ja8an.js";
-import"./index-7sy3aa9m.js";
-import"./index-wx8zdh4a.js";
-import"./index-b44qqqt2.js";
-import"./index-zy7f84cs.js";
-import"./index-77h4xjn5.js";
-import"./index-qm0mz7rj.js";
-import"./index-bx20cv1v.js";
-import"./index-gprxjmm7.js";
-import"./index-n832052r.js";
-import"./index-fv0s19g9.js";
-import"./index-z6xqpmqg.js";
-import"./index-zq9gs0yk.js";
-import"./index-x4eqd82b.js";
-import"./index-v3y3qg48.js";
-import"./index-9e6fdz2h.js";
-import"./index-4rhhvd1a.js";
-import"./index-zjygnfay.js";
-import"./index-ae75rja9.js";
-import"./index-h1p08s3n.js";
-import"./index-9s8drsf9.js";
-import"./index-ed5ykebp.js";
-import"./index-bk5tah7q.js";
-import"./index-f9vvg5xb.js";
-import"./index-1jsmmx7y.js";
-import"./index-7g4c7s5r.js";
-import"./index-bpmtbmy9.js";
-import"./index-zj6t9zgx.js";
-import"./index-zgwm4ryv.js";
-import"./index-a76rekgs.js";
-export {
-  handleGuardrailExplain
-};

package/dist/cli/{index-f36ybbsv.js → index-b30x236n.js}

@@ -1,11 +1,11 @@
 // @bun
+import {
+  bunSpawn
+} from "./index-zj6t9zgx.js";
 import {
   init_git_executable,
   resolveGitExecutable
 } from "./index-9e6fdz2h.js";
-import {
-  bunSpawn
-} from "./index-zj6t9zgx.js";
 
 // src/background/workspace-snapshot.ts
 import * as child_process from "child_process";

package/dist/cli/{index-fv0s19g9.js → index-w8pgjr75.js}

@@ -2,12 +2,12 @@
 import {
   SwarmError
 } from "./index-z6xqpmqg.js";
-import {
-  readCachedTextFile
-} from "./index-ed5ykebp.js";
 import {
   bunFile
 } from "./index-zj6t9zgx.js";
+import {
+  readCachedTextFile
+} from "./index-ed5ykebp.js";
 import {
   warn
 } from "./index-zgwm4ryv.js";