@maestrofrontier/frontier 1.5.0 → 1.6.0

package/frontier/progress.cjs

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+// Maestro Frontier — live progress file for the statusline.
+//
+// The armed autorun runs the panel->judge->synth pipeline inside a blocking
+// UserPromptSubmit hook (silent to the chat until it returns). To give a live
+// signal during that wait, the hook wires makeProgressWriter(scope) as the
+// engine's onProgress callback; it writes frontier-progress.<scope>.json with
+// the current stage as each stage starts. The context-bar statusline reads
+// that file and renders a transient phase (ƒ⠿ fanning 2/3 -> ƒ⚖ judging ->
+// ƒ✶ synth) in place of the static armed badge, then snaps back when the file
+// is cleared. clearProgress removes it on completion; the statusline also
+// ignores a file whose ts is stale (>300s), so a crashed run never pins a
+// phantom phase.
+//
+// Scope + path resolution reuse frontier/config.cjs so the file the engine
+// writes is byte-for-byte the path the statusline computes (cc-<hash>). The
+// statusline only ever renders the whitelisted phase words + clamped integer
+// counts from this file -- never raw bytes -- so the file is presentation
+// data, not a trust boundary.
+//
+// .cjs so Node treats it as CommonJS regardless of a parent "type": "module".
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { statePath } = require('./config.cjs');
+
+// Phases the statusline knows how to render. The writer maps the engine's
+// onProgress events onto exactly these; anything else is dropped.
+const PHASES = ['panel', 'judge', 'synth', 'single'];
+
+/**
+ * Progress file path for a scope, derived from statePath so the scope-alias
+ * and default/suffix rules match the state file (and the statusline reader)
+ * exactly: frontier-state[.scope].json -> frontier-progress[.scope].json.
+ * @param {string} [scope]
+ * @returns {string}
+ */
+function progressPath(scope) {
+  const sp = statePath(scope);
+  return path.join(path.dirname(sp), path.basename(sp).replace('frontier-state', 'frontier-progress'));
+}
+
+/**
+ * Atomic, symlink-refusing, 0600 write of the progress record. Mirrors
+ * saveState in config.cjs. Never throws — progress is best-effort telemetry.
+ * @param {string} scope
+ * @param {{ phase:string, done?:number, total?:number }} rec
+ * @returns {boolean}
+ */
+function writeProgress(scope, rec) {
+  if (!rec || PHASES.indexOf(rec.phase) === -1) return false;
+  const clampInt = (v) => {
+    const n = Math.floor(Number(v));
+    if (!Number.isFinite(n) || n < 0) return 0;
+    return n > 99 ? 99 : n;
+  };
+  const payload = JSON.stringify({
+    phase: rec.phase,
+    done: clampInt(rec.done),
+    total: clampInt(rec.total),
+    ts: Date.now(),
+    pid: process.pid,
+  });
+  try {
+    const p = progressPath(scope);
+    const dir = path.dirname(p);
+    fs.mkdirSync(dir, { recursive: true });
+    try { if (fs.lstatSync(dir).isSymbolicLink()) return false; } catch { return false; }
+    try {
+      if (fs.lstatSync(p).isSymbolicLink()) return false;
+    } catch (e) {
+      if (e.code !== 'ENOENT') return false;
+    }
+    const tempPath = path.join(dir, '.frontier-progress.' + process.pid + '.' + Date.now() + '.tmp');
+    const O_NOFOLLOW = typeof fs.constants.O_NOFOLLOW === 'number' ? fs.constants.O_NOFOLLOW : 0;
+    const flags = fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL | O_NOFOLLOW;
+    let fd;
+    try {
+      if (O_NOFOLLOW === 0) { try { if (fs.lstatSync(tempPath).isSymbolicLink()) return false; } catch {} }
+      fd = fs.openSync(tempPath, flags, 0o600);
+      fs.writeSync(fd, payload);
+      try { fs.fchmodSync(fd, 0o600); } catch {}
+    } finally {
+      if (fd !== undefined) fs.closeSync(fd);
+    }
+    fs.renameSync(tempPath, p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Remove the progress file for a scope. Never throws.
+ * @param {string} scope
+ */
+function clearProgress(scope) {
+  try { fs.unlinkSync(progressPath(scope)); } catch {}
+}
+
+/**
+ * Build an onProgress(event) callback that writes the current stage to the
+ * progress file. Maps engine events -> statusline phases; ignores terminal
+ * events (panel-done/degraded/done — the caller clears the file on completion).
+ * Never throws.
+ * @param {string} scope
+ * @returns {(event:object)=>void}
+ */
+function makeProgressWriter(scope) {
+  return function onProgress(ev) {
+    if (!ev || typeof ev.phase !== 'string') return;
+    let rec = null;
+    switch (ev.phase) {
+      case 'panel-start':
+        rec = { phase: 'panel', done: 0, total: Array.isArray(ev.models) ? ev.models.length : 0 };
+        break;
+      case 'panel-progress':
+        rec = { phase: 'panel', done: ev.done, total: ev.total };
+        break;
+      case 'judge-start':
+        rec = { phase: 'judge', done: 0, total: 0 };
+        break;
+      case 'synth-start':
+        rec = { phase: 'synth', done: 0, total: 0 };
+        break;
+      case 'single-start':
+        rec = { phase: 'single', done: 0, total: 0 };
+        break;
+      default:
+        return;
+    }
+    writeProgress(scope, rec);
+  };
+}
+
+module.exports = { progressPath, writeProgress, clearProgress, makeProgressWriter, PHASES };

package/hooks/frontier-autorun.cjs

@@ -43,10 +43,11 @@ const fusionDepth = parseInt(process.env.FUSION_DEPTH || '0', 10);
 if (Number.isFinite(fusionDepth) && fusionDepth >= 1) noop();
 
 let state;
+let scope;
 try {
   const cfg = require('../frontier/config.cjs');
   const cwd = data.cwd || process.env.CLAUDE_PROJECT_DIR || process.env.CODEX_PROJECT_DIR || process.cwd();
-  const scope = cfg.resolveScope([], { cwd });
+  scope = cfg.resolveScope([], { cwd });
   state = cfg.loadState(scope);
 } catch {
   noop();
@@ -73,14 +74,21 @@ run().catch((e) => {
 async function run() {
   let result;
   const runStart = Date.now();
+  // Live statusline progress: write the current stage as each one starts so
+  // the context-bar can show ƒ⠿ fanning / ƒ⚖ judging / ƒ✶ synth during the
+  // otherwise-silent blocking run. Cleared below on completion or error.
+  const progress = require('../frontier/progress.cjs');
+  const onProgress = progress.makeProgressWriter(scope);
   try {
     const { runFrontier } = require('../frontier/run.cjs');
-    result = await runFrontier({ prompt, state });
+    result = await runFrontier({ prompt, state, deps: { onProgress } });
   } catch (e) {
+    progress.clearProgress(scope);
     process.stderr.write('frontier-autorun: ' + ((e && e.message) || e) + '\n');
     noop();
   }
   const runMs = Date.now() - runStart;
+  progress.clearProgress(scope);
 
   if (!result || result.status !== 'ok' || !result.final) {
     if (result && result.status === 'error') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maestrofrontier/frontier",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "Achieve Frontier AI performance in your CLI by fusing the model CLIs you already run. Maestro Frontier is an opt-in, zero-dependency local multi-CLI fusion engine for AI coding agents: fan a prompt across a panel of any 1 to 8 local model CLIs you pick, have a judge model and a synthesizer you choose read the answers into a structured analysis and write one grounded synthesis (default Opus 4.8, override either with --judge/--synth). On a 100-task benchmark every fusion panel outscored its individual member models. Three adapters ship today: Opus 4.8, GPT-5.5, Gemini 3.1 Pro, with Kimi, DeepSeek, GLM, and Qwen to follow. Off, single, and fusion modes switch via /maestro:frontier. Built on Maestro orchestration discipline: decision-gated routing, verified done-claims, surgical scope, and structural enforcement hooks.",
   "keywords": ["multi-cli-fusion", "fusion-engine", "frontier", "multi-agent", "orchestration", "claude-code", "gemini", "codex", "agents", "hooks", "doctrine"],
   "license": "MIT",
@@ -20,6 +20,7 @@
     "frontier/config.cjs",
     "frontier/dispatch.cjs",
     "frontier/judge.cjs",
+    "frontier/progress.cjs",
     "frontier/run.cjs",
     "frontier/schema.cjs",
     "frontier/semaphore.cjs",