moflo 4.12.4-rc.2 → 4.12.4-rc.3

package/.claude/helpers/statusline.cjs

@@ -649,17 +649,32 @@ function getUpgradeNotice() {
   };
 }
 
+// #1363: an 'upgrade' notice that still reads 'in-progress' when we render is
+// never live work. Claude Code paints the statusline only AFTER the SessionStart
+// hook returns, and the launcher flips the notice to 'completed' the moment the
+// upgrade functionally lands (commitVersionStamp) — so reaching this code with
+// 'in-progress' means the launcher died before finishing its sync: killed by the
+// 5s hook timeout via SIGKILL, or Windows TerminateProcess, neither of which runs
+// the launcher's cleanup handlers. Rendering "(updating…)" there advertises
+// progress nothing is making, and because the TTL is only evaluated when Claude
+// Code re-invokes this script, that badge stays frozen on screen until the next
+// repaint. Report the stall instead, and point at the fix.
+//
+// 'repair' notices are exempt: §0's bootstrap sentinel deliberately holds an
+// in-progress one open to keep the healer prompt in front of the user until §3h
+// resolves it, so there the in-flight state is the intended signal.
 function formatUpgradeNoticeSegment(notice) {
   if (!notice) return '';
   const inFlight = notice.status === 'in-progress';
-  const suffix = inFlight ? ` ${c.dim}(updating…)${c.reset}` : '';
-  // Pick body text: repair > in-flight version range > completed "upgraded to"
+  const stalledUpgrade = inFlight && notice.kind !== 'repair';
+  const suffix = inFlight && !stalledUpgrade ? ` ${c.dim}(updating…)${c.reset}` : '';
+  // Pick body text: repair > stalled upgrade > completed "upgraded to"
   // > bare "upgraded" fallback when no version is known.
   let body;
   if (notice.kind === 'repair') {
     body = 'install repaired';
-  } else if (inFlight) {
-    body = notice.from && notice.to ? `${notice.from} → ${notice.to}` : (notice.to || 'upgraded');
+  } else if (stalledUpgrade) {
+    return `${c.brightRed}📦 upgrade interrupted${c.reset} ${c.dim}(run /healer)${c.reset}`;
   } else {
     const target = notice.to || notice.from || '';
     body = target ? `upgraded to ${target}` : 'upgraded';

package/bin/session-start-launcher.mjs

@@ -277,6 +277,18 @@ let upgradeNoticeContext = null;
 // after the sync that installs this version's files succeeds; every section
 // after the §3 sync block runs unconditionally + idempotently each session, so
 // an abort past this point strands no upgrade work.
+// #1363: this is also the moment the statusline notice flips to 'completed'.
+// The flip used to live at the end of §3 (old §3f), after every best-effort
+// stage — hook-drift, CLAUDE.md injection, embeddings migration, the memory
+// re-index that advertises 30-60s. A launcher killed by the 5s SessionStart
+// hook-timeout never reached it, so the notice stayed 'in-progress' and the
+// statusline painted "(updating…)" for the full 5-minute in-progress TTL with
+// nothing actually running. Marking completion here — where the upgrade has
+// functionally landed — means a kill during the best-effort tail leaves a
+// truthful terminal badge instead. A kill BEFORE this point deliberately
+// leaves 'in-progress': that upgrade really didn't land, and both the exit
+// handler (graceful) and the statusline's stalled-upgrade rendering (SIGKILL)
+// surface it honestly rather than claiming success.
 function commitVersionStamp(stampPath, version) {
   try {
     mkdirSync(dirname(stampPath), { recursive: true });
@@ -284,6 +296,12 @@ function commitVersionStamp(stampPath, version) {
   } catch (err) {
     emitWarning(`version stamp write failed (${errMessage(err)}) — next launcher will re-detect the upgrade`);
   }
+  // Written even when the stamp write above failed: #1173's recovery path keys
+  // off a prior session's 'completed' notice to repair exactly that miss.
+  if (upgradeNoticeContext) {
+    writeUpgradeNotice('completed');
+    upgradeNoticeFinalized = true;
+  }
 }
 
 // 5-min TTL is a safety net for zombie launchers (statusline ignores past-TTL
@@ -977,10 +995,14 @@ try {
         };
         emitMutation('repaired stale install', 'manifest drift detected');
       }
-      // Surface a transient "(updating…)" badge in the statusline before the
-      // long-running upgrade work (manifest sync, daemon recycle, embeddings
-      // migration). See #738 — section 3f flips this to a 2-min "completed"
-      // badge once work finishes (TTL rationale at the constants above).
+      // Open the statusline notice before the long-running upgrade work
+      // (manifest sync, daemon recycle, embeddings migration). commitVersionStamp
+      // flips it to a 2-min "completed" badge the moment the upgrade lands
+      // (#1363; TTL rationale at the constants above). Nothing paints while
+      // this value is live — Claude Code renders the statusline only after the
+      // hook returns — so 'in-progress' surviving to paint time means the
+      // launcher died before the sync finished, which is what the statusline's
+      // stalled-upgrade rendering reports.
       writeUpgradeNotice('in-progress');
 
       // Stop the daemon BEFORE any DB writes (#851). It was started under the
@@ -2425,19 +2447,16 @@ try {
   } catch { /* stderr write must not throw */ }
 }
 
-// ── 3f. Flip the upgrade notice to "completed" (#636, #738) ─────────────────
-// See the TTL rationale at the constants above for why we switch to a
-// short-TTL completed badge instead of clearing the file.
-//
-// #1173: setting upgradeNoticeFinalized signals the exit handler (Option D
-// above) that the notice reached its terminal 'completed' state cleanly, so
-// the handler should NOT clear it on launcher exit. Without this flag the
-// exit cleanup would race with the statusline reader and drop the short-TTL
-// 'completed' badge the user is supposed to see.
-if (upgradeNoticeContext) {
-  writeUpgradeNotice('completed');
-  upgradeNoticeFinalized = true;
-}
+// ── 3f. (moved) Upgrade notice now completes at the version-stamp commit ────
+// The flip to 'completed' — and the upgradeNoticeFinalized flag that tells the
+// exit handler not to clear it — used to run here, at the very end of §3.
+// Everything between the sync block and this point is best-effort work that
+// routinely outlives the 5s SessionStart hook timeout, so on a slow upgrade
+// the launcher was killed before reaching it and the notice stayed
+// 'in-progress'. commitVersionStamp now owns the flip (#1363); see the
+// rationale there. Deliberately NOT reinstated as a fallback: a run that never
+// reached the stamp did not complete its upgrade, and flipping to 'completed'
+// here would paint success over exactly that failure.
 
 // ── 3g. (removed) Version stamp now commits eagerly on sync success ──────────
 // The stamp used to be deferred to here ("written LAST", #730). That made it

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

@@ -8,14 +8,11 @@ import { callMCPTool, MCPClientError } from '../mcp-client.js';
 import * as fs from 'fs';
 import * as path from 'path';
 import { errorDetail } from '../shared/utils/error-detail.js';
+import { isProjectInitialized } from '../shared/utils/project-initialized.js';
 // Default configuration
 const DEFAULT_TOPOLOGY = 'hierarchical-mesh';
 const DEFAULT_MAX_AGENTS = 15;
-// Check if project is initialized
-function isInitialized(cwd) {
-    const configPath = path.join(cwd, '.moflo', 'config.yaml');
-    return fs.existsSync(configPath);
-}
+// Check if project is initialized — shared with `flo status` (#1363).
 // Simple YAML parser for config (basic implementation)
 function parseSimpleYaml(content) {
     const result = {};
@@ -87,7 +84,7 @@ const startAction = async (ctx) => {
     const skipMcp = ctx.flags.skipMcp;
     const cwd = ctx.cwd;
     // Check initialization
-    if (!isInitialized(cwd)) {
+    if (!isProjectInitialized(cwd)) {
         output.printError('MoFlo is not initialized in this directory');
         output.printInfo('Run "flo init" first to initialize');
         return { success: false, exitCode: 1 };
@@ -365,7 +362,7 @@ const quickCommand = {
     description: 'Quick start with default settings',
     action: async (ctx) => {
         // Initialize if needed
-        if (!isInitialized(ctx.cwd)) {
+        if (!isProjectInitialized(ctx.cwd)) {
             output.printInfo('Project not initialized, running init first...');
             output.writeln();
             // Call init with minimal settings

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

@@ -4,9 +4,8 @@
  */
 import { output } from '../output.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
-import * as fs from 'fs';
-import * as path from 'path';
 import * as os from 'os';
+import { isProjectInitialized } from '../shared/utils/project-initialized.js';
 // Status refresh interval (ms)
 const DEFAULT_WATCH_INTERVAL = 2000;
 // Track CPU usage over time
@@ -32,11 +31,7 @@ function getProcessMemoryUsage() {
     const usedMemory = memoryUsage.heapUsed + memoryUsage.external;
     return (usedMemory / totalMemory) * 100;
 }
-// Check if project is initialized
-function isInitialized(cwd) {
-    const configPath = path.join(cwd, '.moflo', 'config.yaml');
-    return fs.existsSync(configPath);
-}
+// Check if project is initialized — shared with `flo start` (#1363).
 // Format uptime
 function formatUptime(ms) {
     const seconds = Math.floor(ms / 1000);
@@ -257,7 +252,7 @@ const statusAction = async (ctx) => {
     const healthCheck = ctx.flags.healthCheck;
     const cwd = ctx.cwd;
     // Check initialization
-    if (!isInitialized(cwd)) {
+    if (!isProjectInitialized(cwd)) {
         output.printError('MoFlo is not initialized in this directory');
         output.printInfo('Run "flo init" to initialize');
         return { success: false, exitCode: 1 };

package/dist/src/cli/shared/utils/project-initialized.js

@@ -0,0 +1,52 @@
+/**
+ * Shared "is this project moflo-initialized?" predicate (#1363).
+ *
+ * `flo status` and `flo start` each carried their own copy that tested for
+ * `.moflo/config.yaml` and nothing else. That file is written by
+ * `writeRuntimeConfig()` in `src/cli/init/executor.ts` only under
+ * `if (options.components.runtime)`, so any consumer who inits with a component
+ * subset never receives it — and both commands then hard-failed with
+ * "MoFlo is not initialized in this directory" on an install with a healthy
+ * `.moflo/`, a running daemon, and a working MCP server.
+ *
+ * Nothing load-bears on `.moflo/config.yaml`: `src/cli/config/cli-config-store.ts`
+ * treats it as one candidate among several. So the gate is widened to any
+ * genuine init marker, and lives in one place rather than two.
+ *
+ * Cross-platform: `path.join` throughout, no separator or case assumptions.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+/**
+ * Config files that, alongside a `.moflo/` directory, mark a project as
+ * initialized. Paths are relative to the project root and joined per-platform.
+ */
+const INIT_MARKERS = [
+    ['moflo.yaml'],
+    ['moflo.config.json'],
+    ['.moflo', 'config.yaml'],
+    ['.moflo', 'config.json'],
+];
+function isDirectory(target) {
+    try {
+        return fs.statSync(target).isDirectory();
+    }
+    catch {
+        // ENOENT, ENOTDIR, EACCES — treat every failure as "not a directory"
+        // rather than letting a permissions edge case crash the command.
+        return false;
+    }
+}
+/**
+ * True when `cwd` looks like a moflo-initialized project.
+ *
+ * Requires the `.moflo/` state directory AND at least one recognized config
+ * marker — the directory alone can be left behind by a partial teardown, and a
+ * stray `moflo.yaml` alone means init never ran.
+ */
+export function isProjectInitialized(cwd) {
+    if (!isDirectory(path.join(cwd, '.moflo')))
+        return false;
+    return INIT_MARKERS.some((segments) => fs.existsSync(path.join(cwd, ...segments)));
+}
+//# sourceMappingURL=project-initialized.js.map

package/dist/src/cli/version.js

@@ -2,5 +2,5 @@
  * Auto-generated by build. Do not edit manually.
  * Source of truth: root package.json → scripts/sync-version.mjs
  */
-export const VERSION = '4.12.4-rc.2';
+export const VERSION = '4.12.4-rc.3';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moflo",
-  "version": "4.12.4-rc.2",
+  "version": "4.12.4-rc.3",
   "description": "MoFlo — AI agent orchestration for Claude Code. A standalone, opinionated toolkit with semantic memory, learned routing, gates, spells, and the /flo issue-execution skill.",
   "main": "dist/src/cli/index.js",
   "type": "module",
@@ -98,7 +98,7 @@
     "@typescript-eslint/parser": "^8.65.0",
     "eslint": "^10.8.0",
     "glob": "^11.1.0",
-    "moflo": "^4.12.4-rc.1",
+    "moflo": "^4.12.4-rc.2",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "vitest": "^4.0.0"