@jaimevalasek/aioson 1.36.0 → 1.37.1

package/src/commands/live.js

@@ -235,14 +235,30 @@ async function resolveExecutablePath(command) {
     .map((entry) => entry.trim())
     .filter(Boolean);
 
-  const extensions = process.platform === 'win32'
-    ? Array.from(new Set([...String(process.env.PATHEXT || '.EXE;.CMD;.BAT;.COM').split(';').map((entry) => entry.toLowerCase())]))
-    : [''];
+  // No Windows NUNCA testamos o arquivo sem extensão: o npm instala um shim
+  // extensionless (script sh) ao lado do .cmd, e ele não é executável via
+  // CreateProcess — spawná-lo dá ENOENT mesmo com o arquivo existindo.
+  // filter(Boolean) descarta segmentos vazios de um PATHEXT malformado
+  // (";.COM;..."), que viravam candidato sem extensão.
+  let extensions;
+  if (process.platform === 'win32') {
+    extensions = Array.from(new Set(
+      String(process.env.PATHEXT || '.EXE;.CMD;.BAT;.COM')
+        .split(';')
+        .map((entry) => entry.trim().toLowerCase())
+        .filter(Boolean)
+    ));
+    if (extensions.length === 0) {
+      extensions = ['.exe', '.cmd', '.bat', '.com'];
+    }
+  } else {
+    extensions = [''];
+  }
 
   for (const dir of pathEntries) {
     for (const ext of extensions) {
-      const candidate = process.platform === 'win32' && ext && !binary.toLowerCase().endsWith(ext)
-        ? path.join(dir, `${binary}${ext}`)
+      const candidate = process.platform === 'win32'
+        ? (binary.toLowerCase().endsWith(ext) ? path.join(dir, binary) : path.join(dir, `${binary}${ext}`))
         : path.join(dir, binary);
       if (await exists(candidate)) {
         return candidate;
@@ -673,10 +689,30 @@ function createLiveEventRecord(context, options = {}) {
   };
 }
 
+// Latch de spawn: entre o spawn() e o await de waitForChild existem awaits
+// (writeLiveState etc.). Se o spawn falhar nessa janela, o 'error' emitia sem
+// listener e DERRUBAVA o node ("Unhandled 'error' event"). Guardamos o
+// desfecho no próprio child pra waitForChild resolver/rejeitar mesmo quando o
+// evento já passou.
+function trackChild(child) {
+  child.aiosonSpawnError = null;
+  child.aiosonExit = null;
+  child.on('error', (err) => {
+    if (!child.aiosonSpawnError) child.aiosonSpawnError = err;
+  });
+  child.on('close', (code, signal) => {
+    child.aiosonExit = { code: Number(code || 0), signal: signal || null };
+  });
+  return child;
+}
+
 function waitForChild(child) {
   return new Promise((resolve, reject) => {
+    if (child.aiosonSpawnError) return reject(child.aiosonSpawnError);
+    if (child.aiosonExit) return resolve(child.aiosonExit);
     child.once('error', reject);
     child.once('close', (code, signal) => {
+      if (child.aiosonSpawnError) return reject(child.aiosonSpawnError);
       resolve({ code: Number(code || 0), signal: signal || null });
     });
   });
@@ -1319,12 +1355,12 @@ async function runLiveStart({ args, options = {}, logger, t }) {
           let attachResult = null;
 
           if (attach && !noLaunch) {
-            attachChild = spawn(spawnExecutable(binaryPath), buildLaunchArgs(options, tool), {
+            attachChild = trackChild(spawn(spawnExecutable(binaryPath), buildLaunchArgs(options, tool), {
               cwd: targetDir,
               env: process.env,
               stdio: 'inherit',
               shell: process.platform === 'win32'
-            });
+            }));
             state.child_pid = attachChild.pid || null;
             if (existing.task?.task_key) {
               const taskMeta = parseTaskMeta(existing.task);
@@ -1428,12 +1464,12 @@ async function runLiveStart({ args, options = {}, logger, t }) {
           });
         } else {
           // Fallback to normal spawn if tmux not available
-          child = spawn(spawnExecutable(binaryPath), buildLaunchArgs(options, tool), {
+          child = trackChild(spawn(spawnExecutable(binaryPath), buildLaunchArgs(options, tool), {
             cwd: targetDir,
             env: process.env,
             stdio: 'inherit',
             shell: process.platform === 'win32'
-          });
+          }));
           taskMeta.child_pid = child.pid || null;
           updateTask(db, {
             taskKey,
@@ -1441,12 +1477,12 @@ async function runLiveStart({ args, options = {}, logger, t }) {
           });
         }
       } else {
-        child = spawn(spawnExecutable(binaryPath), buildLaunchArgs(options, tool), {
+        child = trackChild(spawn(spawnExecutable(binaryPath), buildLaunchArgs(options, tool), {
           cwd: targetDir,
           env: process.env,
           stdio: 'inherit',
           shell: process.platform === 'win32'
-        });
+        }));
         taskMeta.child_pid = child.pid || null;
         updateTask(db, {
           taskKey,

package/src/commands/op-capture.js

@@ -23,14 +23,27 @@ const path = require('node:path');
 const { resolveIdentity } = require('../operator-memory/identity');
 const { ensureStorageTree, recordIdentityActivity, openIndexDb, getStorageRoot } = require('../operator-memory/storage');
 const { deriveSlug, fingerprintProposal } = require('../operator-memory/slug');
-const { captureSignal, readProposal, VALID_SIGNAL_TYPES } = require('../operator-memory/proposal');
-const { promoteProposal } = require('../operator-memory/decision');
+const { captureSignal, readProposal, deleteProposal, VALID_SIGNAL_TYPES } = require('../operator-memory/proposal');
+const { promoteProposal, readDecision, reinforceDecision } = require('../operator-memory/decision');
 const { emitDossierEvent } = require('../lib/dossier-telemetry');
 
 const CONFIRMATIONS_JSONL = '.aioson/runtime/session-confirmations.jsonl';
 
 const PROMOTION_THRESHOLD = 2;
 
+/**
+ * Detections required before a signal promotes to a decision, by signal type.
+ *
+ * `confirmation` needs 2x — the user accepting the same non-obvious approach twice
+ * is what turns it into a signal. `authorization` / `exclusion` / `correction` are
+ * single explicit standing decisions ("pode sempre X", "nunca X", "pare de X"), so
+ * they promote on first detection. Mirrors the taxonomy in
+ * agents/_shared/memory-capture-directive.md.
+ */
+function promotionThresholdFor(signalType) {
+  return signalType === 'confirmation' ? PROMOTION_THRESHOLD : 1;
+}
+
 function existsCheckFactory(identity) {
   return (slug) => {
     const existing = readProposal(identity, slug);
@@ -130,7 +143,23 @@ First detection writes to proposals/{slug}.md. Second detection promotes to deci
 
   const count = result.proposal.detected_count;
 
-  if (count >= PROMOTION_THRESHOLD) {
+  // Idempotent re-detection: a signal already promoted to a decision is reinforced,
+  // not re-promoted — re-promotion would duplicate the FTS row and reset promoted_at.
+  const existingDecision = readDecision(resolved.identity, slug);
+  if (existingDecision) {
+    let reinforced = null;
+    try { reinforced = reinforceDecision(resolved.identity, slug); } catch { /* best-effort */ }
+    // captureSignal re-created a stray proposal (the decision had none) — drop it.
+    try { deleteProposal(resolved.identity, slug); } catch { /* best-effort */ }
+    const auditLine = `✔ Memory reforçada: '${proposal}'. aioson op:forget ${slug} p/ desfazer.`;
+    if (options.json) {
+      return { ok: true, promoted: false, reinforced: true, slug, identity: resolved.identity, reinforcement_count: reinforced ? reinforced.reinforcement_count : undefined };
+    }
+    if (logger) logger.log(auditLine);
+    return { ok: true, promoted: false, reinforced: true, slug };
+  }
+
+  if (count >= promotionThresholdFor(signal)) {
     // Promote to decision
     let decision;
     try {
@@ -166,6 +195,7 @@ First detection writes to proposals/{slug}.md. Second detection promotes to deci
 
 module.exports = {
   runOpCapture,
+  promotionThresholdFor,
   PROMOTION_THRESHOLD,
   CONFIRMATIONS_JSONL
 };

package/src/commands/op-reinforce.js

@@ -5,11 +5,9 @@
  * Phase 5 (v1.16.0). User-driven action when decay prompt fires.
  */
 
-const fs = require('node:fs');
 const { resolveIdentity } = require('../operator-memory/identity');
 const { ensureStorageTree } = require('../operator-memory/storage');
-const { readDecision, decisionPath, serializeDecision } = require('../operator-memory/decision');
-const { regenerateIndex } = require('../operator-memory/index-md');
+const { reinforceDecision } = require('../operator-memory/decision');
 const { emitDossierEvent } = require('../lib/dossier-telemetry');
 
 async function runOpReinforce({ args = [], options = {}, logger }) {
@@ -31,30 +29,20 @@ async function runOpReinforce({ args = [], options = {}, logger }) {
 
   const resolved = resolveIdentity();
   ensureStorageTree(resolved.identity);
-  const decision = readDecision(resolved.identity, slug);
-  if (!decision) {
+
+  // Surgical in-place reinforce: bumps reinforcement_count + refreshes
+  // last_reinforced and regenerates the index, preserving title/body/trigger-quotes
+  // byte-for-byte. (The old re-serialize path double-wrapped them, because the merged
+  // body from readDecision already contained the "# title" and "## Trigger quotes".)
+  const reinforced = reinforceDecision(resolved.identity, slug);
+  if (!reinforced) {
     const err = `op:reinforce — decision '${slug}' not found for identity ${resolved.identity}.`;
     if (options.json) return { ok: false, error: err };
     if (logger && logger.error) logger.error(err);
     return { ok: false, exitCode: 1, error: err };
   }
 
-  const now = new Date().toISOString();
-  const previous = decision.last_reinforced;
-  const updated = {
-    ...decision,
-    slug,
-    last_reinforced: now,
-    reinforcement_count: Number(decision.reinforcement_count || 0) + 1
-  };
-  // serialize keeps quotes + body + frontmatter intact
-  const out = serializeDecision({ ...updated, body: decision.body, title: decision.body?.split('\n')[0]?.replace(/^# /, '') || slug });
-  const filePath = decisionPath(resolved.identity, slug);
-  const tmp = `${filePath}.tmp`;
-  fs.writeFileSync(tmp, out, 'utf8');
-  fs.renameSync(tmp, filePath);
-
-  try { regenerateIndex(resolved.identity); } catch { /* non-fatal */ }
+  const { last_reinforced: now, previous, reinforcement_count } = reinforced;
 
   await emitDossierEvent(targetDir, {
     agent: 'op-reinforce',
@@ -64,7 +52,7 @@ async function runOpReinforce({ args = [], options = {}, logger }) {
   });
 
   if (options.json) {
-    return { ok: true, slug, last_reinforced: now, previous, reinforcement_count: updated.reinforcement_count };
+    return { ok: true, slug, last_reinforced: now, previous, reinforcement_count };
   }
   if (logger) logger.log(`op:reinforce — '${slug}' last_reinforced refreshed to ${now}.`);
   return { ok: true, slug };

package/src/commands/update.js

@@ -5,6 +5,7 @@ const { detectFramework } = require('../detector');
 const { updateInstallation } = require('../updater');
 const { validateProjectContextFile, getInteractionLanguage } = require('../context');
 const { applyAgentLocale } = require('../locales');
+const { getCliVersionLabelSync } = require('../version');
 
 async function runUpdate({ args, options, logger, t }) {
   const targetDir = path.resolve(process.cwd(), args[0] || '.');
@@ -36,10 +37,13 @@ async function runUpdate({ args, options, logger, t }) {
       (result.savedProfile && result.savedProfile.locale
         ? result.savedProfile.locale
         : 'en');
-    localeSync = await applyAgentLocale(targetDir, language, { dryRun, selectiveUpdate: selective && !all });
+    localeSync = await applyAgentLocale(targetDir, language, { dryRun, selectiveUpdate: selective && !all });
   }
 
   logger.log(t('update.done_at', { targetDir }));
+  // Surface WHICH template landed — stale-template updates used to be silent
+  // (the copy comes from the installed CLI's own bundle, not from npm latest).
+  logger.log(t('update.template_version', { version: getCliVersionLabelSync() }));
   logger.log(t('update.files_updated', { count: result.copied.length }));
   logger.log(t('update.backups_created', { count: result.backedUp.length }));
   if (result.migrations && result.migrations.profileRename && result.migrations.profileRename.changed) {

package/src/commands/verification-plan.js

@@ -7,7 +7,8 @@
 // instead of re-interpreting the config in prose. Read-only; never mutates state.
 
 const fs = require('node:fs/promises');
-const path = require('node:path');
+const path = require('node:path');
+const { loadManifest, resolveAgentExecution } = require('../agent-execution/manifest');
 const {
   readVerificationConfig,
   resolveHost,
@@ -24,6 +25,22 @@ const {
 const BAR = '─'.repeat(60);
 const CLASSIFICATIONS = ['MICRO', 'SMALL', 'MEDIUM'];
 
+// A loud, deterministic instruction the phase loop echoes back to @dev at every
+// phase boundary. On a per-phase trigger with auto_continue it is the fresh
+// tool-result that stops the agent from ending its turn to "report" after a
+// phase — the exact failure the phase loop exists to prevent. It never tells the
+// agent to /compact: context is shed transparently by the host's auto-compact,
+// without ending the turn.
+function buildContinuationDirective(trigger, phaseLoop) {
+  if (trigger === 'end-of-feature') {
+    return 'END-OF-FEATURE — last phase: run the full runtime smoke (build + migrate + boot + Core happy-path), then hand off through the post-dev review cycle. Do not close/publish — that is the human gate.';
+  }
+  if (phaseLoop && phaseLoop.auto_continue) {
+    return 'CONTINUE-NOW — a clean report is a checkpoint, not a stop. Go DIRECTLY into the next phase in this same turn: do not stop, do not ask "continue?", do not summarize-and-end, and never self-issue /compact (the host auto-compacts transparently). Halt only on a failing gate/verification after retries or a genuine hard stop.';
+  }
+  return 'PAUSE — auto_continue is off: after this phase report, stop and wait for confirmation before the next phase.';
+}
+
 async function readFileSafe(filePath) {
   try {
     return await fs.readFile(filePath, 'utf8');
@@ -47,15 +64,28 @@ async function detectClassification(targetDir, slug) {
   return null;
 }
 
-async function runVerificationPlan({ args, options = {}, logger }) {
+async function runVerificationPlan({ args, options = {}, logger, catalogLoader }) {
   const targetDir = path.resolve(process.cwd(), args[0] || '.');
   const slug = (options.feature || options.slug || '').toString().trim() || null;
 
   const triggerRaw = (options.trigger || 'per-phase').toString().trim().toLowerCase();
-  const trigger = TRIGGERS.includes(triggerRaw) ? triggerRaw : 'per-phase';
+  // An unknown trigger must fail loudly. Silently coercing it to per-phase used
+  // to emit an imperative CONTINUE-NOW directive on what was actually a typo'd
+  // end-of-feature call — steering @dev into a phase that does not exist.
+  if (!TRIGGERS.includes(triggerRaw)) {
+    const failure = { ok: false, reason: 'invalid_trigger', trigger: triggerRaw, valid_triggers: [...TRIGGERS] };
+    if (options.json) return failure;
+    logger.error(`Invalid --trigger=${triggerRaw}. Valid triggers: ${TRIGGERS.join(', ')}.`);
+    return failure;
+  }
+  const trigger = triggerRaw;
 
-  const config = await readVerificationConfig(targetDir);
-  const host = resolveHost(config, options.host);
+  const config = await readVerificationConfig(targetDir);
+  const host = resolveHost(config, options.host);
+  const executionManifest = slug ? await loadManifest(targetDir, slug) : { exists: false, legacy: true, ok: true };
+  if (executionManifest.exists && !executionManifest.ok) {
+    return { ok: false, reason: 'agent_execution_manifest_invalid', errors: executionManifest.errors, manifest_path: executionManifest.path };
+  }
 
   let classification = (options.classification || '').toString().trim().toUpperCase();
   if (!CLASSIFICATIONS.includes(classification)) {
@@ -66,13 +96,24 @@ async function runVerificationPlan({ args, options = {}, logger }) {
   const context = { trigger, classification, sensitiveSurface };
   const agents = [];
   for (const agentId of VERIFICATION_AGENTS) {
-    const dispatch = getAgentDispatch(config, agentId, host);
-    const entry = {
+    const dispatch = getAgentDispatch(config, agentId, host);
+    const execution = executionManifest.exists ? await resolveAgentExecution(executionManifest.manifest, agentId, {}, { catalogLoader }) : null;
+    if (execution && !execution.ok) {
+      return { ok: false, reason: 'model_resolution_failed', agent: agentId, resolution: execution };
+    }
+    const entry = {
       agent: agentId,
       run: shouldRunForTrigger(config, agentId, context),
-      mode: dispatch ? dispatch.mode : 'native',
-      model: dispatch ? dispatch.model : 'configured-default',
-      report: resolveAgentReportPath(config, agentId, slug || '{slug}')
+      host: execution ? execution.host : (dispatch ? dispatch.host : host),
+      mode: execution ? execution.mode : (dispatch ? dispatch.mode : 'native'),
+      model: execution ? execution.model : (dispatch ? dispatch.model : 'configured-default'),
+      model_requested: execution ? execution.model_requested : (dispatch ? dispatch.model : 'configured-default'),
+      model_resolved: execution ? execution.model_resolved : (dispatch ? dispatch.model : 'configured-default'),
+      model_resolution_strategy: execution ? execution.model_resolution_strategy : 'legacy',
+      reasoning_effort: execution ? (execution.reasoning_effort || null) : null,
+      report: execution ? execution.report.replace('{run_id}', '{run_id}') : resolveAgentReportPath(config, agentId, slug || '{slug}'),
+      execution_source: execution ? 'manifest' : 'legacy',
+      execution: execution || undefined
     };
     if (agentId === 'validator') {
       const cc = getCrossCheck(config, agentId);
@@ -90,8 +131,10 @@ async function runVerificationPlan({ args, options = {}, logger }) {
     sensitive_surface: sensitiveSurface,
     agents,
     phase_loop: getPhaseLoop(config),
-    budget: getBudget(config)
-  };
+    budget: getBudget(config)
+  };
+  result.agent_execution = executionManifest.exists ? { source: 'manifest', path: executionManifest.path, digest: executionManifest.digest } : { source: 'legacy' };
+  result.continuation_directive = buildContinuationDirective(trigger, result.phase_loop);
 
   if (options.json) return result;
 
@@ -108,6 +151,7 @@ async function runVerificationPlan({ args, options = {}, logger }) {
   logger.log(BAR);
   const pl = result.phase_loop;
   logger.log(`Phase loop: auto_continue=${pl.auto_continue}  compact_between_phases=${pl.compact_between_phases}  max_fix_retries=${pl.max_fix_retries_per_phase}`);
+  logger.log(`▶ ${result.continuation_directive}`);
   logger.log('');
 
   return result;

package/src/commands/verify-artifact.js

@@ -179,7 +179,7 @@ const RULESETS = {
 
 // Kinds whose target file path is keyed by --slug; without it we cannot resolve
 // the artifact, so fail with a clear usage error instead of a `null/` path.
-const REQUIRES_SLUG = new Set(['genome', 'research-report', 'enriched-profile', 'hybrid-skill', 'copy']);
+const REQUIRES_SLUG = new Set(['genome', 'research-report', 'enriched-profile', 'hybrid-skill', 'copy', 'review']);
 
 // Kinds whose artifact has a date-stamped / caller-known path — resolved via
 // --file=<path> rather than derived from a slug.
@@ -374,6 +374,69 @@ const ADAPTERS = {
     return { ok: issues.length === 0, issues, warnings, checks: [{ id: 'site', ok: issues.length === 0, detail: issues.join('; ') || null }] };
   },
 
+  // briefing-refiner — the review surface must be the deterministic, fully
+  // self-contained artifact `aioson briefing:review` renders: export fallbacks
+  // present, no external resources, an embedded source_hash, and a feedback
+  // JSON that passes the canonical schema. Staleness (briefings.md changed
+  // after generation, e.g. right after an apply) is a warning, not a failure.
+  review: async (ctx) => {
+    if (!ctx.slug) {
+      return { ok: false, issues: ['kind=review requires --slug=<briefing-slug>'], warnings: [], checks: [] };
+    }
+    const { hashText } = require('../lib/briefing-refiner/briefing-sections');
+    const { validateFeedback } = require('../lib/briefing-refiner/feedback-schema');
+    const briefingDir = path.resolve(ctx.targetDir, '.aioson', 'briefings', ctx.slug);
+    const issues = [];
+    const warnings = [];
+
+    let html = null;
+    try {
+      html = fs.readFileSync(path.join(briefingDir, 'review.html'), 'utf8');
+    } catch {
+      issues.push(`review.html not found for briefing "${ctx.slug}" — run: aioson briefing:review . --slug=${ctx.slug}`);
+    }
+    if (html) {
+      if (!html.includes('aioson:review')) {
+        issues.push('review.html lacks the aioson:review marker (hand-rolled surface) — regenerate with `aioson briefing:review`');
+      }
+      if (!/id="download"/.test(html)) issues.push('review.html has no download fallback button (id="download")');
+      if (!/id="copy"/.test(html)) issues.push('review.html has no copy-JSON fallback button (id="copy")');
+      // User content is HTML-escaped by the generator (quotes become &quot;),
+      // so a real external reference can only be generator-emitted markup —
+      // match those forms only, or briefing text quoting HTML/CSS would
+      // false-positive the gate.
+      if (/<script[^>]+\bsrc=|<link[^>]+href=["']https?:|\bsrc=["']https?:/i.test(html)) {
+        issues.push('review.html references external resources — it must be fully self-contained');
+      }
+      const hashMatch = html.match(/source_hash=([0-9a-f]{64})/);
+      if (!hashMatch) {
+        issues.push('review.html has no embedded source_hash');
+      } else {
+        try {
+          const currentHash = hashText(fs.readFileSync(path.join(briefingDir, 'briefings.md'), 'utf8'));
+          if (hashMatch[1] !== currentHash) {
+            warnings.push('review.html is stale: source_hash differs from the current briefings.md — regenerate the review for the next round');
+          }
+        } catch {
+          issues.push('briefings.md not found next to review.html');
+        }
+      }
+    }
+
+    try {
+      const feedback = JSON.parse(fs.readFileSync(path.join(briefingDir, 'refinement-feedback.json'), 'utf8'));
+      const res = validateFeedback(feedback, { slug: ctx.slug, allowStale: true });
+      if (!res.ok) {
+        for (const err of res.errors) issues.push(`refinement-feedback.json: ${err}`);
+      }
+    } catch {
+      // Absent right after an apply (it gets archived) — only a warning.
+      warnings.push('refinement-feedback.json missing or unreadable — expected right after review generation');
+    }
+
+    return { ok: issues.length === 0, issues, warnings, checks: [{ id: `review:${ctx.slug}`, ok: issues.length === 0, detail: issues.join('; ') || null }] };
+  },
+
   // committer — advisory subject-quality audit. Reads --file if given, else the
   // HEAD commit message (post-commit, so the agent can amend before push).
   'commit-message': async (ctx) => {