moflo 4.12.11 → 4.13.0

package/bin/lib/get-backend.mjs

@@ -163,8 +163,10 @@ function openNodeSqlite(dbPath, opts) {
       // background indexer holds a write lock for 5–8s during its first
       // full-tree pass after `npm install`. See daemon-backend.ts twin for
       // the full rationale (#1098).
-      db.exec('PRAGMA busy_timeout = 15000');
-      db.exec('PRAGMA journal_mode = WAL');
+      db.exec(`PRAGMA busy_timeout = ${OPEN_BUSY_TIMEOUT_MS}`);
+      // Not `db.exec` directly: SQLite skips the busy handler for a
+      // journal-mode change, so this one pragma needs its own retry (#1471).
+      setWalWithRetry(db, dbPath);
       db.exec('PRAGMA synchronous = NORMAL');
       // Phase 4 / #1083 — network-FS detection. SQLite's POSIX advisory locks
       // and WAL shared-memory both fail silently on NFS/SMB; the engine falls
@@ -179,6 +181,148 @@ function openNodeSqlite(dbPath, opts) {
   return wrapNodeSqlite(db, dbPath);
 }
 
+/**
+ * Shared parking buffer for the journal-mode retry sleep. `Atomics.wait` is
+ * the only synchronous sleep that behaves identically on Linux, macOS and
+ * Windows without shelling out (Rule #1), and this open path is synchronous.
+ */
+const WAL_SLEEP_BUF = new Int32Array(new SharedArrayBuffer(4));
+
+/** @param {number} ms */
+function sleepMs(ms) {
+  Atomics.wait(WAL_SLEEP_BUF, 0, 0, ms);
+}
+
+/**
+ * The open-path `busy_timeout`. Named because two places depend on it being
+ * the same number: the pragma below sets it, and `readJournalModeBounded`
+ * restores it after narrowing it for a probe.
+ */
+const OPEN_BUSY_TIMEOUT_MS = 15_000;
+/**
+ * Budget for the post-exhaustion probe. The query form of `PRAGMA
+ * journal_mode` takes a SHARED lock and IS covered by the busy handler, so it
+ * would otherwise inherit the full `OPEN_BUSY_TIMEOUT_MS` — doubling the
+ * worst case to ~30s before we report anything on the one path where we have
+ * already decided to give up.
+ */
+const WAL_PROBE_BUSY_TIMEOUT_MS = 500;
+const WAL_PROBE_ATTEMPTS = 3;
+/** See the daemon-backend.ts twin for the budget rationale (#1471). */
+const WAL_RETRY_BUDGET_MS = OPEN_BUSY_TIMEOUT_MS;
+const WAL_RETRY_MIN_DELAY_MS = 5;
+const WAL_RETRY_MAX_DELAY_MS = 250;
+
+/**
+ * SQLITE_BUSY (5) and SQLITE_LOCKED (6). The message test is a fallback for
+ * wrappers that don't propagate `errcode`.
+ *
+ * @param {unknown} err
+ * @returns {boolean}
+ */
+function isBusyError(err) {
+  const e = /** @type {{ errcode?: number, message?: string } | null} */ (err);
+  if (e?.errcode === 5 || e?.errcode === 6) return true;
+  return /database( table)? is locked/i.test(String(e?.message ?? ''));
+}
+
+/**
+ * Current journal mode, lowercased. `''` when the probe itself fails.
+ *
+ * @param {object} db
+ * @returns {string}
+ */
+function readJournalMode(db) {
+  try {
+    const row = db.prepare('PRAGMA journal_mode').get();
+    return String(row?.journal_mode ?? '').toLowerCase();
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * `readJournalMode` under a deliberately narrow busy budget, restoring the
+ * open-path budget afterwards so a caller that survives keeps the connection
+ * it asked for. Only ever called once the retry budget is already spent.
+ *
+ * @param {object} db
+ * @returns {string}
+ */
+function readJournalModeBounded(db) {
+  try {
+    try {
+      db.exec(`PRAGMA busy_timeout = ${WAL_PROBE_BUSY_TIMEOUT_MS}`);
+    } catch {
+      // Non-fatal: we still probe, just without the narrower budget.
+    }
+    for (let attempt = 0; attempt < WAL_PROBE_ATTEMPTS; attempt++) {
+      const mode = readJournalMode(db);
+      if (mode) return mode;
+    }
+    return '';
+  } finally {
+    try {
+      db.exec(`PRAGMA busy_timeout = ${OPEN_BUSY_TIMEOUT_MS}`);
+    } catch {
+      // Non-fatal: the handle is still usable, and every path out of here
+      // either throws or hands back a database that is already in WAL.
+    }
+  }
+}
+
+/**
+ * Run `PRAGMA journal_mode = WAL`, retrying on contention (#1471).
+ *
+ * `busy_timeout` is set first and covers every other statement, but SQLite
+ * does NOT invoke the busy handler for a journal-mode change — so the one
+ * pragma the budget was put there for never gets it, and concurrent
+ * first-opens of a fresh database threw `SQLITE_BUSY` immediately, killing
+ * whichever process lost the race. On a database already in WAL the pragma is
+ * a no-op taking no exclusive lock, so the common path never enters the loop.
+ *
+ * Twin: `src/cli/memory/daemon-backend.ts:setWalWithRetry`. Keep in lockstep.
+ *
+ * @param {object} db node:sqlite DatabaseSync handle (or a test fake)
+ * @param {string} dbPath
+ * @param {number} [budgetMs]
+ */
+export function setWalWithRetry(db, dbPath, budgetMs = WAL_RETRY_BUDGET_MS) {
+  let lastErr = null;
+  let waited = 0;
+  let delay = WAL_RETRY_MIN_DELAY_MS;
+
+  for (;;) {
+    try {
+      db.exec('PRAGMA journal_mode = WAL');
+      return;
+    } catch (err) {
+      lastErr = err;
+      // Anything that isn't contention — a corrupt file, a read-only mount —
+      // will not clear by waiting. Surface it now rather than after 15s.
+      if (!isBusyError(err)) throw err;
+    }
+    if (waited >= budgetMs) break;
+    const nap = Math.min(delay, budgetMs - waited);
+    sleepMs(nap);
+    waited += nap;
+    delay = Math.min(delay * 2, WAL_RETRY_MAX_DELAY_MS);
+  }
+
+  // Budget spent. Another opener may have completed the conversion while we
+  // were losing races — the database being in WAL is the outcome we wanted,
+  // whichever process got it there.
+  const mode = readJournalModeBounded(db);
+  if (mode === 'wal') return;
+
+  throw new Error(
+    `[moflo] PRAGMA journal_mode = WAL stayed busy for ${waited}ms on ${dbPath} ` +
+    `(journal_mode is still "${mode || 'unreadable'}"). Another process is holding an ` +
+    `exclusive lock on the database. Original error: ${String(lastErr?.message ?? lastErr)}`,
+    { cause: lastErr },
+  );
+}
+
 /**
  * Read `journal_mode` back after we requested WAL. If the engine returned a
  * different mode (`delete`, `truncate`, `persist`, `memory`, `off`), the
@@ -196,16 +340,10 @@ function openNodeSqlite(dbPath, opts) {
  */
 export function warnIfNotWal(db, dbPath) {
   if (_networkFsWarnedPaths.has(dbPath)) return;
-  let mode;
-  try {
-    const stmt = db.prepare('PRAGMA journal_mode');
-    const row = stmt.get();
-    mode = String(row?.journal_mode ?? '').toLowerCase();
-  } catch {
-    // Probe must never break the open path — silent failure is acceptable
-    // because the WAL pragma above already either took effect or didn't.
-    return;
-  }
+  // A probe that throws yields '' and falls through the guard below without
+  // warning — the WAL pragma above either took effect or didn't, and a failed
+  // read is not evidence either way.
+  const mode = readJournalMode(db);
   if (mode && mode !== 'wal') {
     _networkFsWarnedPaths.add(dbPath);
     process.stderr.write(

package/bin/lib/skill-categories.mjs

@@ -56,6 +56,7 @@ export const SKILL_CATEGORIES_MAP = {
     'vector-search',
     'memory-worktree',
     'memory-team',
+    'optimize-learnings',
   ],
   spells: [
     'spell-builder',

package/bin/session-start-launcher.mjs

@@ -2612,11 +2612,19 @@ try {
       const artifactPath = mod.resolveTeamArtifactPath(projectRoot);
       if (artifactPath && existsSync(artifactPath)) {
         const report = mod.importTeamArtifact({ projectRoot, artifactPath });
-        if (report?.imported > 0) {
-          emitMutation(
-            'merged team learnings',
-            `${plural(report.imported, 'shared learning')} imported from the git-tracked team artifact`,
-          );
+        // Corrections and deletions are changes the user needs told about just
+        // as much as inserts (#1463) — reporting only `imported` is what let
+        // the additive bug sit unnoticed.
+        const changed =
+          (report?.imported ?? 0) + (report?.updated ?? 0) + (report?.deleted ?? 0) + (report?.resurrected ?? 0);
+        if (changed > 0) {
+          const detail = [
+            report.imported > 0 ? `${plural(report.imported, 'shared learning')} imported` : null,
+            report.updated > 0 ? `${report.updated} corrected` : null,
+            report.deleted > 0 ? `${report.deleted} retired` : null,
+            report.resurrected > 0 ? `${report.resurrected} restored` : null,
+          ].filter(Boolean).join(', ');
+          emitMutation('merged team learnings', `${detail} from the git-tracked team artifact`);
         }
       }
     }

package/dist/src/cli/commands/daemon.js

@@ -56,7 +56,7 @@ const startCommand = {
         { name: 'max-cpu-load', type: 'string', description: 'Override maxCpuLoad resource threshold (e.g. 4.0)' },
         { name: 'min-free-memory', type: 'string', description: 'Override minFreeMemoryPercent resource threshold (e.g. 15)' },
         { name: 'dashboard-port', type: 'string', description: `Dashboard HTTP port (default: ${DEFAULT_DASHBOARD_PORT})` },
-        { name: 'no-dashboard', type: 'boolean', description: 'Disable the dashboard HTTP server' },
+        { name: 'dashboard', type: 'boolean', default: true, description: 'Dashboard HTTP server (--no-dashboard to disable)' },
     ],
     examples: [
         { command: 'flo daemon start', description: 'Start daemon in background (default)' },
@@ -67,7 +67,10 @@ const startCommand = {
     action: async (ctx) => {
         const quiet = ctx.flags.quiet;
         const foreground = ctx.flags.foreground;
-        const noDashboard = ctx.flags.noDashboard;
+        // `--no-dashboard` parses to `dashboard = false`; there has never been a
+        // `noDashboard` flag for the parser to set (#1474). The internal name stays
+        // negative because it is threaded through the start/attach helpers below.
+        const noDashboard = ctx.flags.dashboard === false;
         const rawDashboardPort = ctx.flags.dashboardPort;
         // #1315 — the shared chokepoint. Every daemon-start path lands here:
         // `maybeAutoStartDaemon`, the session-start launcher, bin/hooks.mjs, the

package/dist/src/cli/commands/epic.js

@@ -525,7 +525,11 @@ const epicCommand = {
                     return { success: false, message: 'Usage: flo epic <issue-number> [--strategy] [--no-merge] [--verbose] [--dry-run]' };
                 }
                 const dryRun = ctx.flags.dryRun === true;
-                const noMerge = ctx.flags.noMerge === true;
+                // `--no-merge` parses to `merge = false`; there has never been a
+                // `noMerge` key, so this read was always undefined and the documented
+                // alias silently did nothing — an epic asked for single-branch ran
+                // auto-merge instead (#1474).
+                const noMerge = ctx.flags.merge === false;
                 const verbose = ctx.flags['verbose'] === true;
                 const strategyFlag = ctx.flags['strategy'];
                 let strategy = 'single-branch';

package/dist/src/cli/commands/hive-mind.js

@@ -219,7 +219,9 @@ async function spawnClaudeCodeInstance(swarmId, swarmName, objective, workers, f
             // explicitly set to 'autonomous' via flag. Non-interactive mode is
             // required for headless execution, so --dangerously-skip-permissions
             // is always included — but --allowedTools restricts the blast radius.
-            const noAutoPerms = flags.noAutoPermissions;
+            // `--no-auto-permissions` parses to `autoPermissions = false`; there has
+            // never been a `noAutoPermissions` key for the parser to set (#1474).
+            const noAutoPerms = flags.autoPermissions === false;
             if (!noAutoPerms) {
                 const permLevel = flags.permissionLevel ?? 'elevated';
                 const resolved = resolvePermissions(permLevel);
@@ -480,10 +482,10 @@ const spawnCommand = {
             default: 'elevated'
         },
         {
-            name: 'no-auto-permissions',
-            description: 'Disable automatic permission handling (Claude will prompt for each action)',
+            name: 'auto-permissions',
+            description: 'Automatic permission handling (--no-auto-permissions to prompt for each action)',
             type: 'boolean',
-            default: false
+            default: true
         },
         {
             name: 'dry-run',

package/dist/src/cli/commands/hooks.js

@@ -2008,10 +2008,10 @@ const coverageRouteCommand = {
             default: 80
         },
         {
-            name: 'no-movector',
-            description: 'Disable movector integration',
+            name: 'movector',
+            description: 'movector integration (--no-movector to disable)',
             type: 'boolean',
-            default: false
+            default: true
         }
     ],
     examples: [
@@ -2021,7 +2021,7 @@ const coverageRouteCommand = {
     action: async (ctx) => {
         const task = ctx.args[0] || ctx.flags.task;
         const threshold = ctx.flags.threshold || 80;
-        const useNativeBackend = !ctx.flags.noMovector;
+        const useNativeBackend = ctx.flags.movector !== false;
         if (!task) {
             output.printError('Task description is required. Use --task or -t flag.');
             return { success: false, exitCode: 1 };
@@ -2506,10 +2506,10 @@ const statuslineCommand = {
             default: false
         },
         {
-            name: 'no-color',
-            description: 'Disable ANSI colors',
+            name: 'color',
+            description: 'ANSI colors (--no-color to disable)',
             type: 'boolean',
-            default: false
+            default: true
         }
     ],
     examples: [
@@ -2740,7 +2740,7 @@ const statuslineCommand = {
             return { success: true, data: statusData };
         }
         // Full colored output
-        const noColor = ctx.flags.noColor;
+        const noColor = ctx.flags.color === false;
         const c = noColor ? {
             reset: '', bold: '', dim: '', red: '', green: '', yellow: '', blue: '',
             purple: '', cyan: '', brightRed: '', brightGreen: '', brightYellow: '',

package/dist/src/cli/commands/index.js

@@ -68,6 +68,11 @@ const commandLoaders = {
     epic: () => import('./epic.js'),
     // Spec-Driven Development artifacts (Epic #1269)
     sdd: () => import('./sdd.js'),
+    worktree: () => import('./worktree.js'),
+    // Alias key, not just `aliases: ['wt']` on the command: lazy commands resolve
+    // through `commandLoaders` by name, and an alias declared only on the command
+    // object is unreachable until something has already loaded it.
+    wt: () => import('./worktree.js'),
     // GitHub Repository Setup
     github: () => import('./github.js'),
     // /flo run ledger + per-run token rollup (#1333).