@claude-flow/cli 3.71.1 → 3.71.3

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

@@ -3115,16 +3115,38 @@ export async function listEntries(options) {
         const total = countRows[0]?.[0] || 0;
         // Get entries. ADR-472: embedding rows are capped at MAX_LIST_EMBEDDINGS.
         const listLimit = options.includeEmbedding ? Math.min(safeLimit, MAX_LIST_EMBEDDINGS) : safeLimit;
-        // Include tags so export/list can round-trip them.
-        const listStmt = db.prepare(`SELECT id, key, namespace, content, embedding, access_count, created_at, updated_at, provenance_type, expires_at, tags
-       FROM memory_entries WHERE ${whereSql}
-       ORDER BY updated_at DESC LIMIT ? OFFSET ?`);
-        listStmt.bind([...whereParams, listLimit, safeOffset]);
-        const listRows = [];
-        while (listStmt.step()) {
-            listRows.push(listStmt.get());
-        }
-        listStmt.free();
+        const columns = 'id, key, namespace, content, embedding, access_count, created_at, updated_at, provenance_type, expires_at, tags';
+        // #4686: page row identities first so the temporary sort B-tree does not
+        // carry full content/embedding payloads for rows outside the page.
+        const pagedSql = `SELECT ${columns} FROM memory_entries
+       WHERE _rowid_ IN (
+         SELECT _rowid_ FROM memory_entries WHERE ${whereSql}
+         ORDER BY updated_at DESC LIMIT ? OFFSET ?
+       )
+       ORDER BY updated_at DESC`;
+        const originalSql = `SELECT ${columns} FROM memory_entries WHERE ${whereSql}
+       ORDER BY updated_at DESC LIMIT ? OFFSET ?`;
+        let listRows = [];
+        const runList = (sql) => {
+            const stmt = db.prepare(sql);
+            try {
+                stmt.bind([...whereParams, listLimit, safeOffset]);
+                const rows = [];
+                while (stmt.step())
+                    rows.push(stmt.get());
+                return rows;
+            }
+            finally {
+                stmt.free();
+            }
+        };
+        try {
+            listRows = runList(pagedSql);
+        }
+        catch {
+            // Legacy WITHOUT ROWID tables have no _rowid_: keep the original query.
+            listRows = runList(originalSql);
+        }
         const entries = [];
         for (const row of listRows) {
             const [id, key, ns, content, embedding, accessCount, createdAt, updatedAt, provenanceTypeVal, expiresAtVal, tagsJson] = row;

package/dist/src/missions/schemas.d.ts

@@ -77,15 +77,15 @@ export declare const missionRecordSchema: z.ZodObject<{
     updatedAt: string;
     schemaVersion: 1;
     state: "completed" | "cancelled" | "failed" | "blocked" | "running" | "paused" | "queued" | "draft" | "planned" | "awaitingAuthorization" | "pauseRequested" | "verifying" | "cancelRequested";
-    acceptance: {
-        revision: number;
-        criteriaDigest: string;
-    };
     plan: {
         digest: string;
         revision: number;
         taskGraphRef: string;
     };
+    acceptance: {
+        revision: number;
+        criteriaDigest: string;
+    };
     objective: string;
     missionId: string;
     tenantId: string;
@@ -103,15 +103,15 @@ export declare const missionRecordSchema: z.ZodObject<{
     updatedAt: string;
     schemaVersion: 1;
     state: "completed" | "cancelled" | "failed" | "blocked" | "running" | "paused" | "queued" | "draft" | "planned" | "awaitingAuthorization" | "pauseRequested" | "verifying" | "cancelRequested";
-    acceptance: {
-        revision: number;
-        criteriaDigest: string;
-    };
     plan: {
         digest: string;
         revision: number;
         taskGraphRef: string;
     };
+    acceptance: {
+        revision: number;
+        criteriaDigest: string;
+    };
     objective: string;
     missionId: string;
     tenantId: string;
@@ -580,7 +580,6 @@ export declare const planInputSchema: z.ZodObject<{
         } | undefined;
     }>;
 }, "strict", z.ZodTypeAny, {
-    requestId: string;
     plan: {
         tasks: {
             id: string;
@@ -617,10 +616,10 @@ export declare const planInputSchema: z.ZodObject<{
             baseline?: string | undefined;
         }[];
     };
+    requestId: string;
     missionId: string;
     expectedRevision: number;
 }, {
-    requestId: string;
     plan: {
         tasks: {
             id: string;
@@ -657,6 +656,7 @@ export declare const planInputSchema: z.ZodObject<{
             capabilities?: string[] | undefined;
         } | undefined;
     };
+    requestId: string;
     missionId: string;
     expectedRevision: number;
 }>;

package/dist/src/mods/headless-plugins.d.ts

@@ -14,10 +14,20 @@
  *
  * Profile override: `RUFLO_HEADLESS_PLUGINS` is a comma list of plugin names;
  * `none` (or an empty value) turns plugin loading off.
+ *
+ * Permission mode: Claude Code 2.1.302 starts a `claude -p` with no
+ * permission mode in `manual` mode on third-party providers, with telemetry
+ * off, or on a fresh install. A headless worker has nobody to answer a prompt,
+ * so a print-mode argv without its own `--permission-mode` or
+ * `--dangerously-skip-permissions` gets `--permission-mode auto` — the mode
+ * first-party installs already started in. `RUFLO_HEADLESS_PERMISSION_MODE`
+ * picks another mode; `none` (or an empty value) passes no flag.
  */
 import { type ResolveOptions, type PluginPaths } from './plugin-paths.js';
 export declare const DEFAULT_WORKER_PLUGINS: readonly string[];
 export declare const PROFILE_ENV = "RUFLO_HEADLESS_PLUGINS";
+export declare const PERMISSION_MODE_ENV = "RUFLO_HEADLESS_PERMISSION_MODE";
+export declare const DEFAULT_HEADLESS_PERMISSION_MODE = "auto";
 export interface HeadlessPluginOptions extends ResolveOptions {
     /** Plugin names to load; defaults to the env profile, else DEFAULT_WORKER_PLUGINS. */
     profile?: readonly string[];
@@ -40,5 +50,11 @@ export declare function resetHeadlessPluginWarnings(): void;
 export declare function workerProfile(env?: NodeJS.ProcessEnv, explicit?: readonly string[]): string[];
 /** Every `--plugin-dir` value already in argv (both `--plugin-dir x` and `--plugin-dir=x`). */
 export declare function existingPluginDirs(argv: readonly string[]): string[];
+/**
+ * The `--permission-mode` args to append to a headless argv: none when the
+ * argv is not print mode or already sets a mode, else the env choice
+ * (default `auto`). An unknown mode is ignored with the default used instead.
+ */
+export declare function headlessPermissionArgs(argv: readonly string[], env?: NodeJS.ProcessEnv): string[];
 export declare function withHeadlessPlugins<E extends Record<string, string | undefined>>(argv: readonly string[], env: E, opts?: HeadlessPluginOptions): HeadlessPluginResult<E>;
 //# sourceMappingURL=headless-plugins.d.ts.map

package/dist/src/mods/headless-plugins.js

@@ -14,6 +14,14 @@
  *
  * Profile override: `RUFLO_HEADLESS_PLUGINS` is a comma list of plugin names;
  * `none` (or an empty value) turns plugin loading off.
+ *
+ * Permission mode: Claude Code 2.1.302 starts a `claude -p` with no
+ * permission mode in `manual` mode on third-party providers, with telemetry
+ * off, or on a fresh install. A headless worker has nobody to answer a prompt,
+ * so a print-mode argv without its own `--permission-mode` or
+ * `--dangerously-skip-permissions` gets `--permission-mode auto` — the mode
+ * first-party installs already started in. `RUFLO_HEADLESS_PERMISSION_MODE`
+ * picks another mode; `none` (or an empty value) passes no flag.
  */
 import { realpathSync } from 'node:fs';
 import { basename, resolve } from 'node:path';
@@ -21,6 +29,9 @@ import { ENABLE_ENV } from './install.js';
 import { resolvePluginPaths } from './plugin-paths.js';
 export const DEFAULT_WORKER_PLUGINS = ['ruflo-mods'];
 export const PROFILE_ENV = 'RUFLO_HEADLESS_PLUGINS';
+export const PERMISSION_MODE_ENV = 'RUFLO_HEADLESS_PERMISSION_MODE';
+export const DEFAULT_HEADLESS_PERMISSION_MODE = 'auto';
+const PERMISSION_MODES = new Set(['acceptEdits', 'auto', 'bypassPermissions', 'manual', 'default', 'dontAsk', 'plan']);
 const warned = new Set();
 /** For tests: forget which missing plugins were already logged. */
 export function resetHeadlessPluginWarnings() {
@@ -56,9 +67,27 @@ export function existingPluginDirs(argv) {
     }
     return dirs;
 }
+/**
+ * The `--permission-mode` args to append to a headless argv: none when the
+ * argv is not print mode or already sets a mode, else the env choice
+ * (default `auto`). An unknown mode is ignored with the default used instead.
+ */
+export function headlessPermissionArgs(argv, env = process.env) {
+    const isPrint = argv.some((a) => a === '-p' || a === '--print');
+    if (!isPrint)
+        return [];
+    const hasMode = argv.some((a) => a === '--permission-mode' || a.startsWith('--permission-mode=') || a === '--dangerously-skip-permissions');
+    if (hasMode)
+        return [];
+    const raw = env[PERMISSION_MODE_ENV];
+    if (raw !== undefined && (raw.trim() === '' || raw.trim().toLowerCase() === 'none'))
+        return [];
+    const mode = raw !== undefined && PERMISSION_MODES.has(raw.trim()) ? raw.trim() : DEFAULT_HEADLESS_PERMISSION_MODE;
+    return ['--permission-mode', mode];
+}
 export function withHeadlessPlugins(argv, env, opts = {}) {
     const profile = workerProfile(opts.env ?? env, opts.profile);
-    const outArgv = [...argv];
+    const outArgv = [...argv, ...headlessPermissionArgs(argv, opts.env ?? env)];
     const outEnv = { ...env };
     if (profile.length === 0)
         return { argv: outArgv, env: outEnv, added: [], missing: [] };

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

@@ -11,7 +11,7 @@ export function readClaimsStore(file) {
     }
     catch (error) {
         if (error.code === 'ENOENT')
-            return { claims: {}, stealable: {}, contests: {} };
+            return { claims: Object.create(null), stealable: Object.create(null), contests: Object.create(null) };
         throw error;
     }
     const data = JSON.parse(text);
@@ -35,6 +35,9 @@ export function readClaimsStore(file) {
         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 ?? {} };
+    // SECURITY: issue ids come from tool input; null-prototype maps keep a lookup
+    // by `constructor`/`__proto__` from resolving to an inherited built-in.
+    const nullProto = (map) => Object.assign(Object.create(null), map ?? {});
+    return { ...data, claims, stealable: nullProto(data.stealable), contests: nullProto(data.contests) };
 }
 //# sourceMappingURL=claims-store.js.map

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

@@ -1,5 +1,29 @@
 /** True if a live daemon already holds the project's pidfile. */
 export declare function isDaemonAlive(projectRoot: string): boolean;
+/**
+ * #4654: an explicit `daemon stop` is an opt-out that must survive the next
+ * hook. Every ruflo-core plugin hook (PreToolUse/PostToolUse, PreCompact, Stop)
+ * runs the CLI, and the CLI auto-starts a daemon whenever none is alive, so a
+ * stopped daemon came back within minutes. `daemon stop` now writes this
+ * marker, auto-start honours it, and only an explicit `daemon start` clears it.
+ */
+export declare const DAEMON_STOP_MARKER = "daemon.stopped";
+/**
+ * Set on the daemon that auto-start spawns, so that spawned `daemon start` does
+ * not clear a stop marker written after auto-start checked it (a `daemon stop`
+ * racing a hook). Only a user-driven start clears the marker.
+ */
+export declare const AUTOSTART_ENV = "RUFLO_DAEMON_AUTOSTARTED";
+/** True if the user explicitly stopped the daemon for this project (#4654). */
+export declare function isDaemonStopMarked(projectRoot: string): boolean;
+/**
+ * Record an explicit `daemon stop` (#4654). Writes only into a directory that is
+ * already a Ruflo project or already has `.claude-flow/`, so `daemon stop` in an
+ * unrelated directory does not litter it. Best-effort; never throws.
+ */
+export declare function writeDaemonStopMarker(projectRoot: string): boolean;
+/** Clear the stop marker. Called by an explicit `daemon start` (#4654). Never throws. */
+export declare function clearDaemonStopMarker(projectRoot: string): void;
 /**
  * Return true only when the directory contains a durable Ruflo project marker.
  *

package/dist/src/services/daemon-autostart.js

@@ -81,6 +81,57 @@ function autostartDisabledByProjectConfig(projectRoot) {
     }
     return false;
 }
+/**
+ * #4654: an explicit `daemon stop` is an opt-out that must survive the next
+ * hook. Every ruflo-core plugin hook (PreToolUse/PostToolUse, PreCompact, Stop)
+ * runs the CLI, and the CLI auto-starts a daemon whenever none is alive, so a
+ * stopped daemon came back within minutes. `daemon stop` now writes this
+ * marker, auto-start honours it, and only an explicit `daemon start` clears it.
+ */
+export const DAEMON_STOP_MARKER = 'daemon.stopped';
+/**
+ * Set on the daemon that auto-start spawns, so that spawned `daemon start` does
+ * not clear a stop marker written after auto-start checked it (a `daemon stop`
+ * racing a hook). Only a user-driven start clears the marker.
+ */
+export const AUTOSTART_ENV = 'RUFLO_DAEMON_AUTOSTARTED';
+function stopMarkerPath(projectRoot) {
+    return path.join(projectRoot, '.claude-flow', DAEMON_STOP_MARKER);
+}
+/** True if the user explicitly stopped the daemon for this project (#4654). */
+export function isDaemonStopMarked(projectRoot) {
+    try {
+        return fs.existsSync(stopMarkerPath(projectRoot));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Record an explicit `daemon stop` (#4654). Writes only into a directory that is
+ * already a Ruflo project or already has `.claude-flow/`, so `daemon stop` in an
+ * unrelated directory does not litter it. Best-effort; never throws.
+ */
+export function writeDaemonStopMarker(projectRoot) {
+    try {
+        const dir = path.join(projectRoot, '.claude-flow');
+        if (!fs.existsSync(dir) && !isRufloProject(projectRoot))
+            return false;
+        fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(stopMarkerPath(projectRoot), JSON.stringify({ stoppedAt: new Date().toISOString(), pid: process.pid }) + '\n');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Clear the stop marker. Called by an explicit `daemon start` (#4654). Never throws. */
+export function clearDaemonStopMarker(projectRoot) {
+    try {
+        fs.unlinkSync(stopMarkerPath(projectRoot));
+    }
+    catch { /* absent */ }
+}
 function autostartDisabled(projectRoot) {
     if (/^(0|false|no|off)$/i.test(process.env.RUFLO_DAEMON_AUTOSTART ?? ''))
         return true;
@@ -166,7 +217,7 @@ const defaultSpawn = (projectRoot) => {
         cwd: projectRoot,
         detached: true,
         stdio: 'ignore',
-        env: { ...process.env },
+        env: { ...process.env, [AUTOSTART_ENV]: '1' },
     });
     child.unref();
 };
@@ -186,6 +237,9 @@ export function ensureDaemonRunning(startDir, opts = {}) {
         if (!isRufloProject(projectRoot)) {
             return { started: false, reason: 'not a ruflo project' };
         }
+        if (isDaemonStopMarked(projectRoot)) {
+            return { started: false, reason: 'stopped by user (daemon stop); run `daemon start` to re-enable' };
+        }
         const alive = (opts.isAlive ?? isDaemonAlive)(projectRoot);
         if (alive)
             return { started: false, reason: 'already running' };

package/dist/src/services/headless-worker-executor.d.ts

@@ -123,6 +123,12 @@ export interface HeadlessExecutionResult {
     inputTokens?: number;
     outputTokens?: number;
     costUsd?: number;
+    /**
+     * When the stored claude.ai sign-in the worker ran under ends (ISO 8601),
+     * from `credential_expires_at` in the `claude -p` JSON result (Claude Code
+     * 2.1.318+). Absent for API-key auth and older CLIs.
+     */
+    credentialExpiresAt?: string;
     /** Model used for execution */
     model: string;
     /** Sandbox mode used */
@@ -202,7 +208,16 @@ export interface ClaudePrintEnvelope {
     outputTokens?: number;
     costUsd?: number;
     durationMs?: number;
+    /** ISO 8601 end of the stored claude.ai sign-in (Claude Code 2.1.318+). */
+    credentialExpiresAt?: string;
 }
+/** Days before a sign-in ends at which the executor emits 'credential-expiring' (matches Claude Code's own stderr warning). */
+export declare const CREDENTIAL_EXPIRY_WARN_DAYS = 10;
+/**
+ * Normalise `credential_expires_at` to ISO 8601. Accepts an ISO string or an
+ * epoch number (seconds or milliseconds); anything else is undefined.
+ */
+export declare function normalizeCredentialExpiry(v: unknown): string | undefined;
 /**
  * #2661 root-fix — best-effort parse of `claude --print --output-format
  * json`'s response envelope. Deliberately lenient: probes a couple of

package/dist/src/services/headless-worker-executor.js

@@ -337,6 +337,23 @@ export function isLocalWorker(type) {
 export function getModelId(model) {
     return MODEL_IDS[model];
 }
+/** Days before a sign-in ends at which the executor emits 'credential-expiring' (matches Claude Code's own stderr warning). */
+export const CREDENTIAL_EXPIRY_WARN_DAYS = 10;
+/**
+ * Normalise `credential_expires_at` to ISO 8601. Accepts an ISO string or an
+ * epoch number (seconds or milliseconds); anything else is undefined.
+ */
+export function normalizeCredentialExpiry(v) {
+    let ms;
+    if (typeof v === 'number' && Number.isFinite(v) && v > 0)
+        ms = v < 1e12 ? v * 1000 : v;
+    else if (typeof v === 'string' && v.trim()) {
+        const t = Date.parse(v);
+        if (Number.isFinite(t))
+            ms = t;
+    }
+    return ms === undefined ? undefined : new Date(ms).toISOString();
+}
 /**
  * #2661 root-fix — best-effort parse of `claude --print --output-format
  * json`'s response envelope. Deliberately lenient: probes a couple of
@@ -371,6 +388,7 @@ export function parseClaudePrintJsonEnvelope(raw) {
         outputTokens: numOrUndef(usage?.output_tokens ?? usage?.outputTokens),
         costUsd: numOrUndef(obj.total_cost_usd ?? obj.cost_usd ?? obj.totalCostUsd),
         durationMs: numOrUndef(obj.duration_ms ?? obj.durationMs),
+        credentialExpiresAt: normalizeCredentialExpiry(obj.credential_expires_at ?? obj.credentialExpiresAt),
     };
 }
 /**
@@ -779,7 +797,16 @@ export class HeadlessWorkerExecutor extends EventEmitter {
                 executionId,
                 error: result.error,
                 ...(result.missingPlugins ? { missingPlugins: result.missingPlugins } : {}),
+                ...(result.credentialExpiresAt ? { credentialExpiresAt: result.credentialExpiresAt } : {}),
             };
+            // Claude Code 2.1.318: surface a claude.ai sign-in that ends soon, so the
+            // daemon can say so before workers start failing on auth.
+            if (result.credentialExpiresAt) {
+                const daysLeft = (Date.parse(result.credentialExpiresAt) - Date.now()) / 86_400_000;
+                if (daysLeft <= CREDENTIAL_EXPIRY_WARN_DAYS) {
+                    this.emit('credential-expiring', { expiresAt: result.credentialExpiresAt, daysLeft: Math.max(0, Math.floor(daysLeft)), workerType });
+                }
+            }
             // Log result
             this.logExecution(executionId, 'result', JSON.stringify(executionResult, null, 2));
             // #2661 root-fix — structured per-launch telemetry, receipted
@@ -1182,6 +1209,7 @@ Analyze the above codebase context and provide your response following the forma
                         : undefined,
                     costUsd: envelope?.costUsd,
                     apiDurationMs: envelope?.durationMs,
+                    credentialExpiresAt: envelope?.credentialExpiresAt,
                     error: code !== 0 ? stderr || `Process exited with code ${code}` : undefined,
                 });
             });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.71.1",
+  "version": "3.71.3",
   "type": "module",
   "description": "Ruflo CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",