opencode-swarm 7.164.11 → 7.164.13

package/dist/memory/schema.d.ts

@@ -54,8 +54,8 @@ export declare const MemorySourceSchema: z.ZodObject<{
         tool: "tool";
         test: "test";
         manual: "manual";
-        commit: "commit";
         user: "user";
+        commit: "commit";
         repo: "repo";
         web: "web";
     }>;
@@ -119,8 +119,8 @@ export declare const MemoryRecordSchema: z.ZodObject<{
             tool: "tool";
             test: "test";
             manual: "manual";
-            commit: "commit";
             user: "user";
+            commit: "commit";
             repo: "repo";
             web: "web";
         }>;
@@ -217,8 +217,8 @@ export declare const MemoryProposalSchema: z.ZodObject<{
                 tool: "tool";
                 test: "test";
                 manual: "manual";
-                commit: "commit";
                 user: "user";
+                commit: "commit";
                 repo: "repo";
                 web: "web";
             }>;

package/dist/pr-review/authorization.d.ts

@@ -19,10 +19,9 @@
  * orchestration gate back. The gate binds its
  * `readPrReviewReentryBindingContext` at module init.
  *
- * Persistence: `.swarm/pr-review/reentry-authorizations/<session-stem>.json`,
- * guarded by a `proper-lockfile` lock (the same dependency the candidate
- * sidecar store uses). Bounded: at most MAX_ACTIVE_AUTHORIZATIONS unconsumed
- * authorizations per session; expired/unconsumed records are pruned on write.
+ * Persistence: SQLite coordination state is authoritative; the legacy
+ * `.swarm/pr-review/reentry-authorizations/<session-stem>.json` path remains a
+ * post-commit shadow projection and one-time import source only.
  */
 import { z } from 'zod';
 export type PrReviewReentryRole = 'reviewer' | 'test_engineer';
@@ -79,6 +78,7 @@ declare const AuthorizationFileSchema: z.ZodObject<{
 }, z.core.$strict>;
 type AuthorizationFile = z.infer<typeof AuthorizationFileSchema>;
 declare function reentryAuthorizationFilePath(directory: string, sessionID: string): string;
+declare function reentryAuthorizationCoordinationNamespace(sessionID: string): string;
 declare function renameWithRetryAsync(tempPath: string, targetPath: string): Promise<void>;
 declare function writeAuthorizationFile(filePath: string, file: AuthorizationFile): Promise<void>;
 /**
@@ -122,6 +122,7 @@ export declare const _internals: {
     AUTHORIZATION_TTL_MS: number;
     MAX_ACTIVE_AUTHORIZATIONS: number;
     reentryAuthorizationFilePath: typeof reentryAuthorizationFilePath;
+    reentryAuthorizationCoordinationNamespace: typeof reentryAuthorizationCoordinationNamespace;
     pruneAuthorizations: typeof pruneAuthorizations;
     authorizationMatchesBinding: typeof authorizationMatchesBinding;
     hasPrReviewReentryAuthorizationAgainstBinding: typeof hasPrReviewReentryAuthorizationAgainstBinding;

package/dist/pr-review/persistence.d.ts

@@ -88,12 +88,21 @@ export declare function writeAtomicJson(directory: string, filePath: string, val
  * rename contention as canonical gate state.
  */
 export declare function writePrWorkflowAtomicJson(directory: string, filePath: string, value: unknown): Promise<void>;
-export declare function readPrWorkflowGateStateFromDisk<S extends PrWorkflowPersistedStateBase>(directory: string, sessionID: string): Promise<S | null>;
+export declare function readPrWorkflowGateStateFromDisk<S extends PrWorkflowPersistedStateBase>(directory: string, sessionID: string, options?: {
+    allowSalvagedImport?: boolean;
+}): Promise<S | null>;
+export declare function readPrWorkflowGateStateFileRawFromDisk<S extends PrWorkflowPersistedStateBase>(filePath: string, stateLabel: string): Promise<S | null>;
 export declare function readPrWorkflowGateStateFileFromDisk<S extends PrWorkflowPersistedStateBase>(filePath: string, stateLabel: string): Promise<S | null>;
+export declare function readPrWorkflowGateStateFromCoordination<S extends PrWorkflowPersistedStateBase>(directory: string, sessionID: string): Promise<S | null>;
 /** Persist one CAS-checked state replacement while the session lock is held. */
 export declare function writeStateWhileLocked<S extends PrWorkflowPersistedStateBase>(directory: string, state: S, options?: {
     replaceWorkflowInstanceId?: string;
 }): Promise<S>;
+/** Remove authoritative PR workflow state while the session mutation lock is held. */
+export declare function deleteStateWhileLocked(directory: string, sessionID: string, options?: {
+    expectedStateRevision?: number;
+    allowSalvagedRead?: boolean;
+}): Promise<void>;
 /** A bounded checkout-mutation refusal that never permits unsafe late overlap. */
 export declare class PrWorkflowCheckoutMutationTimeoutError extends Error {
     readonly phase: 'queue' | 'action';

package/dist/scope/scope-binding.d.ts

@@ -92,6 +92,16 @@ export declare function getScopeBinding(input: {
     ownerSessionId: string;
     ownerMessageId?: string;
 }): ScopeBinding | null;
+/**
+ * Resolve active child bindings that were minted in this process. The
+ * synchronous scope API is still used by a few host integrations that cannot
+ * await the durable claim path; those bindings remain valid for the current
+ * process while the SQLite authority is used on restart/cross-process reads.
+ */
+export declare function getActiveScopeBindingsForSession(input: {
+    directory: string;
+    activeSessionId: string;
+}): ScopeBinding[];
 export declare function createPrFeedbackScopeBinding(input: {
     directory: string;
     taskId: string;

package/dist/scope/scope-persistence.d.ts

@@ -83,6 +83,14 @@ export interface PersistedScope {
     files: string[];
 }
 export type PersistedScopeBinding = ScopeBinding;
+declare function transitionScopeBindingState(directory: string, binding: ScopeBinding, expectedRevision: number | null): ScopePersistenceResult;
+/**
+ * Scope replacement rollback owns one coordination transaction across the
+ * successor revocation and every predecessor restore. Re-entering the public
+ * transition helper would create nested SQLite transaction scopes that cannot
+ * make that whole compensation batch atomic.
+ */
+declare function transitionScopeBindingStateWithinTransaction(directory: string, binding: ScopeBinding, expectedRevision: number | null): ScopePersistenceResult;
 /**
  * Write the legacy v1 `.swarm/scopes/scope-{taskId}.json` projection atomically.
  * Safe to call concurrently — proper-lockfile serialises writers per-file.
@@ -190,6 +198,8 @@ export declare function resolveAuthorizedPrFeedbackScopeBindingFromDisk(input: {
     taskId?: string;
 }): ScopeBinding | null;
 export declare const _scopePersistenceInternals: {
+    transitionScopeBindingState: typeof transitionScopeBindingState;
+    transitionScopeBindingStateWithinTransaction: typeof transitionScopeBindingStateWithinTransaction;
     liveBindingCapacity: number;
     bindingFileScanCapacity: number;
     maintenanceFileScanCapacity: number;

package/dist/services/decision-drift-analyzer.d.ts

@@ -78,6 +78,13 @@ export interface DriftAnalyzerConfig {
 export declare const DEFAULT_DRIFT_CONFIG: DriftAnalyzerConfig;
 /**
  * Extract decisions from context.md content
+ *
+ * #2493 W9a: the section scan itself now lives in the shared extractor
+ * (`src/utils/context-decisions.ts`) so all four historical consumers of
+ * the `## Decisions` section agree on boundaries. This delegate preserves
+ * this module's public shape exactly — `ContextDecision` is a structural
+ * superset of `Decision` (it additionally carries the raw source line), so
+ * the mapping is the identity.
  */
 export declare function extractDecisionsFromContext(contextContent: string): Decision[];
 /**

package/dist/services/handoff-service.d.ts

@@ -6,6 +6,7 @@
  */
 import type { ExecutionProfile } from '../config/plan-schema';
 import { loadPlanJsonOnly } from '../plan/manager';
+import { readSnapshotRows } from '../session/snapshot-store.js';
 /**
  * Escape HTML special characters to prevent XSS attacks
  */
@@ -97,6 +98,16 @@ declare function parseSessionState(content: string | null): {
 } | null;
 /**
  * Extract decisions from context.md content
+ *
+ * #2493 W9a: derives from the shared section extractor
+ * (`src/utils/context-decisions.ts`) instead of a private line-scan.
+ * Mapping preserves this consumer's historical output exactly:
+ * - cleaned text: bracket groups (timestamps, [confirmed]) and the ✅
+ *   marker removed (the shared `text` already strips bracket groups, so
+ *   only ✅ removal remains here);
+ * - empty results dropped;
+ * - RTL-sanitized and truncated to MAX_DECISION_LENGTH;
+ * - LAST 5 decisions kept.
  */
 declare function extractDecisions(content: string | null): string[];
 /**
@@ -134,5 +145,6 @@ export declare const _internals: {
     parseSessionState: typeof parseSessionState;
     extractDecisions: typeof extractDecisions;
     extractPhaseMetrics: typeof extractPhaseMetrics;
+    readSnapshotRows: typeof readSnapshotRows;
 };
 export {};

package/dist/services/status-service.d.ts

@@ -2,6 +2,7 @@ import type { AgentDefinition } from '../agents';
 import { type DelegationHealthMaintenanceSection, type DelegationLedgerHealth } from '../background/delegation-health';
 import { loadFullAutoRunState } from '../full-auto/state';
 import { type RecentEscalation } from '../hooks/knowledge-escalator';
+import { type SnapshotCoordinationStatus } from '../session/snapshot-coordination-init.js';
 import { getActiveFullAutoSessionID, hasActiveFullAuto, hasActiveLeanTurbo } from '../state';
 import { loadLeanTurboRunState } from '../turbo/lean/state';
 import { summarizeTelemetryCosts } from './cost-accounting.js';
@@ -16,6 +17,7 @@ export declare const _internals: {
     getActiveFullAutoSessionID: typeof getActiveFullAutoSessionID;
     loadFullAutoRunState: typeof loadFullAutoRunState;
     summarizeTelemetryCosts: typeof summarizeTelemetryCosts;
+    renderNoActivePlanStatusTail: typeof renderNoActivePlanStatusTail;
 };
 /**
  * Structured status data returned by the status service.
@@ -101,6 +103,22 @@ export interface StatusData {
     specStaleStoredHash?: string;
     /** Current spec.md hash on disk (null when spec.md is missing) */
     specStaleCurrentHash?: string | null;
+    /**
+     * #2493 W9b: decision-drift visibility. Counts derived from running the
+     * same analyzer the architect context injection uses
+     * (`analyzeDecisionDrift`) over `.swarm/context.md`. `undefined` when
+     * detection is disabled (`automation.capabilities.decision_drift_detection:
+     * false`), when there is no drift, or when the analysis fails (fail-open —
+     * a status command must never fail because an optional signal hiccupped).
+     */
+    decisionDrift?: {
+        /** Number of stale-decision signals */
+        staleCount: number;
+        /** Number of contradictory-decision signals */
+        contradictionCount: number;
+        /** Timestamp of the most recent timestamped decision, when any exist */
+        lastDecisionAt?: string;
+    };
     /** Directives auto-escalated in the last 7 days (Change 3). */
     recentEscalations?: RecentEscalation[];
     /** #1234 Part 3: pending skill/motif proposals in .swarm/skills/proposals/ */
@@ -195,6 +213,8 @@ export interface StatusData {
      * stores surface as typed uncertainty, never partially-trusted counts.
      */
     backgroundWork?: BackgroundWorkStatus;
+    /** Post-resolution SQLite import/readiness health (#2481). */
+    coordination?: SnapshotCoordinationStatus;
     /** Issue #2043: compatibility total plus provenance completeness. */
     costs?: {
         totalCostUsd: number;
@@ -216,6 +236,7 @@ export interface BackgroundWorkStatus {
         consumed: number;
         stale: number;
         cancelled: number;
+        rejected: number;
         error: number;
         ingestion_error: number;
     };
@@ -258,6 +279,15 @@ export declare function getStatusData(directory: string, agents: Record<string,
  * This is the thin adapter that delegates to the service.
  */
 export declare function formatStatusMarkdown(status: StatusData): string;
+/**
+ * No-active-plan status tail (#853 Layer C, #2493 W9b, #2034/#1659): spec
+ * drift, decision drift, and delegation-ledger health must COMPOSE — none of
+ * the three signals may suppress another. Extracted from
+ * handleStatusCommand so the composition is directly unit-testable
+ * (#2493 review: the old inline decision-drift early-return silently
+ * suppressed the ledger-health block when both signals coexisted).
+ */
+declare function renderNoActivePlanStatusTail(statusData: StatusData): string;
 /**
  * Handle status command - delegates to service and formats output.
  * Kept for backward compatibility - thin adapter.
@@ -265,3 +295,4 @@ export declare function formatStatusMarkdown(status: StatusData): string;
 export declare function handleStatusCommand(directory: string, agents: Record<string, AgentDefinition>, sessionId?: string, options?: {
     backgroundSubagents?: boolean;
 }): Promise<string>;
+export {};

package/dist/session/snapshot-coordination-init.d.ts

@@ -0,0 +1,49 @@
+/** Post-resolution SQLite snapshot import/readiness lifecycle (#2481). */
+import type { SnapshotData } from './snapshot-writer.js';
+type ReadinessState = 'running' | 'succeeded' | 'failed' | 'timed_out' | 'closing';
+interface ReadinessEntry {
+    attemptId: number;
+    generation: number;
+    state: ReadinessState;
+    settled: boolean;
+    underlying: Promise<void>;
+    error?: string;
+}
+export interface SnapshotCoordinationStatus {
+    state: ReadinessState | 'idle';
+    attemptId?: number;
+    generation?: number;
+    settled: boolean;
+    error?: string;
+}
+/**
+ * Held while reset-session removes the authoritative snapshot and its legacy
+ * projection. Callers must release it after the destructive portion is done.
+ */
+export interface SnapshotCoordinationResetGuard {
+    release(): void;
+    closeError?: Error;
+    /** True when the prior initializer did not settle before the reset deadline. */
+    priorUnsettled?: boolean;
+}
+export declare function startSnapshotCoordinationInitialization(directory: string): Promise<void>;
+export declare function ensureSnapshotCoordinationReady(directory: string): Promise<void>;
+export declare function retrySnapshotCoordinationInitialization(directory: string): Promise<void>;
+export declare function getSnapshotCoordinationStatus(directory: string): SnapshotCoordinationStatus;
+/**
+ * Prevent any fresh initializer from observing state while reset-session
+ * deletes the SQLite authority and legacy projection. The guard deliberately
+ * survives a prior initialization failure: reset remains best-effort, but a
+ * concurrent initializer cannot race through the destructive window.
+ */
+export declare function beginSnapshotCoordinationReset(directory: string): Promise<SnapshotCoordinationResetGuard>;
+export declare function closeSnapshotCoordinationInitialization(directory: string): Promise<void>;
+export declare function markSnapshotCoordinationClosing(directory: string): void;
+export declare const _snapshotCoordinationInternals: {
+    entries: Map<string, ReadinessEntry>;
+    initialize: (directory: string) => Promise<void>;
+    renameLegacySnapshot: (from: string, to: string) => void;
+    writeProjection: (directory: string, snapshot: SnapshotData) => Promise<void>;
+    timeoutMs: number;
+};
+export {};

package/dist/session/snapshot-reader.d.ts

@@ -29,6 +29,8 @@ export declare function deserializeAgentSession(s: SerializedAgentSession): Agen
  * NEVER throws - always returns null on any error.
  */
 export declare function readSnapshot(directory: string): Promise<SnapshotData | null>;
+/** Strict single-candidate reader used by the SQLite import boundary. */
+export declare function readSnapshotFileStrict(directory: string, relativePath: string): Promise<SnapshotData>;
 /**
  * Rehydrate swarmState from a SnapshotData object.
  * Clears existing maps first, then populates from snapshot.

package/dist/session/snapshot-store.d.ts

@@ -0,0 +1,42 @@
+/** SQLite row mapping for durable session snapshots (#2481). */
+import type { SnapshotData } from './snapshot-writer.js';
+/** Test-only seam for interleaving a foreign writer after the first snapshot read. */
+export declare const _snapshotStoreInternals: {
+    afterSnapshotMetaRead: () => void;
+};
+interface DeletedSessionRowPayload {
+    ownerToken?: string;
+    reason: 'ended' | 'stale';
+}
+export interface SnapshotWriteOptions {
+    /** Do not let rehydrated foreign sessions overwrite their durable owners. */
+    onlyLocallyOwnedSessions?: boolean;
+}
+/**
+ * Mark a session as local for snapshot writes and reaping. Rehydration never
+ * calls this. Only a host invocation for the exact session may opt into
+ * takeover, which lets a restarted host resume its own session without letting
+ * a passive foreign rehydration overwrite a live peer.
+ */
+export declare function claimSnapshotSessionOwnership(sessionId: string, canTakeOver?: boolean): string;
+export declare function isSnapshotSessionOwnedLocally(sessionId: string): boolean;
+export declare function releaseSnapshotSessionOwnership(sessionId: string): void;
+export declare function clearSnapshotSessionOwnerships(): void;
+export declare function writeSnapshotRows(directory: string, snapshot: SnapshotData, options?: SnapshotWriteOptions): void;
+export declare function importSnapshotRowsOnce(directory: string, snapshot: SnapshotData, sourceDigest: string, source?: string): 'imported' | 'already_imported' | 'state_exists';
+export declare function readSnapshotRows(directory: string): SnapshotData | null;
+/**
+ * Confirm whether the authoritative durable row is genuinely stale before a
+ * local stale sweep is allowed to tombstone it.
+ *
+ * This re-reads SQLite rather than trusting the caller's in-memory copy so a
+ * peer process with a frozen snapshot cannot delete a still-fresh live row.
+ * Missing rows are treated as safe-to-evict: there is no durable authority left
+ * to protect.
+ */
+export declare function isSnapshotSessionAuthoritativelyStale(directory: string, sessionId: string, staleDurationMs: number, now?: number): boolean;
+/** Remove the complete authoritative snapshot as one FULL transaction. */
+export declare function clearSnapshotRows(directory: string): number;
+/** Tombstone the session-keyed rows removed by a host lifecycle event. */
+export declare function deleteSnapshotSessionRows(directory: string, sessionId: string, reason?: DeletedSessionRowPayload['reason']): number;
+export {};

package/dist/session/snapshot-writer.d.ts

@@ -1,11 +1,13 @@
 /**
  * Session snapshot writer for OpenCode Swarm plugin.
- * Serializes swarmState to .swarm/session/state.json using atomic write (temp-file + rename).
+ * Persists swarmState as independently keyed SQLite coordination rows and a
+ * non-authoritative, versioned file projection.
  */
 import { rename as fsRename } from 'node:fs/promises';
 import { TASK_WORKFLOW_SCHEMA_MARKER } from '../gate-evidence.js';
 import type { AgentSessionState, DelegationEntry, ToolAggregate } from '../state';
 import { swarmState } from '../state';
+export declare const SNAPSHOT_PROJECTION_FILE = "session/state.sqlite-projection.json";
 /**
  * Windows can transiently fail a rename with EEXIST/EBUSY/EPERM while another
  * process (an external snapshot reader, an AV scanner) briefly holds the
@@ -144,6 +146,7 @@ export declare function serializeAgentSession(s: AgentSessionState): SerializedA
  * Silently swallows errors (non-fatal — never crash the plugin).
  */
 export declare function writeSnapshot(directory: string, state: typeof swarmState): Promise<void>;
+export declare function writeSnapshotProjection(directory: string, snapshot: SnapshotData): Promise<void>;
 /**
  * Create a snapshot writer hook suitable for use in tool.execute.after.
  * Writes state immediately on every call.  Concurrent calls are serialised so

package/dist/state.d.ts

@@ -568,6 +568,14 @@ export interface AgentSessionState {
     resumeModelAdvisoryDone?: boolean;
     /** One-shot guard: the config-vs-UI model advisory has fired for this session (#1896). */
     configModelAdvisoryDone?: boolean;
+    /**
+     * One-shot guard: the first-run non-architect advisory has fired for this
+     * session (#2493 K3 UX-3). Keyed by sessionID only — "session starts on a
+     * non-architect agent" is operationalized as the first user message
+     * arriving on a non-architect agent (the OpenCode plugin v1 shape has no
+     * session-start hook).
+     */
+    nonArchitectAdvisoryDone?: boolean;
 }
 export type NonTransientErrorCategory = 'shell_parse_error' | 'command_not_found' | 'sandbox_wrapper_failure' | 'general_permanent';
 export interface NonTransientCircuitState {
@@ -1003,9 +1011,10 @@ export declare function isReviewerScopeGenerationCurrent(input: {
  *
  * @param staleDurationMs - Age threshold in ms (default 2h)
  * @param now - Current time in ms (injectable for deterministic tests)
+ * @param directory - Optional project root whose locally-owned durable rows are tombstoned
  * @returns The list of evicted session IDs
  */
-export declare function sweepStaleSessions(staleDurationMs?: number, now?: number): string[];
+export declare function sweepStaleSessions(staleDurationMs?: number, now?: number, directory?: string): string[];
 /**
  * Opportunistic, cooldown-guarded wrapper around sweepStaleSessions, intended
  * to be called from a frequently-hit code path (per-tool-call accounting in
@@ -1024,9 +1033,10 @@ export declare function sweepStaleSessions(staleDurationMs?: number, now?: numbe
  *
  * @param staleDurationMs - Age threshold in ms (default 2h)
  * @param now - Current time in ms (injectable for deterministic tests)
+ * @param directory - Optional project root whose durable rows are tombstoned
  * @returns Evicted session IDs ([] when the cooldown blocks this run)
  */
-export declare function maybeSweepStaleSessions(staleDurationMs?: number, now?: number): string[];
+export declare function maybeSweepStaleSessions(staleDurationMs?: number, now?: number, directory?: string): string[];
 /**
  * Start a new agent session with initialized guardrail state.
  * Also removes any stale sessions older than staleDurationMs.
@@ -1042,8 +1052,9 @@ export declare function startAgentSession(sessionId: string, agentName: string,
  * teardown) to prevent unbounded Map growth. Double-calls are safe: Map.delete is
  * a no-op for missing keys (FR-010).
  * @param sessionId - The session identifier to remove
+ * @param directory - Optional project root whose durable snapshot row must be tombstoned
  */
-export declare function endAgentSession(sessionId: string): void;
+export declare function endAgentSession(sessionId: string, directory?: string): void;
 /**
  * Get an agent session state by session ID.
  * @param sessionId - The session identifier

package/dist/tools/repo-graph/builder.d.ts

@@ -12,6 +12,7 @@
  */
 import { extractFileSymbols } from '../../lang/symbol-graph';
 import { extractDartSymbols, extractGoSymbols, extractPhpSymbols, extractPythonSymbols, extractRubySymbols, extractRustSymbols, extractTSSymbols } from '../symbols';
+import { type ImportBinding, type ParsedImport } from './fallback-scanner';
 import { extractFileOntology } from './ontology';
 import { safeRealpathSync } from './safe-realpath';
 import type { BuildWorkspaceGraphOptions, GraphEdge, GraphExtractorInputWitness, GraphNode, RepoGraph, RepoGraphDiagnostics, SymbolEdge } from './types';
@@ -96,31 +97,6 @@ export declare function addEdge(graph: RepoGraph, edge: GraphEdge): void;
  * @returns Resolved absolute path or null if unresolvable
  */
 export declare function resolveModuleSpecifier(workspaceRoot: string, sourceFile: string, specifier: string): string | null;
-/**
- * A parsed import with its specifier and type.
- */
-/**
- * A single imported binding: the symbol's *exported* name in the target file
- * and the *local* name it is bound to in the importing file (differs when an
- * `as` alias or default import is used). Used to attribute call-site usage back
- * to the correct exported symbol.
- */
-interface ImportBinding {
-    imported: string;
-    local: string;
-}
-interface ParsedImport {
-    /** The module specifier (e.g., './foo', 'lodash') */
-    specifier: string;
-    /** The type of import */
-    importType: 'default' | 'named' | 'namespace' | 'require' | 'sideeffect' | 'type';
-    /** Named imported symbols when statically detectable */
-    importedSymbols: string[];
-    /** Alias-aware imported→local bindings for usage attribution */
-    bindings: ImportBinding[];
-    /** True for `export { x } from '...'` re-exports (symbols are re-exposed). */
-    reExport: boolean;
-}
 /**
  * Strip line (`//…`) and block (`/* … *\/`) comments from JS/TS source while
  * preserving string, template-literal, and regex-literal contents (DD-C010).

package/dist/tools/repo-graph/cache.d.ts

@@ -13,7 +13,7 @@ export declare function getCachedGraph(workspace: string): RepoGraph | undefined
  * Cache a graph and mark it clean. Omitting mtime clears any previous mtime so
  * an old optimistic-concurrency witness cannot survive a new graph value.
  */
-export declare function setCachedGraph(workspace: string, graph: RepoGraph, mtime?: number): void;
+export declare function setCachedGraph(workspace: string, graph: RepoGraph, mtime?: number, ino?: number | string, size?: number): void;
 /** Mark a workspace's cached state dirty, preserving its graph and mtime. */
 export declare function markDirty(workspace: string): void;
 /** Return whether the workspace's cached state is dirty. */
@@ -22,3 +22,7 @@ export declare function isDirty(workspace: string): boolean;
 export declare function clearCache(workspace: string): void;
 /** Return the graph-file mtime captured with the cached graph, if present. */
 export declare function getCachedMtime(workspace: string): number | undefined;
+/** Return the graph-file inode/file-id captured with the cached graph. */
+export declare function getCachedIno(workspace: string): string | undefined;
+/** Return the graph-file byte size captured with the cached graph. */
+export declare function getCachedSize(workspace: string): number | undefined;

package/dist/tools/repo-graph/fallback-scanner.d.ts

@@ -0,0 +1,71 @@
+import type { GraphEdge, GraphNode } from './types';
+export interface ImportBinding {
+    imported: string;
+    local: string;
+}
+export interface ParsedImport {
+    specifier: string;
+    importType: GraphEdge['importType'];
+    importedSymbols: string[];
+    bindings: ImportBinding[];
+    reExport: boolean;
+}
+interface FileStat {
+    size: number;
+    mtime: Date;
+    mtimeMs: number;
+}
+interface OntologyInput {
+    moduleName: string;
+    filePath: string;
+    content: string;
+    language: string;
+    exports: string[];
+    imports: string[];
+    hasManifest?: (relDir: string) => boolean;
+}
+export interface FallbackScannerDependencies {
+    statFile: (filePath: string) => FileStat;
+    readFile: (filePath: string) => string;
+    isBinaryContent: (content: string) => boolean;
+    extractExports: (filePath: string, absoluteRoot: string) => {
+        exports: string[];
+        exportLines: Record<string, number>;
+    };
+    parseImports: (content: string, filePath: string, absoluteRoot: string) => ParsedImport[];
+    stripComments: (content: string) => string;
+    toModuleName: (filePath: string, absoluteRoot: string) => string;
+    getLanguage: (filePath: string) => string;
+    extractOntology: (input: OntologyInput) => GraphNode['ontology'];
+    resolveSpecifier: (absoluteRoot: string, filePath: string, specifier: string) => string | null;
+    usedSymbolsForImport: (parsedImport: ParsedImport, strippedContent: string) => string[] | undefined;
+    isScannableSourcePath: (filePath: string) => boolean;
+}
+export type FallbackScanOutcome = {
+    status: 'scanned';
+    node: GraphNode & Required<Pick<GraphNode, 'sizeBytes' | 'mtimeMs'>>;
+    edges: GraphEdge[];
+} | {
+    status: 'skipped';
+    reason: 'oversized' | 'unreadable' | 'binary' | 'malformed';
+    moduleName: string;
+    language?: string;
+    sizeBytes?: number;
+    mtimeMs?: number;
+};
+export interface FallbackScanOptions {
+    filePath: string;
+    absoluteRoot: string;
+    maxFileSize: number;
+    hasManifest?: (relDir: string) => boolean;
+    dependencies: FallbackScannerDependencies;
+}
+/**
+ * Bounded, fail-open boundary for the legacy parser-based file scanner.
+ *
+ * All filesystem access happens before parser work, with the size cap enforced
+ * before content is read. Language extraction and resolution stay injectable so
+ * builder tests can replace them without process-wide module mocks.
+ */
+export declare function runFallbackScan({ filePath, absoluteRoot, maxFileSize, hasManifest, dependencies, }: FallbackScanOptions): FallbackScanOutcome;
+export {};

package/dist/tools/repo-graph/indexed-storage.d.ts

@@ -25,6 +25,8 @@
  * statement's placeholder count equals its argument count exactly and
  * no-placeholder statements are issued as `db.run(sql)` with no array.
  */
+import type { Database } from 'bun:sqlite';
+import { unlinkSync } from 'node:fs';
 import type { GraphNode, RepoGraph } from './types';
 /** Filename of the derived index inside `.swarm/`. */
 export declare const REPO_MEMORY_FILENAME = "repo-memory.sqlite";
@@ -34,6 +36,7 @@ export declare const REPO_MEMORY_FILENAME = "repo-memory.sqlite";
  * validateSymlinkBoundary.
  */
 export declare function getRepoMemoryPath(workspace: string): string;
+declare function cacheHandle(storePath: string, db: Database): void;
 /**
  * Close the cached connection for a workspace. Called by the `/swarm close`
  * clean stage before unlinking the store (Windows holds a WAL-mode file open,
@@ -55,6 +58,7 @@ export declare function closeAllRepoMemory(): void;
  * otherwise.
  */
 export declare function deleteRepoMemory(workspace: string): void;
+declare function removeRepoMemoryFiles(workspace: string): boolean;
 /** Whether a SQLite driver is resolvable in this runtime. */
 export declare function isIndexedStorageAvailable(): boolean;
 /**
@@ -74,6 +78,12 @@ export declare function resolveGraphStorageMode(workspace: string): 'json' | 'in
  */
 export declare const _internals: {
     isIndexedStorageAvailable: typeof isIndexedStorageAvailable;
+    removeRepoMemoryFiles: typeof removeRepoMemoryFiles;
+    unlinkSync: typeof unlinkSync;
+    cacheHandle: typeof cacheHandle;
+    maxOpenHandles: number;
+    openHandleCount: () => number;
+    hasOpenHandle: (workspace: string) => boolean;
 };
 /**
  * Replace the whole index from `graph` in one transaction.
@@ -134,3 +144,4 @@ export declare function queryNodeByFile(workspace: string, file: string): GraphN
  * `maxDepth = 0` blast radius early-returns, query.ts:613-621).
  */
 export declare function loadSubgraphForFiles(workspace: string, files: string[], depth: number): RepoGraph | null;
+export {};

package/dist/tools/repo-graph/storage.d.ts

@@ -22,7 +22,13 @@ export declare const _internals: {
     fsRename: typeof fsPromises.rename;
     retryDelayMs: number;
     writeFingerprint: typeof writeFingerprint;
+    cacheArtifactMatches: typeof cacheArtifactMatches;
 };
+declare function cacheArtifactMatches(cachedMtime: number | undefined, cachedIno: string | undefined, cachedSize: number | undefined, stats: {
+    mtimeMs: number;
+    ino: number;
+    size: number;
+}): boolean;
 /**
  * Get the validated path for the repo-graph.json file.
  * Resolves symlinks via realpath before validation to prevent
@@ -78,3 +84,4 @@ export declare function loadOrCreateGraph(workspace: string): Promise<RepoGraph>
  * @throws Error if save fails
  */
 export declare function saveIfDirty(workspace: string, freshnessOptions?: FreshnessOptions): Promise<void>;
+export {};

package/dist/turbo/epic/state.d.ts

@@ -1,14 +1,9 @@
 /**
- * Durable Epic Mode session state (Capability C).
+ * Durable Epic Mode session state.
  *
- * Persists per-session Epic Mode activation state under
- * `<projectRoot>/.swarm/epic-state.json` so toggling survives process
- * restarts. Mirrors the pattern in `src/turbo/lean/state.ts` (atomic
- * `tmp + rename`, per-directory `stateUnreadableMap` for fail-closed
- * semantics, sessions-keyed shape) — without modifying that file.
- *
- * Dependency direction is one-way: this module imports nothing from
- * `src/turbo/lean/`. The shape is parallel but independent.
+ * The authoritative store is the per-project SQLite coordination DB, with one
+ * row per session. `.swarm/epic-state.json` remains a compatibility
+ * projection and import source during the cutover.
  */
 /** Top-level state for a single session. */
 export interface EpicSessionState {
@@ -49,17 +44,6 @@ export declare function isEpicModeActive(directory: string, sessionID: string):
 /**
  * True iff epic mode is currently active for ANY session in the project.
  *
- * Use this when a code path needs to know "is the project running under
- * Epic Mode right now" without caring which session toggled it. The
- * session-scoped `isEpicModeActive` answers "did THIS session toggle it" —
- * a different question with a different answer.
- *
- * The architect's session enables Epic via `/swarm epic on`; sub-agents
- * (coders, reviewers) dispatched through the `Task` tool run in their own
- * sessions and have no record of that toggle. Asking the project-scoped
- * check is the only correct way to honor Epic Mode from those flows.
- * Rule 2's auto-commit (centralized in Phase 5) is the canonical caller.
- *
  * Fail-closed: returns `false` on unreadable state, matching the rest of
  * this module's defaults.
  */