@claude-flow/cli 3.54.1 → 3.55.0

package/dist/src/parser.d.ts

@@ -94,6 +94,9 @@ export declare class CommandParser {
      * commit message.)
      */
     private getScopedBooleanFlags;
+    /** Resolve declared types from broad to narrow without borrowing string
+     * declarations from unrelated registered commands. */
+    private getFlagScope;
     private getBooleanFlags;
     private applyDefaults;
     validateFlags(flags: ParsedFlags, command?: Command): string[];

package/dist/src/parser.js

@@ -135,14 +135,27 @@ export class CommandParser {
         // with `daemon` left as a positional.
         let resolvedCmd;
         let resolvedSub;
+        const resolvedCommands = [];
         let sawFirstPositional = false;
-        for (const arg of args) {
-            if (arg.startsWith('-'))
+        for (let index = 0; index < args.length; index++) {
+            const arg = args[index];
+            if (arg === '--')
+                break;
+            if (arg.startsWith('-')) {
+                // Pass 2 recognizes only contiguous subcommands after the root.
+                if (sawFirstPositional)
+                    break;
+                // Skip consumed values as well as flags: a global option value is not
+                // the command slot, even when it happens to name another command.
+                const scope = this.getFlagScope(resolvedCommands);
+                index = this.parseFlag(args, index, scope.aliases, scope.booleanFlags, scope.stringFlags).nextIndex - 1;
                 continue;
+            }
             if (!sawFirstPositional) {
                 sawFirstPositional = true;
                 if (this.commands.has(arg)) {
                     resolvedCmd = this.commands.get(arg);
+                    resolvedCommands.push(resolvedCmd);
                     continue;
                 }
                 // Lazy command: we know its name but not its subcommands. Stop the
@@ -153,14 +166,21 @@ export class CommandParser {
                 // Unknown first positional — not a command. Stop walking.
                 break;
             }
-            if (resolvedCmd && !resolvedSub && resolvedCmd.subcommands) {
-                resolvedSub = resolvedCmd.subcommands.find(sc => sc.name === arg || sc.aliases?.includes(arg));
+            // Match the same supported command depth as Pass 2, with each option
+            // declaration taking precedence over its parent scope.
+            const parent = resolvedCommands[resolvedCommands.length - 1];
+            if (resolvedCommands.length < 4 && parent?.subcommands) {
+                const child = parent.subcommands.find(sc => sc.name === arg || sc.aliases?.includes(arg));
+                if (child) {
+                    resolvedCommands.push(child);
+                    resolvedSub ??= child;
+                    continue;
+                }
             }
+            // A positional that is not the next subcommand ends the command path.
+            break;
         }
-        // Pass 2: Build aliases scoped to the resolved subcommand
-        // Subcommand-specific aliases take priority over global ones
-        const aliases = this.buildScopedAliases(resolvedSub || resolvedCmd);
-        const booleanFlags = this.getScopedBooleanFlags(resolvedSub || resolvedCmd);
+        const { aliases, booleanFlags, stringFlags } = this.getFlagScope(resolvedCommands);
         let i = 0;
         let parsingFlags = true;
         while (i < args.length) {
@@ -173,7 +193,7 @@ export class CommandParser {
             }
             // Handle flags
             if (parsingFlags && arg.startsWith('-')) {
-                const parseResult = this.parseFlag(args, i, aliases, booleanFlags);
+                const parseResult = this.parseFlag(args, i, aliases, booleanFlags, stringFlags);
                 // Apply to result flags
                 Object.assign(result.flags, parseResult.flags);
                 i = parseResult.nextIndex;
@@ -231,7 +251,7 @@ export class CommandParser {
         this.applyDefaults(result.flags, resolvedCmd, resolvedSub);
         return result;
     }
-    parseFlag(args, index, aliases, booleanFlags) {
+    parseFlag(args, index, aliases, booleanFlags, stringFlags) {
         const flags = { _: [] };
         const arg = args[index];
         let nextIndex = index + 1;
@@ -242,7 +262,8 @@ export class CommandParser {
                 // --flag=value
                 const key = arg.slice(2, equalIndex);
                 const value = arg.slice(equalIndex + 1);
-                flags[this.normalizeKey(key)] = this.parseValue(value);
+                const normalizedKey = this.normalizeKey(key);
+                flags[normalizedKey] = stringFlags.has(normalizedKey) ? value : this.parseValue(value);
             }
             else if (arg.startsWith('--no-')) {
                 // --no-flag (boolean negation)
@@ -266,7 +287,7 @@ export class CommandParser {
                     }
                 }
                 else if (nextIndex < args.length && this.isFlagValue(args[nextIndex])) {
-                    flags[normalizedKey] = this.parseValue(args[nextIndex]);
+                    flags[normalizedKey] = stringFlags.has(normalizedKey) ? args[nextIndex] : this.parseValue(args[nextIndex]);
                     nextIndex++;
                 }
                 else {
@@ -293,7 +314,7 @@ export class CommandParser {
                     }
                 }
                 else if (nextIndex < args.length && this.isFlagValue(args[nextIndex])) {
-                    flags[normalizedKey] = this.parseValue(args[nextIndex]);
+                    flags[normalizedKey] = stringFlags.has(normalizedKey) ? args[nextIndex] : this.parseValue(args[nextIndex]);
                     nextIndex++;
                 }
                 else {
@@ -439,6 +460,36 @@ export class CommandParser {
         }
         return flags;
     }
+    /** Resolve declared types from broad to narrow without borrowing string
+     * declarations from unrelated registered commands. */
+    getFlagScope(commands) {
+        const aliases = this.buildScopedAliases(commands[commands.length - 1]);
+        const booleanFlags = this.getScopedBooleanFlags(commands[commands.length - 1]);
+        const stringFlags = new Set((this.options.stringFlags ?? []).map(flag => this.normalizeKey(flag)));
+        for (const command of commands) {
+            for (const option of command.options ?? []) {
+                if (option.short)
+                    aliases[option.short] = option.name;
+            }
+        }
+        const layers = [this.globalOptions, ...commands.map(command => command.options ?? [])];
+        for (const options of layers) {
+            for (const option of options) {
+                const key = this.normalizeKey(option.name);
+                if (option.type === 'string')
+                    stringFlags.add(key);
+                else if (option.type)
+                    stringFlags.delete(key);
+                if (option.type === 'boolean')
+                    booleanFlags.add(key);
+                else if (option.type)
+                    booleanFlags.delete(key);
+            }
+        }
+        for (const flag of stringFlags)
+            booleanFlags.delete(flag);
+        return { aliases, booleanFlags, stringFlags };
+    }
     getBooleanFlags() {
         const flags = new Set();
         for (const opt of this.globalOptions) {

package/dist/src/production/retry.js

@@ -116,7 +116,7 @@ export async function withRetry(fn, config = {}, strategy = 'exponential') {
             };
         }
         catch (error) {
-            lastError = error;
+            lastError = error instanceof Error ? error : new Error(String(error));
             // Check if we should retry
             if (!shouldRetryError(lastError, attempt, finalConfig)) {
                 return {

package/dist/src/services/bounded-worker-pool.js

@@ -20,6 +20,9 @@ export async function runBoundedPool(tasks, options) {
     const controller = new AbortController();
     const onAbort = () => controller.abort(options.signal?.reason ?? new Error('cancelled'));
     options.signal?.addEventListener('abort', onAbort, { once: true });
+    // Abort events are not replayed for signals cancelled before registration.
+    if (options.signal?.aborted)
+        onAbort();
     const timer = options.timeoutMs && options.timeoutMs > 0
         ? setTimeout(() => controller.abort(new Error('worker-pool-timeout')), options.timeoutMs)
         : undefined;

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

@@ -3,6 +3,7 @@
  * Shared JSON config file persistence with atomic writes and Zod validation
  */
 export declare class ConfigFileManager {
+    private configCwd;
     private configPath;
     private config;
     /** Find config file in search paths starting from cwd */
@@ -27,6 +28,8 @@ export declare class ConfigFileManager {
     getConfigPath(): string | null;
     /** Get default config */
     getDefaults(): Record<string, unknown>;
+    /** Cached values and file paths belong to one resolved project directory. */
+    private selectProject;
     /** Atomic write: write to .tmp then rename */
     private writeAtomic;
 }

package/dist/src/services/config-file-manager.js

@@ -54,6 +54,7 @@ const DEFAULT_CONFIG = {
     },
 };
 export class ConfigFileManager {
+    configCwd = null;
     configPath = null;
     config = null;
     /** Find config file in search paths starting from cwd */
@@ -73,6 +74,7 @@ export class ConfigFileManager {
     }
     /** Load config from file, returns null if not found */
     load(cwd) {
+        this.selectProject(cwd);
         this.configPath = this.findConfig(cwd);
         if (!this.configPath) {
             this.config = null;
@@ -101,10 +103,11 @@ export class ConfigFileManager {
     }
     /** Get the current config, loading if needed */
     getConfig(cwd) {
+        this.selectProject(cwd);
         if (this.config === null) {
             this.load(cwd);
         }
-        return this.config ?? { ...DEFAULT_CONFIG };
+        return this.config ?? structuredClone(DEFAULT_CONFIG);
     }
     /** Get a nested config value by dot-separated key */
     get(cwd, key) {
@@ -117,6 +120,7 @@ export class ConfigFileManager {
         if (key.split('.').some(part => part === '__proto__' || part === 'constructor' || part === 'prototype')) {
             throw new Error(`Unsafe configuration key: ${key}`);
         }
+        this.selectProject(cwd);
         // A targeted update must not persist unrelated defaults (notably the
         // default memory path, which would relocate an existing memory store).
         const config = this.config ?? this.load(cwd) ?? {};
@@ -137,17 +141,20 @@ export class ConfigFileManager {
         if (fs.existsSync(targetPath) && !force) {
             throw new Error(`Config file already exists: ${targetPath}. Use --force to overwrite.`);
         }
-        const config = { ...DEFAULT_CONFIG, ...overrides };
+        const config = { ...structuredClone(DEFAULT_CONFIG), ...overrides };
         this.writeAtomic(targetPath, config);
+        this.selectProject(cwd);
         this.config = config;
         this.configPath = targetPath;
         return targetPath;
     }
     /** Reset config to defaults */
     reset(cwd) {
-        const targetPath = this.configPath ?? path.resolve(cwd, CONFIG_FILENAMES[0]);
-        this.writeAtomic(targetPath, DEFAULT_CONFIG);
-        this.config = { ...DEFAULT_CONFIG };
+        this.selectProject(cwd);
+        const targetPath = this.findConfig(cwd) ?? path.resolve(cwd, CONFIG_FILENAMES[0]);
+        const config = structuredClone(DEFAULT_CONFIG);
+        this.writeAtomic(targetPath, config);
+        this.config = config;
         this.configPath = targetPath;
         return targetPath;
     }
@@ -174,7 +181,8 @@ export class ConfigFileManager {
         if (typeof imported !== 'object' || imported === null || Array.isArray(imported)) {
             throw new Error('Import file must contain a JSON object');
         }
-        const targetPath = this.configPath ?? path.resolve(cwd, CONFIG_FILENAMES[0]);
+        this.selectProject(cwd);
+        const targetPath = this.findConfig(cwd) ?? path.resolve(cwd, CONFIG_FILENAMES[0]);
         this.writeAtomic(targetPath, imported);
         this.config = imported;
         this.configPath = targetPath;
@@ -185,7 +193,16 @@ export class ConfigFileManager {
     }
     /** Get default config */
     getDefaults() {
-        return { ...DEFAULT_CONFIG };
+        return structuredClone(DEFAULT_CONFIG);
+    }
+    /** Cached values and file paths belong to one resolved project directory. */
+    selectProject(cwd) {
+        const resolved = path.resolve(cwd);
+        if (this.configCwd !== resolved) {
+            this.configCwd = resolved;
+            this.config = null;
+            this.configPath = null;
+        }
     }
     /** Atomic write: write to .tmp then rename */
     writeAtomic(filePath, data) {

package/dist/src/services/policy-ledger-anchor.d.ts

@@ -0,0 +1,42 @@
+import type { PolicyState } from '@claude-flow/security';
+export type AnchorEvent = 'append' | 'migrated-from-state' | 'establish-anchor';
+export interface AnchorEntry {
+    seq: number;
+    length: number;
+    headHash: string | null;
+    prevAnchorHash: string | null;
+    ts: number;
+    event: AnchorEvent;
+    by?: string;
+    hash: string;
+}
+export type AnchorAssessment = {
+    kind: 'absent';
+} | {
+    kind: 'ok';
+    last: AnchorEntry;
+    behind: boolean;
+} | {
+    kind: 'fail';
+    error: string;
+};
+export type AnchorWriter = (file: string, value: unknown) => Promise<void>;
+export declare const anchorLogPath: (projectRoot: string) => string;
+/**
+ * How the stored anchors relate to `state`; read-only. `rebuild` is the
+ * explicit-establish path: an unreadable log or mirror is treated as absent, but
+ * whatever readable anchor remains must still agree with the chain, so it can
+ * never bless a truncation the anchors still remember.
+ */
+export declare function assessAnchors(projectRoot: string, state: PolicyState, rebuild?: boolean): AnchorAssessment;
+/**
+ * Append an entry for the current state if the newest entry does not already
+ * describe it. Must run under the policy lock. Throws if the log is corrupt:
+ * only an explicit establish may replace a corrupt log.
+ */
+export declare function recordAnchor(projectRoot: string, state: PolicyState, write: AnchorWriter, event?: AnchorEvent, by?: string): Promise<void>;
+export declare function anchorPosture(projectRoot: string): {
+    log: boolean;
+    mirror: boolean;
+};
+//# sourceMappingURL=policy-ledger-anchor.d.ts.map

package/dist/src/services/policy-ledger-anchor.js

@@ -0,0 +1,163 @@
+/**
+ * Second, hash-chained copy of the policy ledger anchor (#3602, ADR-475).
+ *
+ * The primary anchor (`ledgerLength` / `ledgerHead`) lives inside state.json,
+ * the same file it protects, so deleting it together with receipts used to
+ * make `verify` bless the truncated chain. This module keeps an append-only
+ * chain of anchor entries in a SEPARATE file plus a mirror of the newest entry
+ * outside the project directory (~/.config/ruflo/policy-trust/<project>/).
+ *
+ * Threat model: this detects any tampering confined to state.json, and any
+ * tampering confined to the project directory. It does NOT stop an attacker
+ * who can rewrite both the project directory and the user's home directory.
+ */
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, realpathSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { userInfo } from 'node:os';
+const LOG_FILE = 'ledger-anchors.json';
+const MIRROR_FILE = 'ledger-anchor-head.json';
+export const anchorLogPath = (projectRoot) => join(resolve(projectRoot), '.claude-flow', 'policy', LOG_FILE);
+function mirrorPath(projectRoot) {
+    const id = createHash('sha256').update(realpathSync(projectRoot)).digest('hex');
+    return join(userInfo().homedir, '.config', 'ruflo', 'policy-trust', id, MIRROR_FILE);
+}
+function entryHash(entry) {
+    return createHash('sha256').update(JSON.stringify([
+        entry.seq, entry.length, entry.headHash, entry.prevAnchorHash, entry.ts, entry.event, entry.by ?? null,
+    ])).digest('hex');
+}
+function validEntry(value, seq, prev) {
+    const e = value;
+    return !!e && typeof e === 'object'
+        && e.seq === seq
+        && Number.isInteger(e.length) && e.length >= 0
+        && (e.headHash === null || typeof e.headHash === 'string')
+        && e.prevAnchorHash === prev
+        && typeof e.ts === 'number'
+        && ['append', 'migrated-from-state', 'establish-anchor'].includes(e.event)
+        && typeof e.hash === 'string'
+        && e.hash === entryHash({ ...e, hash: undefined });
+}
+function readLog(projectRoot) {
+    const file = anchorLogPath(projectRoot);
+    if (!existsSync(file))
+        return [];
+    try {
+        const parsed = JSON.parse(readFileSync(file, 'utf8'));
+        if (parsed.version !== 1 || !Array.isArray(parsed.entries))
+            return 'corrupt';
+        let prev = null;
+        for (let i = 0; i < parsed.entries.length; i++) {
+            if (!validEntry(parsed.entries[i], i, prev))
+                return 'corrupt';
+            prev = parsed.entries[i].hash;
+        }
+        return parsed.entries;
+    }
+    catch {
+        return 'corrupt';
+    }
+}
+function readMirror(projectRoot) {
+    const file = mirrorPath(projectRoot);
+    if (!existsSync(file))
+        return null;
+    try {
+        const parsed = JSON.parse(readFileSync(file, 'utf8'));
+        return typeof parsed?.hash === 'string' && parsed.hash === entryHash({ ...parsed, hash: undefined })
+            ? parsed
+            : 'corrupt';
+    }
+    catch {
+        return 'corrupt';
+    }
+}
+/**
+ * How the stored anchors relate to `state`; read-only. `rebuild` is the
+ * explicit-establish path: an unreadable log or mirror is treated as absent, but
+ * whatever readable anchor remains must still agree with the chain, so it can
+ * never bless a truncation the anchors still remember.
+ */
+export function assessAnchors(projectRoot, state, rebuild = false) {
+    let entries = readLog(projectRoot);
+    if (entries === 'corrupt') {
+        if (!rebuild)
+            return { kind: 'fail', error: 'policy-anchor-log-corrupt' };
+        entries = [];
+    }
+    let mirror = readMirror(projectRoot);
+    if (mirror === 'corrupt') {
+        if (!rebuild)
+            return { kind: 'fail', error: 'policy-anchor-mirror-corrupt' };
+        mirror = null;
+    }
+    if (entries.length === 0) {
+        if (!mirror)
+            return { kind: 'absent' };
+        if (!rebuild)
+            return { kind: 'fail', error: 'policy-anchor-log-missing' };
+        if (state.receipts.length < mirror.length)
+            return { kind: 'fail', error: 'policy-ledger-truncated' };
+        if (mirror.length > 0 && state.receipts[mirror.length - 1].hash !== mirror.headHash) {
+            return { kind: 'fail', error: 'policy-ledger-anchor-mismatch' };
+        }
+        return { kind: 'absent' };
+    }
+    if (mirror && !entries.some((entry) => entry.hash === mirror.hash)) {
+        return { kind: 'fail', error: 'policy-anchor-log-rolled-back' };
+    }
+    const last = entries[entries.length - 1];
+    for (const anchor of mirror ? [last, mirror] : [last]) {
+        if (state.receipts.length < anchor.length)
+            return { kind: 'fail', error: 'policy-ledger-truncated' };
+        if (anchor.length > 0 && state.receipts[anchor.length - 1].hash !== anchor.headHash) {
+            return { kind: 'fail', error: 'policy-ledger-anchor-mismatch' };
+        }
+    }
+    return { kind: 'ok', last, behind: state.receipts.length > last.length };
+}
+/**
+ * Append an entry for the current state if the newest entry does not already
+ * describe it. Must run under the policy lock. Throws if the log is corrupt:
+ * only an explicit establish may replace a corrupt log.
+ */
+export async function recordAnchor(projectRoot, state, write, event = 'append', by) {
+    if (state.receipts.length === 0)
+        return;
+    const loaded = readLog(projectRoot);
+    const entries = loaded === 'corrupt' ? [] : loaded;
+    if (loaded === 'corrupt' && event !== 'establish-anchor')
+        throw new Error('policy-anchor-log-corrupt');
+    const last = entries[entries.length - 1];
+    const length = state.receipts.length;
+    const headHash = state.receipts[length - 1].hash;
+    let tip = last;
+    if (!last || last.length !== length || last.headHash !== headHash) {
+        const base = {
+            seq: entries.length,
+            length,
+            headHash,
+            prevAnchorHash: last?.hash ?? null,
+            ts: Date.now(),
+            event,
+            ...(by ? { by } : {}),
+        };
+        tip = { ...base, hash: entryHash(base) };
+        await write(anchorLogPath(projectRoot), { version: 1, entries: [...entries, tip] });
+    }
+    try {
+        const mirror = mirrorPath(projectRoot);
+        mkdirSync(dirname(mirror), { recursive: true, mode: 0o700 });
+        await write(mirror, tip);
+    }
+    catch (error) {
+        // A read-only home must not stop the ledger; verify reports the weaker
+        // posture (no mirror) rather than failing closed on every decision.
+        process.stderr.write(`[policy] anchor mirror not written: ${error.message}\n`);
+    }
+}
+export function anchorPosture(projectRoot) {
+    return { log: existsSync(anchorLogPath(projectRoot)), mirror: existsSync(mirrorPath(projectRoot)) };
+}
+//# sourceMappingURL=policy-ledger-anchor.js.map

package/dist/src/services/policy-runtime.d.ts

@@ -22,13 +22,19 @@ export declare function issuePolicyApproval(approval: Omit<PolicyApproval, 'uses
     issuedAt?: number;
 }, projectRoot?: string, approvalIssuerVerifier?: (issuer: string) => boolean): Promise<PolicyApproval>;
 export declare function revokePolicyApproval(id: string, projectRoot?: string): Promise<boolean>;
+export type PolicyLedgerVerification = ReturnType<AgenticPolicyEngine['verifyLedger']> & {
+    /** How the second anchor was brought in line during this call. */
+    secondaryAnchor?: 'recorded-from-state' | 'restored-primary' | 'established-explicitly';
+};
 /**
- * Read-only verification (#3568). It must not run inside
- * `withPolicyTransaction`, whose own post-operation check throws a generic
- * `policy-ledger-verification-failed` and hides which check failed. The only
- * write is persisting an anchor established for a pre-anchor ledger.
+ * Verification (#3568, #3602). It must not run inside `withPolicyTransaction`,
+ * whose own post-operation check throws a generic
+ * `policy-ledger-verification-failed` and hides which check failed. It writes
+ * only to bring the second anchor in line, or on an explicit `establishAnchor`.
  */
-export declare function verifyPolicyLedger(projectRoot?: string): Promise<ReturnType<AgenticPolicyEngine['verifyLedger']>>;
+export declare function verifyPolicyLedger(projectRoot?: string, options?: {
+    establishAnchor?: boolean;
+}): Promise<PolicyLedgerVerification>;
 export declare function authorizeMcpTool(toolName: string, input: Record<string, unknown>, context?: Record<string, unknown>, attributes?: Readonly<{
     actionType?: string;
     network?: boolean;

package/dist/src/services/policy-runtime.js

@@ -5,6 +5,7 @@ import { closeSync, constants as fsConstants, existsSync, fstatSync, lstatSync,
 import { dirname, join, resolve } from 'node:path';
 import { hostname, userInfo } from 'node:os';
 import { syncPolicyProjection } from '../mods/policy-projection.js';
+import { assessAnchors, recordAnchor } from './policy-ledger-anchor.js';
 const POLICY_DIR = join('.claude-flow', 'policy');
 const POLICY_FILE = 'state.json';
 const LOCK_FILE = 'state.lock';
@@ -231,8 +232,11 @@ function verifyStateAnchor(projectRoot, state) {
         throw new Error('policy-state-authentication-failed');
     }
 }
-async function writePolicyState(projectRoot, statePath, state) {
+async function writePolicyState(projectRoot, statePath, state, anchorEvent = 'append', by) {
     await writePolicyStateFiles(projectRoot, statePath, state);
+    // #3602: the second anchor is written after the state, so a crash leaves the
+    // state AHEAD of the log (caught up on the next write), never behind it.
+    await recordAnchor(projectRoot, state, writeJsonAtomic, anchorEvent, by);
     // ADR-404: the ruflo mod reads Claude Code tool rules from a small
     // projection, never from state.json. Written only after the state and its
     // anchor are safely down; a failure here never fails the state write. A
@@ -350,20 +354,26 @@ export async function withPolicyTransaction(projectRoot, operation, options = {}
     mkdirSync(target.dir, { recursive: true, mode: 0o700 });
     const release = await acquireLock(target.lock);
     try {
-        const engine = AgenticPolicyEngine.fromState(loadPolicyState(projectRoot), {
+        const loaded = loadPolicyState(projectRoot);
+        const engine = AgenticPolicyEngine.fromState(loaded, {
             signingKey: process.env.CLAUDE_FLOW_POLICY_SIGNING_KEY,
             keyId: process.env.CLAUDE_FLOW_POLICY_KEY_ID,
             evidenceVerifier: verifyPolicyEvidence,
             approvalIssuerVerifier: options.approvalIssuerVerifier,
         });
+        // #3602: refuse to operate on a ledger whose anchors are missing or
+        // disagree; a restored primary anchor is persisted by the write below.
+        const gate = reconcileLedger(projectRoot, engine, {});
+        if (!gate.result.valid) {
+            throw new Error(gate.result.error === 'anchor-missing'
+                ? `policy-ledger-anchor-missing: receipts exist but no ledger anchor was found. If this ledger predates anchors, run \`ruflo policy verify --establish-anchor\`; otherwise treat it as tampering.`
+                : gate.result.error ?? 'policy-ledger-verification-failed');
+        }
         const result = await operation(engine);
-        // Verify before exporting: verification establishes the ledger anchor
-        // (#3568) on state written before the anchor existed, and that anchor
-        // must be part of what is persisted.
         if (!engine.verifyLedger().valid)
             throw new Error('policy-ledger-verification-failed');
         const nextState = engine.exportState();
-        await writePolicyState(projectRoot, target.state, nextState);
+        await writePolicyState(projectRoot, target.state, nextState, gate.event);
         return result;
     }
     finally {
@@ -416,12 +426,56 @@ export async function revokePolicyApproval(id, projectRoot = process.cwd()) {
     return withPolicyTransaction(projectRoot, (engine) => engine.revokeApproval(id));
 }
 /**
- * Read-only verification (#3568). It must not run inside
- * `withPolicyTransaction`, whose own post-operation check throws a generic
- * `policy-ledger-verification-failed` and hides which check failed. The only
- * write is persisting an anchor established for a pre-anchor ledger.
+ * Decide whether the ledger may be trusted, using the chain, the primary anchor
+ * in state.json and the second anchor (#3602). It never creates an anchor over
+ * existing receipts on its own: only an authentic second anchor (restoring a
+ * deleted primary) or an explicit `establishAnchor` does.
+ */
+function reconcileLedger(projectRoot, engine, options) {
+    const state = engine.exportState();
+    const length = state.receipts.length;
+    const primary = typeof state.ledgerLength === 'number';
+    const base = engine.verifyLedger();
+    const fail = (error) => ({ result: { valid: false, length, error }, persist: false });
+    if (!base.valid && base.error !== 'anchor-missing')
+        return { result: base, persist: false };
+    const assessed = assessAnchors(projectRoot, state, options.establishAnchor === true);
+    if (assessed.kind === 'fail')
+        return fail(assessed.error);
+    if (primary) {
+        if (assessed.kind === 'absent' && length > 0) {
+            return options.establishAnchor
+                ? { result: { ...base, secondaryAnchor: 'established-explicitly' }, persist: true, event: 'establish-anchor' }
+                : { result: { ...base, secondaryAnchor: 'recorded-from-state' }, persist: true, event: 'migrated-from-state' };
+        }
+        return { result: base, persist: assessed.kind === 'ok' && assessed.behind, event: 'append' };
+    }
+    // No primary anchor.
+    if (length === 0)
+        return { result: { valid: true, length, state: 'empty' }, persist: false };
+    if (assessed.kind === 'ok') {
+        // The second anchor is authentic and agrees with the chain: the deleted
+        // primary can be restored from it. Truncation was already rejected above.
+        engine.verifyLedger({ establishAnchor: true });
+        return { result: { valid: true, length, secondaryAnchor: 'restored-primary' }, persist: true, event: 'append' };
+    }
+    if (options.establishAnchor) {
+        const established = engine.verifyLedger({ establishAnchor: true });
+        return {
+            result: { ...established, secondaryAnchor: 'established-explicitly' },
+            persist: true,
+            event: 'establish-anchor',
+        };
+    }
+    return fail('anchor-missing');
+}
+/**
+ * Verification (#3568, #3602). It must not run inside `withPolicyTransaction`,
+ * whose own post-operation check throws a generic
+ * `policy-ledger-verification-failed` and hides which check failed. It writes
+ * only to bring the second anchor in line, or on an explicit `establishAnchor`.
  */
-export async function verifyPolicyLedger(projectRoot = process.cwd()) {
+export async function verifyPolicyLedger(projectRoot = process.cwd(), options = {}) {
     const target = paths(projectRoot);
     mkdirSync(target.dir, { recursive: true, mode: 0o700 });
     const release = await acquireLock(target.lock);
@@ -430,11 +484,12 @@ export async function verifyPolicyLedger(projectRoot = process.cwd()) {
             signingKey: process.env.CLAUDE_FLOW_POLICY_SIGNING_KEY,
             keyId: process.env.CLAUDE_FLOW_POLICY_KEY_ID,
         });
-        const result = engine.verifyLedger();
-        if (result.anchor === 'established-now') {
-            await writePolicyState(projectRoot, target.state, engine.exportState());
+        const outcome = reconcileLedger(projectRoot, engine, options);
+        if (outcome.persist) {
+            const by = outcome.event === 'establish-anchor' ? userInfo().username : undefined;
+            await writePolicyState(projectRoot, target.state, engine.exportState(), outcome.event, by);
         }
-        return result;
+        return outcome.result;
     }
     finally {
         release();

package/dist/src/services/worker-daemon.d.ts

@@ -67,6 +67,7 @@ export interface DaemonConfig {
     idleShutdownMs: number;
     aiWorkersEnabled: boolean;
     workers: WorkerConfig[];
+    enabledWorkers?: string[];
 }
 /**
  * Worker Daemon - Manages background workers with Node.js