@maestrofrontier/frontier 1.4.5 → 1.6.0

package/frontier/judge.cjs

@@ -1,92 +1,92 @@
-#!/usr/bin/env node
-// Maestro Frontier — judge stage: build prompt + invoke Opus to produce Analysis.
-
-'use strict';
-
-const { parseAnalysis } = require('./schema.cjs');
-const dispatch = require('./dispatch.cjs');
-
-/**
- * Build the judge prompt for Opus.
- * @param {string} userPrompt
- * @param {import('./schema.cjs').PanelResponse[]} responses
- * @param {object} cfg
- * @returns {string}
- */
-function buildJudgePrompt(userPrompt, responses, cfg) {
-  const sections = responses.map(
-    r => `### Response from ${r.model}\n${r.content}`
-  ).join('\n\n');
-
-  const domainNote = (cfg.excluded_domains && cfg.excluded_domains.length > 0)
-    ? `\nDisregard any claims sourced only from the following domains: ${cfg.excluded_domains.join(', ')}.\n`
-    : '';
-
-  return `You are a neutral JUDGE evaluating multiple AI panel responses to a user question.
-
-USER QUESTION:
-${userPrompt}
-
-PANEL RESPONSES:
-${sections}
-${domainNote}
-INSTRUCTIONS:
-COMPARE the panel responses — do NOT merge or summarize them. Perform a structured analysis:
-- consensus: points that all or most models agree on
-- contradictions: topics where models disagree, with each model's specific stance
-- partial_coverage: points that only some models covered (with which models)
-- unique_insights: insights raised by exactly one model (with which model)
-- blind_spots: important points that NO model addressed
-
-OUTPUT IS ONLY a single JSON object with EXACTLY these keys:
-  consensus (string[])
-  contradictions (array of {topic: string, stances: [{model: string, stance: string}]})
-  partial_coverage (array of {models: string[], point: string})
-  unique_insights (array of {model: string, insight: string})
-  blind_spots (string[])
-
-No prose before or after. No markdown fence. No extra keys. Output the raw JSON object only.`;
-}
-
-/**
- * Run the judge stage. Returns Analysis or undefined on any failure (degrades gracefully).
- * @param {string} userPrompt
- * @param {import('./schema.cjs').PanelResponse[]} responses
- * @param {object} cfg
- * @param {{ spawn?: Function }} [deps]
- * @returns {Promise<import('./schema.cjs').Analysis | undefined>}
- */
-async function runJudge(userPrompt, responses, cfg, deps) {
-  const spawn = (deps && deps.spawn) || dispatch.spawnOne;
-  let r;
-  try {
-    r = await spawn(
-      buildJudgePrompt(userPrompt, responses, cfg),
-      cfg.adapters[cfg.judgeModel],
-      { timeoutMs: cfg.timeoutMs, fusionDepth: 1 }
-    );
-  } catch {
-    return undefined;
-  }
-
-  if (!r || !r.ok || !r.content) return undefined;
-
-  // Primary parse
-  try {
-    return parseAnalysis(r.content);
-  } catch {
-    // substring recovery: find outermost { ... }
-    const first = r.content.indexOf('{');
-    const last  = r.content.lastIndexOf('}');
-    if (first !== -1 && last > first) {
-      try {
-        return parseAnalysis(r.content.slice(first, last + 1));
-      } catch {
-        return undefined;
-      }
-    }
-    return undefined;
-  }
-}
-
-module.exports = { buildJudgePrompt, runJudge };
+#!/usr/bin/env node
+// Maestro Frontier — judge stage: build prompt + invoke Opus to produce Analysis.
+
+'use strict';
+
+const { parseAnalysis } = require('./schema.cjs');
+const dispatch = require('./dispatch.cjs');
+
+/**
+ * Build the judge prompt for Opus.
+ * @param {string} userPrompt
+ * @param {import('./schema.cjs').PanelResponse[]} responses
+ * @param {object} cfg
+ * @returns {string}
+ */
+function buildJudgePrompt(userPrompt, responses, cfg) {
+  const sections = responses.map(
+    r => `### Response from ${r.model}\n${r.content}`
+  ).join('\n\n');
+
+  const domainNote = (cfg.excluded_domains && cfg.excluded_domains.length > 0)
+    ? `\nDisregard any claims sourced only from the following domains: ${cfg.excluded_domains.join(', ')}.\n`
+    : '';
+
+  return `You are a neutral JUDGE evaluating multiple AI panel responses to a user question.
+
+USER QUESTION:
+${userPrompt}
+
+PANEL RESPONSES:
+${sections}
+${domainNote}
+INSTRUCTIONS:
+COMPARE the panel responses — do NOT merge or summarize them. Perform a structured analysis:
+- consensus: points that all or most models agree on
+- contradictions: topics where models disagree, with each model's specific stance
+- partial_coverage: points that only some models covered (with which models)
+- unique_insights: insights raised by exactly one model (with which model)
+- blind_spots: important points that NO model addressed
+
+OUTPUT IS ONLY a single JSON object with EXACTLY these keys:
+  consensus (string[])
+  contradictions (array of {topic: string, stances: [{model: string, stance: string}]})
+  partial_coverage (array of {models: string[], point: string})
+  unique_insights (array of {model: string, insight: string})
+  blind_spots (string[])
+
+No prose before or after. No markdown fence. No extra keys. Output the raw JSON object only.`;
+}
+
+/**
+ * Run the judge stage. Returns Analysis or undefined on any failure (degrades gracefully).
+ * @param {string} userPrompt
+ * @param {import('./schema.cjs').PanelResponse[]} responses
+ * @param {object} cfg
+ * @param {{ spawn?: Function }} [deps]
+ * @returns {Promise<import('./schema.cjs').Analysis | undefined>}
+ */
+async function runJudge(userPrompt, responses, cfg, deps) {
+  const spawn = (deps && deps.spawn) || dispatch.spawnOne;
+  let r;
+  try {
+    r = await spawn(
+      buildJudgePrompt(userPrompt, responses, cfg),
+      cfg.adapters[cfg.judgeModel],
+      { timeoutMs: cfg.timeoutMs, fusionDepth: 1 }
+    );
+  } catch {
+    return undefined;
+  }
+
+  if (!r || !r.ok || !r.content) return undefined;
+
+  // Primary parse
+  try {
+    return parseAnalysis(r.content);
+  } catch {
+    // substring recovery: find outermost { ... }
+    const first = r.content.indexOf('{');
+    const last  = r.content.lastIndexOf('}');
+    if (first !== -1 && last > first) {
+      try {
+        return parseAnalysis(r.content.slice(first, last + 1));
+      } catch {
+        return undefined;
+      }
+    }
+    return undefined;
+  }
+}
+
+module.exports = { buildJudgePrompt, runJudge };

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 };