@claude-flow/cli 3.55.0 → 3.56.1

package/dist/src/memory/memory-initializer.js

@@ -1,14 +1,5 @@
-/**
- * V3 Memory Initializer
- * Properly initializes the memory database with sql.js (WASM SQLite)
- * Includes pattern tables, vector embeddings, migration state tracking
- *
- * ADR-053: Routes through ControllerRegistry → AgentDB v3 when available,
- * falls back to raw sql.js for backwards compatibility.
- *
- * @module v3/cli/memory-initializer
- */
 import { loadBetterSqlite3 } from './shared-sqlite.js';
+import { resolveMemoryRoot } from './memory-root.js';
 import { liveMemoryRowSql } from './live-memory-row.js';
 import { encodeEmbeddingQ8, MAX_LIST_EMBEDDINGS } from './embedding-q8.js';
 import * as fs from 'fs';
@@ -59,25 +50,88 @@ function isRuvectorCoreResolvable() {
     return _ruvectorCoreResolvable;
 }
 /**
- * #2735 — before a whole-image sql.js read-modify-persist (export() +
- * rename over the live database path), refuse if there is evidence of a
- * live native (better-sqlite3) WAL connection: `-wal`/`-shm` sidecar files
- * on disk. A native connection in WAL mode keeps its sidecars present for
- * its entire lifetime (removed only on the last connection's clean close),
- * so their presence is strong evidence of a live native holder — and their
- * absence means the image is a clean, checkpointed, standalone file that
- * sql.js can safely read-modify-write.
+ * #2735 / #3161 — before a whole-image sql.js read-modify-persist (export() +
+ * rename over the live database path), refuse if a native (better-sqlite3)
+ * WAL connection is actually LIVE. `-wal`/`-shm` sidecar presence alone is
+ * not proof of that: #3161 found `ruflo doctor`'s readonly diagnostic
+ * connections leave orphaned sidecars behind after a plain `.close()` (WAL
+ * mode does not checkpoint on close unless the closing connection was the
+ * last holder in a state that triggers one), permanently blocking every
+ * later write in that project.
+ *
+ * Liveness is probed in two steps, because a single `wal_checkpoint`
+ * busy-check is not sufficient on its own:
+ *
+ *  1. Open our own probe connection and run `PRAGMA wal_checkpoint(TRUNCATE)`.
+ *     `busy !== 0` means another connection genuinely holds a lock blocking
+ *     the checkpoint RIGHT NOW (an open transaction) — unsafe, refuse
+ *     immediately. This also truncates a genuinely-orphaned WAL as a side
+ *     effect.
+ *  2. If `busy === 0`, close our probe connection and re-check whether the
+ *     sidecars are still on disk. SQLite only deletes `-wal`/`-shm` when the
+ *     LAST connection to the database closes. If nothing else is attached,
+ *     OUR close is that last close and the sidecars vanish — safe, proceed.
+ *     If they are still present after our own close, some OTHER connection
+ *     is still attached (even idle, holding no lock — e.g. a foreign native
+ *     handle that already finished its last statement), so step 1's
+ *     busy-check alone would have missed it. Refuse.
  *
- * This is a scoped-down version of the fuller "scan live process holders"
- * design discussed in #2735: it does not close the narrow assess-then-write
- * race (a native opener could still attach in the gap between this check
- * and the write), but it directly closes the demonstrated corruption
- * mechanism — a whole-image write proceeding while an ALREADY-OPEN native
- * connection's sidecars are on disk — with no platform-specific process
- * scanning. Fails closed (treats a stat error as "unsafe") because this is
- * a safety gate, not a best-effort probe.
+ * Step 2 is what makes this safe against an idle-but-attached native
+ * connection (an open handle holding no lock does not block checkpointing,
+ * so step 1 alone would report "safe" even though a real holder is still
+ * attached) without resorting to platform-specific process scanning.
+ *
+ * The common case (no sidecars at all) stays a couple of cheap `existsSync`
+ * calls — a DB connection is only opened when a sidecar is actually present
+ * to investigate.
+ *
+ * This is still a scoped-down version of the fuller "scan live process
+ * holders" design discussed in #2735: it does not close the narrow
+ * assess-then-write race (a native opener could still attach in the gap
+ * between this check and the write), but it directly closes the
+ * demonstrated corruption mechanism — a whole-image write proceeding while
+ * an ALREADY-OPEN native connection genuinely holds the file — with no
+ * platform-specific process scanning. Fails closed (treats any probe error
+ * as "unsafe") because this is a safety gate, not a best-effort probe.
  */
-function hasNativeWalSidecars(dbPath) {
+async function hasNativeWalSidecars(dbPath) {
+    try {
+        if (!fs.existsSync(`${dbPath}-wal`) && !fs.existsSync(`${dbPath}-shm`)) {
+            return false;
+        }
+    }
+    catch {
+        return true;
+    }
+    let db;
+    try {
+        const Database = await loadBetterSqlite3();
+        const opened = new Database(dbPath);
+        db = opened;
+        // Report busy immediately instead of retrying for the driver's default
+        // (multi-second) busy_timeout — a live holder's checkpoint-blocking
+        // lock is a steady-state fact at probe time, not a transient we should
+        // wait out, and this is a safety gate on a hot write path.
+        opened.pragma('busy_timeout = 0');
+        const [{ busy }] = opened.pragma('wal_checkpoint(TRUNCATE)');
+        if (busy !== 0)
+            return true;
+    }
+    catch {
+        return true;
+    }
+    finally {
+        try {
+            db?.close();
+        }
+        catch {
+            // best-effort
+        }
+    }
+    // Nothing was mid-transaction at probe time, and our own (now-closed)
+    // probe connection just truncated the WAL. If the sidecars are still
+    // here, another connection is still attached and kept them alive through
+    // our close.
     try {
         return fs.existsSync(`${dbPath}-wal`) || fs.existsSync(`${dbPath}-shm`);
     }
@@ -123,34 +177,7 @@ let _memoryRootCache;
 export function getMemoryRoot() {
     if (_memoryRootCache !== undefined)
         return _memoryRootCache;
-    // 1. Env var
-    const envPath = process.env.CLAUDE_FLOW_MEMORY_PATH;
-    if (envPath && envPath.trim().length > 0) {
-        _memoryRootCache = path.resolve(envPath);
-        return _memoryRootCache;
-    }
-    // 2. Config file (claude-flow.config.json)
-    const configCandidates = [
-        path.resolve(process.cwd(), 'claude-flow.config.json'),
-        path.resolve(process.cwd(), '.claude-flow', 'config.json'),
-    ];
-    for (const configPath of configCandidates) {
-        if (!fs.existsSync(configPath))
-            continue;
-        try {
-            const raw = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-            const fromConfig = raw?.memory?.persistPath ?? raw?.memory?.path;
-            if (typeof fromConfig === 'string' && fromConfig.trim().length > 0) {
-                _memoryRootCache = path.resolve(fromConfig);
-                return _memoryRootCache;
-            }
-        }
-        catch {
-            /* malformed config — fall through to default */
-        }
-    }
-    // 3. Default
-    _memoryRootCache = path.resolve(process.cwd(), '.swarm');
+    _memoryRootCache = resolveMemoryRoot(process.cwd());
     return _memoryRootCache;
 }
 /** For tests + the `memory configure` flow that mutates the config at runtime. */
@@ -1208,7 +1235,11 @@ export async function ensureSchemaColumns(dbPath, options = {}) {
             if (columnsAdded.includes('status') || existingColumns.has('status')) {
                 try {
                     db.run(`UPDATE memory_entries SET status = 'active' WHERE status IS NULL`);
-                    modified = true;
+                    // #3918: only a backfill that changed rows dirties the image. Setting
+                    // this unconditionally rewrote every up-to-date store on each open (and,
+                    // with encryption at rest, with a fresh nonce, so the bytes changed too).
+                    if (db.getRowsModified() > 0)
+                        modified = true;
                 }
                 catch {
                     /* table is read-only or doesn't exist — skip */
@@ -2532,6 +2563,9 @@ export async function verifyMemoryInit(dbPath, options) {
  * This bypasses MCP and writes directly to the database
  */
 export async function storeEntry(options) {
+    if (options.appendOnly && !options.requireNative) {
+        return { success: false, id: '', error: 'Immutable append requires a native writer' };
+    }
     // ADR-323: validate before touching either backend so an invalid value
     // gets one clear error instead of a raw SQLite CHECK-constraint failure
     // from whichever path (bridge vs sql.js) happens to run.
@@ -2563,8 +2597,12 @@ export async function storeEntry(options) {
             return bridgeResult;
         }
     }
+    if (options.requireNative || options.appendConditions) {
+        return { success: false, id: '', error: 'Native memory writer required; refusing whole-image sql.js fallback' };
+    }
     // Fallback: raw sql.js
-    const { key, value, namespace = 'default', generateEmbeddingFlag = true, tags = [], ttl, dbPath: customPath, upsert = false, provenanceType } = options;
+    const { key, value, namespace = 'default', generateEmbeddingFlag = true, tags = [], ttl, dbPath: customPath, upsert: requestedUpsert = false, provenanceType } = options;
+    const upsert = requestedUpsert && !options.appendOnly;
     const swarmDir = getMemoryRoot();
     const dbPath = customPath ? path.resolve(customPath) : path.join(swarmDir, 'memory.db');
     try {
@@ -2578,7 +2616,7 @@ export async function storeEntry(options) {
         // race). This check gates ensureSchemaColumns()'s own whole-image
         // write below too, not just this function's.
         await releaseOwnNativeHandle(dbPath);
-        if (hasNativeWalSidecars(dbPath)) {
+        if (await hasNativeWalSidecars(dbPath)) {
             return {
                 success: false,
                 id: '',
@@ -2985,7 +3023,7 @@ export async function listEntries(options) {
         // Listing can migrate/backfill the schema, so it is also a whole-image
         // writer. The newly selected native mirror may still have a live WAL.
         await releaseOwnNativeHandle(dbPath);
-        if (hasNativeWalSidecars(dbPath)) {
+        if (await hasNativeWalSidecars(dbPath)) {
             return { success: false, entries: [], total: 0, error: await walRefusalError('read/write') };
         }
         // Ensure schema has all required columns (migration for older DBs)
@@ -3097,7 +3135,7 @@ export async function getEntry(options) {
         // bump is itself a whole-image write, not a lightweight read, even
         // though this function's contract reads as a "get".
         await releaseOwnNativeHandle(dbPath);
-        if (hasNativeWalSidecars(dbPath)) {
+        if (await hasNativeWalSidecars(dbPath)) {
             return {
                 success: false,
                 found: false,
@@ -3217,7 +3255,7 @@ export async function deleteEntry(options) {
         // #2735 — see storeEntry's identical gate for the corruption mechanism
         // this closes.
         await releaseOwnNativeHandle(dbPath);
-        if (hasNativeWalSidecars(dbPath)) {
+        if (await hasNativeWalSidecars(dbPath)) {
             return {
                 success: false,
                 deleted: false,
@@ -3437,7 +3475,7 @@ export async function purgeNamespace(options) {
             }
             // Recheck at mutation time even when the CLI already read a preview.
             await releaseOwnNativeHandle(dbPath);
-            if (hasNativeWalSidecars(dbPath)) {
+            if (await hasNativeWalSidecars(dbPath)) {
                 return { success: false, deletedCount: 0, remainingEntries: 0, error: await walRefusalError('write') };
             }
             await ensureSchemaColumns(dbPath, options);

package/dist/src/memory/memory-root.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveMemoryRoot(cwd: string): string;
+//# sourceMappingURL=memory-root.d.ts.map

package/dist/src/memory/memory-root.js

@@ -0,0 +1,28 @@
+/** Uncached memory-directory authority for an explicit project directory. */
+import * as fs from 'fs';
+import * as path from 'path';
+export function resolveMemoryRoot(cwd) {
+    const envPath = process.env.CLAUDE_FLOW_MEMORY_PATH;
+    if (envPath && envPath.trim().length > 0)
+        return path.resolve(cwd, envPath);
+    const configCandidates = [
+        path.resolve(cwd, 'claude-flow.config.json'),
+        path.resolve(cwd, '.claude-flow', 'config.json'),
+    ];
+    for (const configPath of configCandidates) {
+        if (!fs.existsSync(configPath))
+            continue;
+        try {
+            const raw = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+            const fromConfig = raw?.memory?.persistPath ?? raw?.memory?.path;
+            if (typeof fromConfig === 'string' && fromConfig.trim().length > 0) {
+                return path.resolve(cwd, fromConfig);
+            }
+        }
+        catch {
+            /* malformed config — fall through to default */
+        }
+    }
+    return path.resolve(cwd, '.swarm');
+}
+//# sourceMappingURL=memory-root.js.map

package/dist/src/memory/sona-optimizer.d.ts

@@ -93,6 +93,8 @@ export interface SONAStats {
         agents: number;
     } | 'unavailable';
 }
+/** Agent roles supported by the SONA routing optimizer. */
+export declare function isSupportedSonaAgent(agent: string): boolean;
 /**
  * SONA Optimizer for adaptive routing based on trajectory outcomes
  *

package/dist/src/memory/sona-optimizer.js

@@ -61,6 +61,10 @@ const AGENT_TYPES = [
     'security-architect',
     'performance-engineer',
 ];
+/** Agent roles supported by the SONA routing optimizer. */
+export function isSupportedSonaAgent(agent) {
+    return AGENT_TYPES.includes(agent);
+}
 /**
  * Task keywords for pattern extraction
  */

package/dist/src/parser.js

@@ -568,6 +568,13 @@ export class CommandParser {
             if (opt.required && (flags[key] === undefined || flags[key] === '')) {
                 errors.push(`Required option missing: --${opt.name}`);
             }
+            // A value-taking option given with nothing after it (`--task`, `--key` at the end, or
+            // followed by another flag) is parsed as boolean `true`. Commands then treat `true` as
+            // the value: `hooks route --task` crashed with "task.trim is not a function" and
+            // `memory retrieve --key` looked up the key "true". Report it instead.
+            if ((opt.type === 'string' || opt.type === 'number') && flags[key] === true) {
+                errors.push(`Option --${opt.name} needs a value`);
+            }
             // Check choices
             if (opt.choices && flags[key] !== undefined) {
                 const value = String(flags[key]);

package/dist/src/plugins/store/discovery.d.ts

@@ -32,6 +32,12 @@ export interface PluginDiscoveryResult {
     source?: string;
     fromCache?: boolean;
     error?: string;
+    /**
+     * True when the signed registry could not be fetched or verified and the CLI fell back to
+     * its built-in plugin list. That list is safe to use (fixed, first-party npm names), but it
+     * is NOT the verified registry, and callers must say so rather than report a discovery.
+     */
+    demo?: boolean;
 }
 /**
  * Plugin Discovery Service

package/dist/src/plugins/store/discovery.js

@@ -3,7 +3,6 @@
  * Discovers plugin registries via IPNS and fetches from IPFS
  * Parallel implementation to pattern store for plugins
  */
-import * as crypto from 'crypto';
 import { resolveIPNS, fetchFromIPFS, verifyEd25519Signature } from '../../transfer/ipfs/client.js';
 /**
  * Fetch real npm download stats for a package
@@ -115,7 +114,9 @@ export class PluginDiscoveryService {
                 success: true,
                 registry: cached.registry,
                 fromCache: true,
-                source: registry.name,
+                // A cached fallback is still the fallback: never relabel it as the real registry.
+                source: cached.demo ? `${registry.name} (demo)` : registry.name,
+                ...(cached.demo ? { demo: true } : {}),
             };
         }
         try {
@@ -223,13 +224,16 @@ export class PluginDiscoveryService {
         this.cache.set(registry.ipnsName, {
             registry: demoRegistry,
             timestamp: Date.now(),
+            demo: true,
         });
         return {
             success: true,
             registry: demoRegistry,
-            cid: `bafybeiplugin${crypto.randomBytes(16).toString('hex')}`,
+            // No CID: the built-in list was not fetched from IPFS. (This used to be a random
+            // `bafybeiplugin…` string, printed as "Registry CID" as if it were a real address.)
             source: `${registry.name} (demo)`,
             fromCache: false,
+            demo: true,
         };
     }
     /**

package/dist/src/ruvector/neural-router.js

@@ -288,8 +288,13 @@ async function resolveBackend(cfg) {
                     return r;
                 return {
                     route: (e) => {
-                        const result = r.route(e);
-                        return { ...result, predictedQuality: cal.transform(result.predictedQuality) };
+                        // Calibration can move a candidate across the quality bar. Select
+                        // from the calibrated predictions, not the raw router's old pick.
+                        const all = r.predictAll(e).map(c => ({ ...c, predictedQuality: cal.transform(c.predictedQuality) }));
+                        const clearing = all.filter(c => c.predictedQuality >= cfg.qualityBar)
+                            .sort((a, b) => a.costPerMTok - b.costPerMTok);
+                        const pick = clearing[0] ?? [...all].sort((a, b) => b.predictedQuality - a.predictedQuality)[0];
+                        return { ...pick, metBar: pick.predictedQuality >= cfg.qualityBar };
                     },
                     predictAll: (e) => r.predictAll(e).map(c => ({ ...c, predictedQuality: cal.transform(c.predictedQuality) })),
                 };

package/dist/src/services/claim-service.js

@@ -16,6 +16,7 @@ import { EventEmitter } from 'events';
 import * as fs from 'fs';
 import * as path from 'path';
 import { execFileSync } from 'child_process';
+import { readClaimsStore } from './claims-store.js';
 // ============================================================================
 // Default Configuration
 // ============================================================================
@@ -57,28 +58,29 @@ export class ClaimService extends EventEmitter {
         // Load existing claims
         await this.loadClaims();
     }
-    async loadClaims() {
-        const claimsFile = path.join(this.storagePath, 'claims.json');
-        if (fs.existsSync(claimsFile)) {
-            try {
-                const data = JSON.parse(fs.readFileSync(claimsFile, 'utf-8'));
-                for (const claim of data.claims || []) {
-                    claim.claimedAt = new Date(claim.claimedAt);
-                    claim.statusChangedAt = new Date(claim.statusChangedAt);
-                    if (claim.expiresAt)
-                        claim.expiresAt = new Date(claim.expiresAt);
-                    this.claims.set(claim.issueId, claim);
-                }
-            }
-            catch {
-                // Start fresh if file is corrupted
-            }
+    loadClaims() {
+        const data = readClaimsStore(path.join(this.storagePath, 'claims.json'));
+        const claims = new Map();
+        const stealable = new Map();
+        for (const claim of Object.values(data.claims)) {
+            claim.claimedAt = new Date(claim.claimedAt);
+            claim.statusChangedAt = new Date(claim.statusChangedAt);
+            if (claim.expiresAt)
+                claim.expiresAt = new Date(claim.expiresAt);
+            claims.set(claim.issueId, claim);
+        }
+        for (const [id, info] of Object.entries(data.stealable)) {
+            stealable.set(id, { ...info, stealableAt: new Date(info.stealableAt) });
         }
+        this.claims = claims;
+        this.stealableInfo = stealable;
     }
     async saveClaims() {
         const claimsFile = path.join(this.storagePath, 'claims.json');
         const data = {
-            claims: Array.from(this.claims.values()),
+            ...readClaimsStore(claimsFile),
+            claims: Object.fromEntries(this.claims),
+            stealable: Object.fromEntries(this.stealableInfo),
             savedAt: new Date().toISOString(),
         };
         fs.writeFileSync(claimsFile, JSON.stringify(data, null, 2));
@@ -87,6 +89,7 @@ export class ClaimService extends EventEmitter {
     // Core Claiming
     // ==========================================================================
     async claim(issueId, claimant) {
+        this.loadClaims();
         // Check if already claimed
         const existing = this.claims.get(issueId);
         if (existing && existing.status !== 'stealable') {
@@ -116,6 +119,7 @@ export class ClaimService extends EventEmitter {
         return { success: true, claim };
     }
     async release(issueId, claimant) {
+        this.loadClaims();
         const claim = this.claims.get(issueId);
         if (!claim) {
             throw new Error(`Issue ${issueId} is not claimed`);
@@ -137,6 +141,7 @@ export class ClaimService extends EventEmitter {
     // Handoffs
     // ==========================================================================
     async requestHandoff(issueId, from, to, reason) {
+        this.loadClaims();
         const claim = this.claims.get(issueId);
         if (!claim) {
             throw new Error(`Issue ${issueId} is not claimed`);
@@ -158,6 +163,7 @@ export class ClaimService extends EventEmitter {
         });
     }
     async acceptHandoff(issueId, claimant) {
+        this.loadClaims();
         const claim = this.claims.get(issueId);
         if (!claim || claim.status !== 'handoff-pending') {
             throw new Error(`No pending handoff for issue ${issueId}`);
@@ -181,6 +187,7 @@ export class ClaimService extends EventEmitter {
         });
     }
     async rejectHandoff(issueId, claimant, reason) {
+        this.loadClaims();
         const claim = this.claims.get(issueId);
         if (!claim || claim.status !== 'handoff-pending') {
             throw new Error(`No pending handoff for issue ${issueId}`);
@@ -205,6 +212,7 @@ export class ClaimService extends EventEmitter {
     // Status Updates
     // ==========================================================================
     async updateStatus(issueId, status, note) {
+        this.loadClaims();
         const claim = this.claims.get(issueId);
         if (!claim) {
             throw new Error(`Issue ${issueId} is not claimed`);
@@ -227,6 +235,7 @@ export class ClaimService extends EventEmitter {
         });
     }
     async updateProgress(issueId, progress) {
+        this.loadClaims();
         const claim = this.claims.get(issueId);
         if (!claim) {
             throw new Error(`Issue ${issueId} is not claimed`);
@@ -235,6 +244,7 @@ export class ClaimService extends EventEmitter {
         await this.saveClaims();
     }
     async requestReview(issueId, reviewers) {
+        this.loadClaims();
         const claim = this.claims.get(issueId);
         if (!claim) {
             throw new Error(`Issue ${issueId} is not claimed`);
@@ -254,6 +264,7 @@ export class ClaimService extends EventEmitter {
     // Work Stealing
     // ==========================================================================
     async markStealable(issueId, info) {
+        this.loadClaims();
         const claim = this.claims.get(issueId);
         if (!claim) {
             throw new Error(`Issue ${issueId} is not claimed`);
@@ -273,6 +284,7 @@ export class ClaimService extends EventEmitter {
         });
     }
     async steal(issueId, stealer) {
+        this.loadClaims();
         const claim = this.claims.get(issueId);
         if (!claim) {
             return { success: false, error: `Issue ${issueId} is not claimed` };
@@ -309,6 +321,7 @@ export class ClaimService extends EventEmitter {
         return { success: true, claim, previousOwner, context: info };
     }
     async getStealable(agentType) {
+        this.loadClaims();
         const stealable = [];
         for (const claim of this.claims.values()) {
             if (claim.status !== 'stealable')
@@ -323,6 +336,7 @@ export class ClaimService extends EventEmitter {
         return stealable;
     }
     async contestSteal(issueId, originalClaimant, reason) {
+        this.loadClaims();
         const claim = this.claims.get(issueId);
         if (!claim) {
             throw new Error(`Issue ${issueId} is not claimed`);
@@ -340,6 +354,7 @@ export class ClaimService extends EventEmitter {
     // Load Balancing
     // ==========================================================================
     async getAgentLoad(agentId) {
+        this.loadClaims();
         const claims = [];
         let blockedCount = 0;
         for (const claim of this.claims.values()) {
@@ -362,6 +377,7 @@ export class ClaimService extends EventEmitter {
         };
     }
     async rebalance(swarmId) {
+        this.loadClaims();
         const result = { moved: [], suggested: [] };
         // Get all agent loads
         const agentLoads = new Map();
@@ -410,6 +426,7 @@ export class ClaimService extends EventEmitter {
     // Queries
     // ==========================================================================
     async getClaimedBy(claimant) {
+        this.loadClaims();
         return Array.from(this.claims.values()).filter(c => this.isSameClaimant(c.claimant, claimant));
     }
     async getAvailableIssues(_filters) {
@@ -418,18 +435,22 @@ export class ClaimService extends EventEmitter {
         return [];
     }
     async getIssueStatus(issueId) {
+        this.loadClaims();
         return this.claims.get(issueId) || null;
     }
     async getAllClaims() {
+        this.loadClaims();
         return Array.from(this.claims.values());
     }
     async getByStatus(status) {
+        this.loadClaims();
         return Array.from(this.claims.values()).filter(c => c.status === status);
     }
     // ==========================================================================
     // Auto-Management
     // ==========================================================================
     async expireStale(maxAgeMinutes) {
+        this.loadClaims();
         const threshold = maxAgeMinutes ?? this.config.staleThresholdMinutes;
         const now = Date.now();
         const expired = [];
@@ -445,7 +466,7 @@ export class ClaimService extends EventEmitter {
                     progress: claim.progress,
                     context: `Stale: No activity for ${Math.round(age)} minutes`,
                 });
-                expired.push(claim);
+                expired.push(this.claims.get(claim.issueId));
             }
         }
         return expired;

package/dist/src/services/claims-store.d.ts

@@ -0,0 +1,3 @@
+/** Read legacy CLI arrays and MCP dictionaries; never replace unreadable state. */
+export declare function readClaimsStore(file: string): Record<string, unknown>;
+//# sourceMappingURL=claims-store.d.ts.map

package/dist/src/services/claims-store.js

@@ -0,0 +1,40 @@
+/** Shared on-disk shape for the CLI claim service and public MCP claim tools. */
+import { readFileSync } from 'node:fs';
+function record(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+/** Read legacy CLI arrays and MCP dictionaries; never replace unreadable state. */
+export function readClaimsStore(file) {
+    let text;
+    try {
+        text = readFileSync(file, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return { claims: {}, stealable: {}, contests: {} };
+        throw error;
+    }
+    const data = JSON.parse(text);
+    if (!record(data) || (!Array.isArray(data.claims) && !record(data.claims))) {
+        throw new Error('Invalid claims store: expected a claims array or object');
+    }
+    const entries = Array.isArray(data.claims)
+        ? data.claims.map((claim) => [record(claim) ? claim.issueId : undefined, claim])
+        : Object.entries(data.claims);
+    const claims = Object.create(null);
+    for (const [id, claim] of entries) {
+        if (typeof id !== 'string' || !id || !record(claim) || claim.issueId !== id ||
+            !record(claim.claimant) || typeof claim.status !== 'string' ||
+            typeof claim.claimedAt !== 'string' || typeof claim.statusChangedAt !== 'string' ||
+            Object.hasOwn(claims, id)) {
+            throw new Error('Invalid claims store: malformed or duplicate claim');
+        }
+        claims[id] = claim;
+    }
+    for (const key of ['stealable', 'contests']) {
+        if (data[key] !== undefined && !record(data[key]))
+            throw new Error(`Invalid claims store: ${key} must be an object`);
+    }
+    return { ...data, claims, stealable: data.stealable ?? {}, contests: data.contests ?? {} };
+}
+//# sourceMappingURL=claims-store.js.map

package/dist/src/services/config-file-manager.d.ts

@@ -18,8 +18,8 @@ export declare class ConfigFileManager {
     set(cwd: string, key: string, value: unknown): void;
     /** Create a new config file with defaults */
     create(cwd: string, overrides?: Record<string, unknown>, force?: boolean): string;
-    /** Reset config to defaults */
-    reset(cwd: string): string;
+    /** Reset all configuration or only the selected section to defaults. */
+    reset(cwd: string, section?: string): string;
     /** Export config to a specific path */
     exportTo(cwd: string, exportPath: string): void;
     /** Import config from a specific path */