@maestrofrontier/frontier 1.4.5 → 1.6.0

package/frontier/semaphore.cjs

@@ -1,49 +1,49 @@
-#!/usr/bin/env node
-// Maestro Frontier — bounded-concurrency map utility.
-// mapLimit(items, limit, asyncFn) -> Promise<settled[]>
-// Each settled item is {ok:true,value} or {ok:false,error}.
-// A rejected task releases its permit and does NOT starve the pool.
-
-'use strict';
-
-/**
- * @template T, R
- * @param {T[]} items
- * @param {number} limit
- * @param {(item: T, index: number) => Promise<R>} asyncFn
- * @returns {Promise<({ok:true,value:R}|{ok:false,error:unknown})[]}
- */
-function mapLimit(items, limit, asyncFn) {
-  return new Promise((resolve) => {
-    const n = items.length;
-    if (n === 0) { resolve([]); return; }
-
-    const results = new Array(n);
-    let nextIdx = 0;   // index of next item to start
-    let inFlight = 0;  // currently running tasks
-    let done = 0;      // settled tasks
-
-    function run() {
-      while (inFlight < limit && nextIdx < n) {
-        const idx = nextIdx++;
-        inFlight++;
-        Promise.resolve()
-          .then(() => asyncFn(items[idx], idx))
-          .then(
-            (value) => { results[idx] = { ok: true, value }; },
-            (error) => { results[idx] = { ok: false, error }; }
-          )
-          .finally(() => {
-            inFlight--;
-            done++;
-            if (done === n) { resolve(results); return; }
-            run();
-          });
-      }
-    }
-
-    run();
-  });
-}
-
-module.exports = { mapLimit };
+#!/usr/bin/env node
+// Maestro Frontier — bounded-concurrency map utility.
+// mapLimit(items, limit, asyncFn) -> Promise<settled[]>
+// Each settled item is {ok:true,value} or {ok:false,error}.
+// A rejected task releases its permit and does NOT starve the pool.
+
+'use strict';
+
+/**
+ * @template T, R
+ * @param {T[]} items
+ * @param {number} limit
+ * @param {(item: T, index: number) => Promise<R>} asyncFn
+ * @returns {Promise<({ok:true,value:R}|{ok:false,error:unknown})[]}
+ */
+function mapLimit(items, limit, asyncFn) {
+  return new Promise((resolve) => {
+    const n = items.length;
+    if (n === 0) { resolve([]); return; }
+
+    const results = new Array(n);
+    let nextIdx = 0;   // index of next item to start
+    let inFlight = 0;  // currently running tasks
+    let done = 0;      // settled tasks
+
+    function run() {
+      while (inFlight < limit && nextIdx < n) {
+        const idx = nextIdx++;
+        inFlight++;
+        Promise.resolve()
+          .then(() => asyncFn(items[idx], idx))
+          .then(
+            (value) => { results[idx] = { ok: true, value }; },
+            (error) => { results[idx] = { ok: false, error }; }
+          )
+          .finally(() => {
+            inFlight--;
+            done++;
+            if (done === n) { resolve(results); return; }
+            run();
+          });
+      }
+    }
+
+    run();
+  });
+}
+
+module.exports = { mapLimit };

package/frontier/synthesize.cjs

@@ -1,79 +1,79 @@
-#!/usr/bin/env node
-// Maestro Frontier — synthesis stage: build prompt + invoke Opus for final answer.
-
-'use strict';
-
-const dispatch = require('./dispatch.cjs');
-
-/**
- * Build the synthesis prompt for Opus.
- * @param {string} userPrompt
- * @param {{ analysis?: import('./schema.cjs').Analysis, responses: import('./schema.cjs').PanelResponse[] }} bundle
- * @param {object} cfg
- * @returns {string}
- */
-function buildSynthPrompt(userPrompt, bundle, cfg) {
-  const antiMajority =
-    'Do NOT majority-vote or pick the most common answer; weigh correctness and evidence — ' +
-    'a single correct minority response outweighs a popular wrong one.';
-
-  let groundingSection;
-  if (bundle.analysis) {
-    groundingSection =
-      `PANEL ANALYSIS (structured):
-${JSON.stringify(bundle.analysis, null, 2)}
-
-Ground your final answer in this analysis:
-- Adopt the consensus points as established facts.
-- RESOLVE contradictions by reasoning about which stance is most correct; do not dodge them.
-- Preserve unique insights that add value.
-- Address any blind spots the analysis identified.`;
-  } else {
-    const raw = bundle.responses.map(
-      r => `### Response from ${r.model}\n${r.content}`
-    ).join('\n\n');
-    groundingSection =
-      `RAW PANEL RESPONSES:
-${raw}
-
-Ground your final answer in these responses.`;
-  }
-
-  return `You are a SYNTHESIZER producing the definitive final answer to a user question.
-
-USER QUESTION:
-${userPrompt}
-
-${groundingSection}
-
-IMPORTANT: ${antiMajority}
-
-Write the final answer as clear, direct prose. No JSON, no meta-commentary, no preamble about your process. Output the answer only.`;
-}
-
-/**
- * Run the synthesis stage. Returns the final answer string or '' on failure (degrades gracefully).
- * @param {string} userPrompt
- * @param {{ analysis?: import('./schema.cjs').Analysis, responses: import('./schema.cjs').PanelResponse[] }} bundle
- * @param {object} cfg
- * @param {{ spawn?: Function }} [deps]
- * @returns {Promise<string>}
- */
-async function runSynth(userPrompt, bundle, cfg, deps) {
-  const spawn = (deps && deps.spawn) || dispatch.spawnOne;
-  let r;
-  try {
-    r = await spawn(
-      buildSynthPrompt(userPrompt, bundle, cfg),
-      cfg.adapters[cfg.synthModel],
-      { timeoutMs: cfg.timeoutMs, fusionDepth: 1 }
-    );
-  } catch {
-    return '';
-  }
-
-  if (r && r.ok && r.content) return r.content;
-  return '';
-}
-
-module.exports = { buildSynthPrompt, runSynth };
+#!/usr/bin/env node
+// Maestro Frontier — synthesis stage: build prompt + invoke Opus for final answer.
+
+'use strict';
+
+const dispatch = require('./dispatch.cjs');
+
+/**
+ * Build the synthesis prompt for Opus.
+ * @param {string} userPrompt
+ * @param {{ analysis?: import('./schema.cjs').Analysis, responses: import('./schema.cjs').PanelResponse[] }} bundle
+ * @param {object} cfg
+ * @returns {string}
+ */
+function buildSynthPrompt(userPrompt, bundle, cfg) {
+  const antiMajority =
+    'Do NOT majority-vote or pick the most common answer; weigh correctness and evidence — ' +
+    'a single correct minority response outweighs a popular wrong one.';
+
+  let groundingSection;
+  if (bundle.analysis) {
+    groundingSection =
+      `PANEL ANALYSIS (structured):
+${JSON.stringify(bundle.analysis, null, 2)}
+
+Ground your final answer in this analysis:
+- Adopt the consensus points as established facts.
+- RESOLVE contradictions by reasoning about which stance is most correct; do not dodge them.
+- Preserve unique insights that add value.
+- Address any blind spots the analysis identified.`;
+  } else {
+    const raw = bundle.responses.map(
+      r => `### Response from ${r.model}\n${r.content}`
+    ).join('\n\n');
+    groundingSection =
+      `RAW PANEL RESPONSES:
+${raw}
+
+Ground your final answer in these responses.`;
+  }
+
+  return `You are a SYNTHESIZER producing the definitive final answer to a user question.
+
+USER QUESTION:
+${userPrompt}
+
+${groundingSection}
+
+IMPORTANT: ${antiMajority}
+
+Write the final answer as clear, direct prose. No JSON, no meta-commentary, no preamble about your process. Output the answer only.`;
+}
+
+/**
+ * Run the synthesis stage. Returns the final answer string or '' on failure (degrades gracefully).
+ * @param {string} userPrompt
+ * @param {{ analysis?: import('./schema.cjs').Analysis, responses: import('./schema.cjs').PanelResponse[] }} bundle
+ * @param {object} cfg
+ * @param {{ spawn?: Function }} [deps]
+ * @returns {Promise<string>}
+ */
+async function runSynth(userPrompt, bundle, cfg, deps) {
+  const spawn = (deps && deps.spawn) || dispatch.spawnOne;
+  let r;
+  try {
+    r = await spawn(
+      buildSynthPrompt(userPrompt, bundle, cfg),
+      cfg.adapters[cfg.synthModel],
+      { timeoutMs: cfg.timeoutMs, fusionDepth: 1 }
+    );
+  } catch {
+    return '';
+  }
+
+  if (r && r.ok && r.content) return r.content;
+  return '';
+}
+
+module.exports = { buildSynthPrompt, runSynth };

package/hooks/frontier-autorun.cjs

@@ -1,120 +1,135 @@
-#!/usr/bin/env node
-// Maestro Frontier autorun hook (UserPromptSubmit). When the engine is
-// armed (frontier-state mode != 'off'), every user prompt is run through
-// the configured preset/model via runFrontier, and the synthesized answer
-// is injected back as additionalContext with a relay instruction + a
-// one-line preset header, so the live session relays it. mode == 'off' ->
-// zero overhead: no engine require, no spawn, no injected context.
-//
-// Recursion guard (load-bearing): the engine spawns child `claude -p`
-// CLIs, and headless `claude -p` re-fires UserPromptSubmit hooks (verified
-// against the Claude Code hooks contract). dispatch.cjs sets FUSION_DEPTH
-// on every spawned child; this hook no-ops whenever FUSION_DEPTH is present,
-// BEFORE any engine require or spawn. Without it the first armed prompt
-// would fork the engine recursively.
-//
-// Degrade-to-normal: any engine error, empty answer, or thrown exception
-// exits 0 with empty stdout (logging only to stderr), so a broken engine
-// never blocks or corrupts a turn — the session just answers normally. A
-// UserPromptSubmit hook can only ADD context; it cannot suppress the main
-// turn, which is exactly the relay model.
-//
-// .cjs so Node treats it as CommonJS regardless of any parent "type":
-// "module" package.json. configDir/state patterns reused from
-// frontier/config.cjs; structure ported from maestro-terse-mode.cjs.
-
-'use strict';
-
-const fs = require('fs');
-
-function noop() { process.exit(0); }
-
-let data = {};
-try { data = JSON.parse(fs.readFileSync(0, 'utf8')); } catch { noop(); }
-
-if (data.hook_event_name !== 'UserPromptSubmit') noop();
-
-// Recursion guard FIRST: never run the engine inside an engine-spawned CLI.
-// The engine sets FUSION_DEPTH on every child (dispatch.cjs:108); depth >= 1
-// means we are inside a spawned panel/judge/synth process. Mirror run.cjs's
-// own parseInt check (run.cjs:27) so the two layers agree and a stray
-// FUSION_DEPTH='0'/'' in the environment reads as "not a child".
-const fusionDepth = parseInt(process.env.FUSION_DEPTH || '0', 10);
-if (Number.isFinite(fusionDepth) && fusionDepth >= 1) noop();
-
-let state;
-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 });
-  state = cfg.loadState(scope);
-} catch {
-  noop();
-}
-
-// Off -> zero overhead: no run.cjs require, no spawn, no injected context.
-if (!state || state.mode === 'off') noop();
-
-const prompt = String(data.prompt || '');
-
-// Optional length gate (default 0 = every prompt). Skips trivially short
-// prompts ("yes"/"ok") so they don't pay a full engine run.
-const rawMin = Number(state.autorunMinChars);
-const minChars = Number.isFinite(rawMin) && rawMin > 0 ? rawMin : 0;
-if (prompt.trim().length < minChars) noop();
-
-// Any unexpected throw after the await boundary degrades to a normal turn,
-// never a non-zero exit / unhandled rejection.
-run().catch((e) => {
-  process.stderr.write('frontier-autorun: ' + ((e && e.message) || e) + '\n');
-  process.exit(0);
-});
-
-async function run() {
-  let result;
-  try {
-    const { runFrontier } = require('../frontier/run.cjs');
-    result = await runFrontier({ prompt, state });
-  } catch (e) {
-    process.stderr.write('frontier-autorun: ' + ((e && e.message) || e) + '\n');
-    noop();
-  }
-
-  if (!result || result.status !== 'ok' || !result.final) {
-    if (result && result.status === 'error') {
-      process.stderr.write(
-        'frontier-autorun: engine error [' + result.failure_reason + ']: ' + result.error + '\n');
-    }
-    noop();
-  }
-
-  const context =
-    'MAESTRO FRONTIER AUTORUN — ' + presetHeader(state) + '\n\n' +
-    'The Maestro Frontier engine already ran this prompt through the panel ' +
-    'above and produced the answer below. Relay it as your response — you ' +
-    'may reformat for clarity, but do not redo the work or contradict it:\n\n' +
-    result.final;
-
-  // fs.writeSync (synchronous, unbuffered) guarantees the full payload reaches
-  // stdout before exit. process.exit() does NOT drain a pipe-backed
-  // process.stdout, which would truncate a large engine answer (multi-KB
-  // synthesis) into malformed JSON the hook consumer cannot parse.
-  fs.writeSync(1, JSON.stringify({
-    hookSpecificOutput: {
-      hookEventName: 'UserPromptSubmit',
-      additionalContext: context,
-    },
-  }));
-  process.exit(0);
-}
-
-function presetHeader(st) {
-  if (st.mode === 'single') return 'single · ' + st.model;
-  if (st.mode === 'fusion') {
-    const preset = st.preset === 'custom'
-      ? 'custom (' + (Array.isArray(st.models) ? st.models.join(', ') : '') + ')'
-      : st.preset;
-    return 'fusion · ' + preset;
-  }
-  return String(st.mode);
-}
+#!/usr/bin/env node
+// Maestro Frontier autorun hook (UserPromptSubmit). When the engine is
+// armed (frontier-state mode != 'off'), every user prompt is run through
+// the configured preset/model via runFrontier, and the synthesized answer
+// is injected back as additionalContext with a relay instruction + a
+// one-line preset header, so the live session relays it. mode == 'off' ->
+// zero overhead: no engine require, no spawn, no injected context.
+//
+// Recursion guard (load-bearing): the engine spawns child `claude -p`
+// CLIs, and headless `claude -p` re-fires UserPromptSubmit hooks (verified
+// against the Claude Code hooks contract). dispatch.cjs sets FUSION_DEPTH
+// on every spawned child; this hook no-ops whenever FUSION_DEPTH is present,
+// BEFORE any engine require or spawn. Without it the first armed prompt
+// would fork the engine recursively.
+//
+// Degrade-to-normal: any engine error, empty answer, or thrown exception
+// exits 0 with empty stdout (logging only to stderr), so a broken engine
+// never blocks or corrupts a turn — the session just answers normally. A
+// UserPromptSubmit hook can only ADD context; it cannot suppress the main
+// turn, which is exactly the relay model.
+//
+// .cjs so Node treats it as CommonJS regardless of any parent "type":
+// "module" package.json. configDir/state patterns reused from
+// frontier/config.cjs; structure ported from maestro-terse-mode.cjs.
+
+'use strict';
+
+const fs = require('fs');
+
+function noop() { process.exit(0); }
+
+let data = {};
+try { data = JSON.parse(fs.readFileSync(0, 'utf8')); } catch { noop(); }
+
+if (data.hook_event_name !== 'UserPromptSubmit') noop();
+
+// Recursion guard FIRST: never run the engine inside an engine-spawned CLI.
+// The engine sets FUSION_DEPTH on every child (dispatch.cjs:108); depth >= 1
+// means we are inside a spawned panel/judge/synth process. Mirror run.cjs's
+// own parseInt check (run.cjs:27) so the two layers agree and a stray
+// FUSION_DEPTH='0'/'' in the environment reads as "not a child".
+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();
+  scope = cfg.resolveScope([], { cwd });
+  state = cfg.loadState(scope);
+} catch {
+  noop();
+}
+
+// Off -> zero overhead: no run.cjs require, no spawn, no injected context.
+if (!state || state.mode === 'off') noop();
+
+const prompt = String(data.prompt || '');
+
+// Optional length gate (default 0 = every prompt). Skips trivially short
+// prompts ("yes"/"ok") so they don't pay a full engine run.
+const rawMin = Number(state.autorunMinChars);
+const minChars = Number.isFinite(rawMin) && rawMin > 0 ? rawMin : 0;
+if (prompt.trim().length < minChars) noop();
+
+// Any unexpected throw after the await boundary degrades to a normal turn,
+// never a non-zero exit / unhandled rejection.
+run().catch((e) => {
+  process.stderr.write('frontier-autorun: ' + ((e && e.message) || e) + '\n');
+  process.exit(0);
+});
+
+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, 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') {
+      process.stderr.write(
+        'frontier-autorun: engine error [' + result.failure_reason + ']: ' + result.error + '\n');
+    }
+    noop();
+  }
+
+  const modelCount = result.responses ? result.responses.length : 1;
+  const banner = '⚡ Frontier \xb7 ' + presetHeader(state) + ' \xb7 ' + modelCount + ' models \xb7 ' + Math.round(runMs / 1000) + 's';
+
+  const context =
+    'MAESTRO FRONTIER AUTORUN — ' + presetHeader(state) + '\n\n' +
+    'The Maestro Frontier engine already ran this prompt through the panel ' +
+    'above and produced the answer below. Begin your response with this exact ' +
+    'banner line (verbatim, on its own line): ' + banner + '\n\n' +
+    'Then relay the answer — you may reformat for clarity, but do not redo ' +
+    'the work or contradict it:\n\n' +
+    result.final;
+
+  // fs.writeSync (synchronous, unbuffered) guarantees the full payload reaches
+  // stdout before exit. process.exit() does NOT drain a pipe-backed
+  // process.stdout, which would truncate a large engine answer (multi-KB
+  // synthesis) into malformed JSON the hook consumer cannot parse.
+  fs.writeSync(1, JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: 'UserPromptSubmit',
+      additionalContext: context,
+    },
+  }));
+  process.exit(0);
+}
+
+function presetHeader(st) {
+  if (st.mode === 'single') return 'single · ' + st.model;
+  if (st.mode === 'fusion') {
+    const preset = st.preset === 'custom'
+      ? 'custom (' + (Array.isArray(st.models) ? st.models.join(', ') : '') + ')'
+      : st.preset;
+    return 'fusion · ' + preset;
+  }
+  return String(st.mode);
+}