@jaimevalasek/aioson 1.22.0 → 1.23.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jaimevalasek/aioson",
-  "version": "1.22.0",
+  "version": "1.23.0",
   "description": "AI operating framework for hyper-personalized software.",
   "keywords": [
     "ai",

package/src/agents.js

@@ -67,7 +67,7 @@ function buildAgentPrompt(agent, tool, options = {}) {
     '',
     `**Language boundary:** Agent instructions are canonical in English. All user-facing communication must be in ${interactionLanguage}.`,
     '',
-    `**Scope boundary:** You operate exclusively as ${agent.command}. Do not perform work that belongs to another agent. When your work is complete, output only the handoff — which agent is next and why. Do not continue into that agent\'s territory.${autoHandoff ? ' Exception: autopilot handoff is active for this stage — follow `.aioson/docs/autopilot-handoff.md` and auto-invoke the next agent\'s skill when no stop condition applies, never past the `@dev` handoff.' : ''}`,
+    `**Scope boundary:** You operate exclusively as ${agent.command}. Do not perform work that belongs to another agent. When your work is complete, output only the handoff — which agent is next and why. Do not continue into that agent\'s territory.${autoHandoff ? ' Exception: autopilot handoff is active for this stage — follow `.aioson/docs/autopilot-handoff.md` and auto-invoke the next agent\'s skill when no stop condition applies. The chain stops before the first `@dev` activation (human clears context and starts implementation) and continues through the post-dev review cycle (`@dev` → `@qa` → `@tester`/`@pentester` when their triggers fire → `@validator`); it NEVER auto-runs `feature:close`/publish — those require explicit human approval.' : ''}`,
   ].join('\n');
 
   if (safeTool === 'claude') {

package/src/cli.js

@@ -268,6 +268,10 @@ const JSON_SUPPORTED_COMMANDS = new Set([
   'workflow-next',
   'workflow:status',
   'workflow-status',
+  'harness:retro',
+  'harness-retro',
+  'harness:preview',
+  'harness-preview',
   'agent:next',
   'agent-next',
   'parallel:init',
@@ -405,6 +409,10 @@ const JSON_SUPPORTED_COMMANDS = new Set([
   'harness-reject',
   'harness:status',
   'harness-status',
+  'harness:retro',
+  'harness-retro',
+  'harness:preview',
+  'harness-preview',
   'brief-gen',
   'verify:gate',
   'verify-gate',
@@ -817,6 +825,8 @@ function printHelp(t, logger) {
   logHelpLine(t, logger, 'cli.help_qa_run');
   logHelpLine(t, logger, 'cli.help_qa_scan');
   logHelpLine(t, logger, 'cli.help_qa_report');
+  logHelpLine(t, logger, 'cli.help_harness_retro');
+  logHelpLine(t, logger, 'cli.help_harness_preview');
   logHelpLine(t, logger, 'cli.help_web_map');
   logHelpLine(t, logger, 'cli.help_web_scrape');
   logHelpLine(t, logger, 'cli.help_scan_project');
@@ -1271,6 +1281,12 @@ async function main() {
     } else if (command === 'harness:status' || command === 'harness-status') {
       const { runHarnessStatus } = require('./commands/harness-status');
       result = await runHarnessStatus({ args, options, logger: commandLogger, t });
+    } else if (command === 'harness:retro' || command === 'harness-retro') {
+      const { runHarnessRetro } = require('./commands/harness-retro');
+      result = await runHarnessRetro({ args, options, logger: commandLogger, t });
+    } else if (command === 'harness:preview' || command === 'harness-preview') {
+      const { runHarnessPreview } = require('./commands/harness-preview');
+      result = await runHarnessPreview({ args, options, logger: commandLogger, t });
     } else if (command === 'verify:gate' || command === 'verify-gate') {
       result = await runVerifyGate({ args, options, logger: commandLogger, t });
 

package/src/commands/harness-preview.js

@@ -0,0 +1,74 @@
+'use strict';
+
+/**
+ * `aioson harness:preview <file> [--max-bytes=8192] [--json]` (requirements §5.2).
+ *
+ * Wrapper fino e read-only de `previewArtifact` sobre um arquivo já persistido
+ * (ex.: `npm test > test.log`). Devolve preview + ponteiro para o agente de teste
+ * consumir sem despejar o log integral no contexto. Tema 2 (should-have).
+ *
+ * Exit codes: 0 sucesso; 12 input inválido (arquivo ausente/ilegível).
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const { previewArtifact, DEFAULT_MAX_BYTES } = require('../harness/preview-artifact');
+
+const EXIT_OK = 0;
+const EXIT_INPUT = 12;
+
+function tr(t, key, params, fallback) {
+  if (typeof t !== 'function') return fallback;
+  const msg = t(key, params);
+  return msg && msg !== key ? msg : fallback;
+}
+
+async function runHarnessPreview({ args, options = {}, logger, t } = {}) {
+  const log = logger || { log() {}, error() {} };
+  const file = args && args[0];
+
+  if (!file || typeof file !== 'string') {
+    log.error(tr(t, 'cli.harnessPreview.file_required', null, 'harness:preview requires a <file> path argument.'));
+    process.exitCode = EXIT_INPUT;
+    return { ok: false, exitCode: EXIT_INPUT, error: 'file_required' };
+  }
+
+  // SF-02 (decisão de design, não bug): leitor read-only operador-local. Lê
+  // qualquer path legível por design — o caso de uso é previewar logs de teste
+  // (ex.: `npm test > test.log`) que podem viver fora do cwd. Sem cruzamento de
+  // fronteira de confiança (o operador já tem acesso ao FS); por isso não há
+  // contenção de workspace aqui. Mantém-se intencionalmente irrestrito.
+  const abs = path.resolve(process.cwd(), file);
+  let content;
+  try {
+    content = fs.readFileSync(abs, 'utf8');
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      log.error(tr(t, 'cli.harnessPreview.not_found', { path: file }, `File not found: ${file}`));
+      process.exitCode = EXIT_INPUT;
+      return { ok: false, exitCode: EXIT_INPUT, error: 'not_found' };
+    }
+    log.error(tr(t, 'cli.harnessPreview.read_error', { path: file, error: err.message }, `Could not read file: ${file} (${err.message})`));
+    process.exitCode = EXIT_INPUT;
+    return { ok: false, exitCode: EXIT_INPUT, error: 'read_error' };
+  }
+
+  let maxBytes = Number(options['max-bytes'] ?? options.maxBytes ?? DEFAULT_MAX_BYTES);
+  if (!Number.isInteger(maxBytes) || maxBytes <= 0) maxBytes = DEFAULT_MAX_BYTES;
+
+  // Modo leitura: o arquivo já está persistido — não reescrever (persist:false).
+  const result = previewArtifact(content, { maxBytes, artifactPath: abs, persist: false });
+  log.log(result.preview);
+
+  return {
+    ok: true,
+    exitCode: EXIT_OK,
+    file: file.replaceAll('\\', '/'),
+    totalBytes: result.totalBytes,
+    truncated: result.truncated,
+    preview: result.preview
+  };
+}
+
+module.exports = { runHarnessPreview };

package/src/commands/harness-retro.js

@@ -0,0 +1,221 @@
+'use strict';
+
+/**
+ * `aioson harness:retro [path] --feature=<slug> | --last=<N> [--json] [--locale=<l>]`
+ *
+ * Minera deterministicamente a trilha de falhas já coletada e materializa um
+ * dossiê retrospectivo em `.aioson/context/retro/{slug}.md` (ou
+ * `window-last-{N}.md`). Leitura-apenas sobre as fontes; única escrita: o dossiê.
+ * Sem LLM, sem rede (requirements §5.1, RHO-lite).
+ *
+ * Exit codes (D4 — devolvidos em `result.exitCode`, propagados por cli.js:1649
+ * em --json e por process.exitCode no modo texto; mesmo caminho de código para
+ * fechar a classe recorrente exit-code-collapsed-in-json-mode):
+ *   0  sucesso (inclusive dossiê vazio)
+ *   1  erro de I/O inesperado
+ *   12 erro de input (slug inválido, flags conflitantes, feature inexistente)
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const {
+  collectSources, resolvePassDate, resolveFeatureExists, enumerateClosedFeatures, relPath
+} = require('../lib/retro/retro-sources');
+const { aggregate } = require('../lib/retro/retro-aggregate');
+const { renderDossier } = require('../lib/retro/retro-render');
+
+const SLUG_RE = /^[a-z0-9][a-z0-9-]*$/;
+const EXIT_OK = 0;
+const EXIT_IO = 1;
+const EXIT_INPUT = 12;
+
+function tr(t, key, params, fallback) {
+  if (typeof t !== 'function') return fallback;
+  const msg = t(key, params);
+  return msg && msg !== key ? msg : fallback;
+}
+
+/** Encerra em erro de input: registra mensagem + devolve resultado com exitCode. */
+function inputError(logger, message, error) {
+  if (logger && typeof logger.error === 'function') logger.error(message);
+  process.exitCode = EXIT_INPUT;
+  return { ok: false, exitCode: EXIT_INPUT, error, message };
+}
+
+/** Datas `completed` do MANIFEST de arquivadas (fallback de ordenação). */
+function readManifestDates(targetDir) {
+  const map = {};
+  try {
+    const text = fs.readFileSync(path.join(targetDir, '.aioson', 'context', 'done', 'MANIFEST.md'), 'utf8');
+    for (const line of text.split(/\r?\n/)) {
+      const m = line.match(/^\|\s*([a-z0-9][a-z0-9-]*)\s*\|\s*([0-9-]{8,10})\s*\|/i);
+      if (m) map[m[1]] = m[2].trim();
+    }
+  } catch { /* best-effort */ }
+  return map;
+}
+
+/**
+ * Ordena uma lista de slugs por data de PASS desc (trail vence → QA → MANIFEST).
+ * Undatáveis são excluídos com aviso, salvo se marcados como âncora obrigatória.
+ */
+function rankByPassDate(targetDir, slugs, { anchor = null } = {}) {
+  const manifest = readManifestDates(targetDir);
+  const dated = [];
+  const undated = [];
+  for (const slug of slugs) {
+    const d = resolvePassDate(targetDir, slug) || manifest[slug] || null;
+    if (d) dated.push({ slug, date: d });
+    else if (slug === anchor) dated.push({ slug, date: '' }); // âncora entra mesmo sem data
+    else undated.push(slug);
+  }
+  dated.sort((a, b) => {
+    if (a.slug === anchor) return -1;
+    if (b.slug === anchor) return 1;
+    if (a.date !== b.date) return a.date < b.date ? 1 : -1; // desc
+    return a.slug < b.slug ? -1 : 1;
+  });
+  return { ordered: dated.map((x) => x.slug), undated };
+}
+
+async function runHarnessRetro({ args, options = {}, logger, t } = {}) {
+  const log = logger || { log() {}, error() {} };
+  const targetDir = path.resolve(process.cwd(), (args && args[0]) || '.');
+
+  const hasFeature = options.feature !== undefined && options.feature !== null
+    && options.feature !== true && String(options.feature).length > 0;
+  const hasLast = options.last !== undefined && options.last !== null && options.last !== true;
+
+  // --- Validação de input (antes de qualquer toque no filesystem — REQ-8) ---
+  if (!hasFeature && !hasLast) {
+    return inputError(log,
+      tr(t, 'cli.harnessRetro.need_target', null, 'harness:retro requer --feature=<slug> ou --last=<N>'),
+      'missing_target');
+  }
+
+  let slug = null;
+  if (hasFeature) {
+    slug = String(options.feature).trim();
+    if (!SLUG_RE.test(slug)) {
+      return inputError(log,
+        tr(t, 'cli.harnessRetro.invalid_slug', { slug }, `Slug inválido: ${slug} (deve casar ^[a-z0-9][a-z0-9-]*$)`),
+        'invalid_slug');
+    }
+  }
+
+  let lastN = null;
+  if (hasLast) {
+    lastN = Number(options.last);
+    if (!Number.isInteger(lastN) || lastN < 1) {
+      return inputError(log,
+        tr(t, 'cli.harnessRetro.invalid_last', { value: String(options.last) }, `Valor inválido para --last: ${options.last} (use inteiro ≥ 1)`),
+        'invalid_last');
+    }
+  }
+
+  // --- Resolve modo, janela e arquivo de saída -----------------------------
+  let mode;
+  let slugs;
+  let outRel;
+  const warnings = [];
+
+  if (hasFeature && !hasLast) {
+    if (!resolveFeatureExists(targetDir, slug)) {
+      return inputError(log,
+        tr(t, 'cli.harnessRetro.feature_not_found', { slug },
+          `Feature não encontrada: ${slug} (procurado em .aioson/context/, .aioson/plans/${slug}/, .aioson/context/features/${slug}/, .aioson/context/done/${slug}/)`),
+        'feature_not_found');
+    }
+    mode = 'feature';
+    slugs = [slug];
+    outRel = path.join('.aioson', 'context', 'retro', `${slug}.md`);
+  } else {
+    // Qualquer uso de --last produz window-last-{N}.md (D6, modo combinado incluído).
+    mode = 'window';
+    if (hasFeature && !resolveFeatureExists(targetDir, slug)) {
+      return inputError(log,
+        tr(t, 'cli.harnessRetro.feature_not_found', { slug },
+          `Feature não encontrada: ${slug}`),
+        'feature_not_found');
+    }
+    const closed = enumerateClosedFeatures(targetDir);
+    const pool = hasFeature ? [slug, ...closed.filter((s) => s !== slug)] : closed;
+    if (pool.length === 0) {
+      return inputError(log,
+        tr(t, 'cli.harnessRetro.no_closed_features', null, 'Nenhuma feature fechada em .aioson/context/done/ para minerar'),
+        'no_closed_features');
+    }
+    const { ordered, undated } = rankByPassDate(targetDir, pool, { anchor: hasFeature ? slug : null });
+    if (undated.length > 0) {
+      warnings.push(tr(t, 'cli.harnessRetro.undatable_excluded', { count: undated.length, slugs: undated.join(', ') },
+        `${undated.length} feature(s) sem data de PASS determinável excluída(s) da janela: ${undated.join(', ')}`));
+    }
+    if (lastN > ordered.length) {
+      warnings.push(tr(t, 'cli.harnessRetro.window_truncated', { n: lastN, available: ordered.length },
+        `--last=${lastN} excede features disponíveis (${ordered.length}); minerando todas`));
+    }
+    slugs = ordered.slice(0, lastN);
+    outRel = path.join('.aioson', 'context', 'retro', `window-last-${lastN}.md`);
+  }
+
+  // --- Mineração + agregação + render --------------------------------------
+  const sources = collectSources(targetDir, slugs);
+  const allWarnings = warnings.concat(sources.warnings);
+  const { candidates, observations } = aggregate(sources);
+
+  const outRelPosix = outRel.replaceAll('\\', '/');
+  const generatedAt = new Date().toISOString();
+  const markdown = renderDossier({
+    mode,
+    slug: mode === 'feature' ? slug : undefined,
+    windowN: mode === 'window' ? lastN : undefined,
+    featuresMined: sources.features_mined,
+    counts: sources.counts,
+    candidates,
+    observations,
+    minedPaths: sources.minedPaths,
+    warnings: allWarnings,
+    dossierRelPath: outRelPosix,
+    generatedAt
+  });
+
+  // --- Escrita (única do comando) ------------------------------------------
+  const outAbs = path.join(targetDir, outRel);
+  try {
+    fs.mkdirSync(path.dirname(outAbs), { recursive: true }); // edge 7
+    fs.writeFileSync(outAbs, markdown, 'utf8'); // edge 8 (idempotente, sobrescreve)
+  } catch (err) {
+    log.error(tr(t, 'cli.harnessRetro.io_error', { error: err.message }, `Erro de I/O ao escrever o dossiê: ${err.message}`));
+    process.exitCode = EXIT_IO;
+    return { ok: false, exitCode: EXIT_IO, error: 'io_error', message: err.message };
+  }
+
+  const report = {
+    ok: true,
+    exitCode: EXIT_OK,
+    mode,
+    feature: mode === 'feature' ? slug : null,
+    window: mode === 'window' ? `last-${lastN}` : null,
+    features_mined: sources.features_mined,
+    output: outRelPosix,
+    candidates: candidates.length,
+    observations: observations.length,
+    sources: sources.counts,
+    warnings: allWarnings
+  };
+
+  if (candidates.length === 0 && observations.length === 0) {
+    log.log(tr(t, 'cli.harnessRetro.empty', { path: outRelPosix },
+      `Dossiê gerado sem propostas: ${outRelPosix} (fontes sem trilha minerável)`));
+  } else {
+    log.log(tr(t, 'cli.harnessRetro.written',
+      { path: outRelPosix, candidates: candidates.length, observations: observations.length },
+      `Dossiê retrospectivo gerado: ${outRelPosix} (${candidates.length} candidatos, ${observations.length} observações)`));
+  }
+  for (const w of allWarnings) log.log(`  ⚠ ${w}`);
+
+  return report;
+}
+
+module.exports = { runHarnessRetro };

package/src/commands/self-implement-loop.js

@@ -31,6 +31,7 @@ const { captureBaseline, computeChangedSet, captureDiffPatch } = require('../har
 const { checkScope, checkDiffLimits, buildRollbackFeedback } = require('../harness/scope-guard');
 const { estimateTokens, startRunBudget, recordAttemptTokens, checkBudget, buildBudgetSummary } = require('../harness/budget-guard');
 const { writeAttemptArtifacts } = require('../harness/attempt-artifacts');
+const { previewArtifact } = require('../harness/preview-artifact');
 const { emitGuardEvent } = require('../harness/guard-events');
 const { detectGates, createGate, enterHumanGate, resolveGateState, pendingGates, loadGates } = require('../harness/human-gate');
 const { runCriteria, registerFailureSignatures, startRunSignatures } = require('../harness/criteria-runner');
@@ -293,9 +294,18 @@ async function runPostAttemptGuards({ targetDir, guards, cb, logger, attempt, ag
       } else if (failed.length > 0) {
         logger.log(`  ✗ Criteria checks falharam: ${failed.map((c) => c.id).join(', ')}`);
         outcome.reason = 'criteria_check_failed';
+        // AC-13: feedback = preview + ponteiro para attempts/{n}/checks/{id}.log
+        // (já persistido integralmente por writeAttemptArtifacts acima — persist-first
+        // satisfeito pelo fluxo existente). Evita dump integral no contexto do agente.
         outcome.feedback = failed
-          .map((c) => `Criterion ${c.id} failed (exit ${c.exitCode}${c.timedOut ? ', timeout' : ''}): ${(c.stderr || c.stdout || '').split('\n').find((l) => l.trim()) || 'no output'}`)
-          .join('\n');
+          .map((c) => {
+            const safeId = String(c.id || 'check').replace(/[^A-Za-z0-9._-]/g, '_');
+            const logPath = path.join(planDir, 'attempts', String(attempt), 'checks', `${safeId}.log`);
+            const raw = `${c.stdout || ''}${c.stderr ? `\n${c.stderr}` : ''}`.trim() || 'no output';
+            const { preview } = previewArtifact(raw, { maxBytes: 1024, artifactPath: logPath, persist: false });
+            return `Criterion ${c.id} failed (exit ${c.exitCode}${c.timedOut ? ', timeout' : ''}):\n${preview}`;
+          })
+          .join('\n\n');
         outcome.issues = [{ message: outcome.feedback }];
       }
     }

package/src/commands/workflow-next.js

@@ -40,8 +40,15 @@ const DEFAULT_FEATURE_WORKFLOW_BY_CLASSIFICATION = {
 };
 
 // Stages eligible for autopilot handoff (auto_handoff: true in project.context.md).
-// The chain always breaks at the @dev handoff — see .aioson/docs/autopilot-handoff.md.
-const AUTOPILOT_HANDOFF_STAGES = new Set(['analyst', 'scope-check', 'architect', 'discovery-design-doc', 'pm']);
+// Two segments — see .aioson/docs/autopilot-handoff.md:
+//   1. analyst → dev: deterministic pre-dev chain; STOPS before the first @dev entry
+//      (human clears context and starts implementation).
+//   2. post-dev review cycle: @dev → @qa → @tester/@pentester (when their @qa triggers
+//      fire) → @validator → STOPS before feature:close (human approves the close).
+const AUTOPILOT_HANDOFF_STAGES = new Set([
+  'analyst', 'scope-check', 'architect', 'discovery-design-doc', 'pm',
+  'dev', 'qa', 'tester', 'pentester', 'validator'
+]);
 
 function normalizeAgentName(input) {
   return String(input || '')
@@ -1671,6 +1678,7 @@ async function runWorkflowNext({ args, options, logger, t }) {
 }
 
 module.exports = {
+  AUTOPILOT_HANDOFF_STAGES,
   STATE_RELATIVE_PATH,
   CONFIG_RELATIVE_PATH,
   EVENTS_RELATIVE_PATH,

package/src/harness/preview-artifact.js

@@ -0,0 +1,85 @@
+'use strict';
+
+/**
+ * `previewArtifact` — preview + ponteiro para outputs grandes (requirements §3.3,
+ * REQ-10). Tema 2 (should-have) da Harness Retrospective Optimization.
+ *
+ *   previewArtifact(content, { maxBytes = 8192, artifactPath, label, persist })
+ *     → { preview, truncated, fullPath, totalBytes }
+ *
+ * - Persist-first: quando `artifactPath` é dado e `persist !== false`, grava o
+ *   conteúdo INTEGRAL em disco ANTES de gerar o preview.
+ * - `content` ≤ maxBytes → preview = conteúdo integral, `truncated: false`.
+ * - `content` > maxBytes → preview = primeiros maxBytes cortados em boundary
+ *   UTF-8 seguro + linha-ponteiro padrão.
+ * - Falha de escrita NÃO lança: retorna preview truncado + `fullPath: null` +
+ *   aviso (best-effort, mesmo padrão de `attempt-artifacts.js`).
+ * - `persist: false` referencia um arquivo já persistido sem reescrevê-lo
+ *   (modo leitura de `harness:preview`).
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const DEFAULT_MAX_BYTES = 8192;
+
+/** Corta um Buffer UTF-8 em `maxBytes` sem quebrar caractere multi-byte (edge 10). */
+function safeUtf8Slice(buf, maxBytes) {
+  if (buf.length <= maxBytes) return buf.toString('utf8');
+  let end = maxBytes;
+  // Recua enquanto estiver no meio de uma sequência (bytes de continuação 10xxxxxx).
+  while (end > 0 && (buf[end] & 0xc0) === 0x80) end -= 1;
+  return buf.slice(0, end).toString('utf8');
+}
+
+function previewArtifact(content, options = {}) {
+  // Coerção segura: content não-string vira string ('' para null/undefined).
+  let text;
+  if (typeof content === 'string') {
+    text = content;
+  } else if (content === null || content === undefined) {
+    text = '';
+  } else {
+    try {
+      text = String(content);
+    } catch {
+      return { preview: '', truncated: false, fullPath: null, totalBytes: 0, warning: 'content não coercível' };
+    }
+  }
+
+  let maxBytes = Number(options.maxBytes);
+  if (!Number.isInteger(maxBytes) || maxBytes <= 0) maxBytes = DEFAULT_MAX_BYTES;
+
+  const artifactPath = options.artifactPath || null;
+  const persist = options.persist !== false;
+
+  const buf = Buffer.from(text, 'utf8');
+  const totalBytes = buf.length;
+
+  // Persist-first: grava integral antes de qualquer preview.
+  let fullPath = artifactPath;
+  let warning = null;
+  if (artifactPath && persist) {
+    try {
+      fs.mkdirSync(path.dirname(artifactPath), { recursive: true });
+      fs.writeFileSync(artifactPath, text, 'utf8');
+    } catch (err) {
+      fullPath = null;
+      warning = `falha ao persistir ${artifactPath}: ${err.message}`;
+    }
+  }
+
+  if (totalBytes <= maxBytes) {
+    return { preview: text, truncated: false, fullPath, totalBytes, ...(warning ? { warning } : {}) };
+  }
+
+  const cut = safeUtf8Slice(buf, maxBytes);
+  const pointer = fullPath
+    ? `[preview: primeiros ${maxBytes} de ${totalBytes} bytes — completo em ${fullPath}]`
+    : `[preview: primeiros ${maxBytes} de ${totalBytes} bytes — conteúdo completo não persistido]`;
+  const preview = `${cut}\n${pointer}`;
+
+  return { preview, truncated: true, fullPath, totalBytes, ...(warning ? { warning } : {}) };
+}
+
+module.exports = { previewArtifact, DEFAULT_MAX_BYTES, _internal: { safeUtf8Slice } };

package/src/i18n/messages/en.js

@@ -150,6 +150,27 @@ module.exports = {
       'aioson harness:init [path] --slug=<slug> [--mode=BALANCED|URGENT|ECONOMICAL] [--locale=en]',
     help_harness_validate:
       'aioson harness:validate [path] --slug=<slug> [--artifact=<path>] [--locale=en]',
+    help_harness_retro:
+      'aioson harness:retro [path] --feature=<slug> | --last=<N> [--json] [--locale=en]',
+    help_harness_preview:
+      'aioson harness:preview <file> [--max-bytes=8192] [--json] [--locale=en]',
+    harnessRetro: {
+      need_target: 'harness:retro requires --feature=<slug> or --last=<N>.',
+      invalid_slug: 'Invalid slug: {slug} (must match ^[a-z0-9][a-z0-9-]*$).',
+      invalid_last: 'Invalid --last value: {value} (use an integer >= 1).',
+      feature_not_found: 'Feature not found: {slug} (searched .aioson/context/, .aioson/plans/{slug}/, .aioson/context/features/{slug}/, .aioson/context/done/{slug}/).',
+      no_closed_features: 'No closed features under .aioson/context/done/ to mine.',
+      written: 'Retro dossier written: {path} ({candidates} candidates, {observations} observations).',
+      empty: 'Retro dossier written with no proposals: {path} (no minable trail).',
+      io_error: 'I/O error writing the dossier: {error}',
+      window_truncated: '--last={n} exceeds available features ({available}); mining all of them.',
+      undatable_excluded: '{count} feature(s) without a resolvable PASS date excluded from the window: {slugs}'
+    },
+    harnessPreview: {
+      file_required: 'harness:preview requires a <file> path argument.',
+      not_found: 'File not found: {path}',
+      read_error: 'Could not read file: {path} ({error})'
+    },
     help_web_map:
       'aioson web:map [path] --url=<url> [--depth=<N>] [--max-pages=<N>] [--include-external] [--json] [--locale=en]',
     help_web_scrape:

package/src/i18n/messages/es.js

@@ -136,6 +136,27 @@ module.exports = {
       'aioson qa:scan [path] [--url=<app-url>] [--depth=3] [--max-pages=50] [--headed] [--html] [--json] [--locale=es]',
     help_qa_report:
       'aioson qa:report [path] [--html] [--json] [--locale=es]',
+    help_harness_retro:
+      'aioson harness:retro [path] --feature=<slug> | --last=<N> [--json] [--locale=es]',
+    help_harness_preview:
+      'aioson harness:preview <file> [--max-bytes=8192] [--json] [--locale=es]',
+    harnessRetro: {
+      need_target: 'harness:retro requiere --feature=<slug> o --last=<N>.',
+      invalid_slug: 'Slug inválido: {slug} (debe cumplir ^[a-z0-9][a-z0-9-]*$).',
+      invalid_last: 'Valor inválido para --last: {value} (use un entero >= 1).',
+      feature_not_found: 'Feature no encontrada: {slug} (buscado en .aioson/context/, .aioson/plans/{slug}/, .aioson/context/features/{slug}/, .aioson/context/done/{slug}/).',
+      no_closed_features: 'No hay features cerradas en .aioson/context/done/ para minar.',
+      written: 'Dosier retrospectivo generado: {path} ({candidates} candidatos, {observations} observaciones).',
+      empty: 'Dosier generado sin propuestas: {path} (fuentes sin rastro minable).',
+      io_error: 'Error de E/S al escribir el dosier: {error}',
+      window_truncated: '--last={n} supera las features disponibles ({available}); minando todas.',
+      undatable_excluded: '{count} feature(s) sin fecha de PASS resoluble excluida(s) de la ventana: {slugs}'
+    },
+    harnessPreview: {
+      file_required: 'harness:preview requiere una ruta de archivo <file>.',
+      not_found: 'Archivo no encontrado: {path}',
+      read_error: 'No se pudo leer el archivo: {path} ({error})'
+    },
     help_web_map:
       'aioson web:map [path] --url=<url> [--depth=<N>] [--max-pages=<N>] [--include-external] [--json] [--locale=es]',
     help_web_scrape:

package/src/i18n/messages/fr.js

@@ -136,6 +136,27 @@ module.exports = {
       'aioson qa:scan [path] [--url=<app-url>] [--depth=3] [--max-pages=50] [--headed] [--html] [--json] [--locale=fr]',
     help_qa_report:
       'aioson qa:report [path] [--html] [--json] [--locale=fr]',
+    help_harness_retro:
+      'aioson harness:retro [path] --feature=<slug> | --last=<N> [--json] [--locale=fr]',
+    help_harness_preview:
+      'aioson harness:preview <file> [--max-bytes=8192] [--json] [--locale=fr]',
+    harnessRetro: {
+      need_target: 'harness:retro requiert --feature=<slug> ou --last=<N>.',
+      invalid_slug: 'Slug invalide : {slug} (doit correspondre à ^[a-z0-9][a-z0-9-]*$).',
+      invalid_last: 'Valeur --last invalide : {value} (utilisez un entier >= 1).',
+      feature_not_found: 'Feature introuvable : {slug} (cherché dans .aioson/context/, .aioson/plans/{slug}/, .aioson/context/features/{slug}/, .aioson/context/done/{slug}/).',
+      no_closed_features: 'Aucune feature clôturée dans .aioson/context/done/ à miner.',
+      written: 'Dossier rétrospectif généré : {path} ({candidates} candidats, {observations} observations).',
+      empty: 'Dossier généré sans propositions : {path} (sources sans piste exploitable).',
+      io_error: 'Erreur d’E/S lors de l’écriture du dossier : {error}',
+      window_truncated: '--last={n} dépasse les features disponibles ({available}) ; minage de toutes.',
+      undatable_excluded: '{count} feature(s) sans date de PASS résoluble exclue(s) de la fenêtre : {slugs}'
+    },
+    harnessPreview: {
+      file_required: 'harness:preview requiert un chemin de fichier <file>.',
+      not_found: 'Fichier introuvable : {path}',
+      read_error: 'Impossible de lire le fichier : {path} ({error})'
+    },
     help_web_map:
       'aioson web:map [path] --url=<url> [--depth=<N>] [--max-pages=<N>] [--include-external] [--json] [--locale=fr]',
     help_web_scrape:

package/src/i18n/messages/pt-BR.js

@@ -152,6 +152,27 @@ module.exports = {
       'aioson harness:init [path] --slug=<slug> [--mode=BALANCED|URGENT|ECONOMICAL] [--locale=pt-BR]',
     help_harness_validate:
       'aioson harness:validate [path] --slug=<slug> [--artifact=<path>] [--locale=pt-BR]',
+    help_harness_retro:
+      'aioson harness:retro [path] --feature=<slug> | --last=<N> [--json] [--locale=pt-BR]',
+    help_harness_preview:
+      'aioson harness:preview <file> [--max-bytes=8192] [--json] [--locale=pt-BR]',
+    harnessRetro: {
+      need_target: 'harness:retro requer --feature=<slug> ou --last=<N>.',
+      invalid_slug: 'Slug inválido: {slug} (deve casar ^[a-z0-9][a-z0-9-]*$).',
+      invalid_last: 'Valor inválido para --last: {value} (use inteiro >= 1).',
+      feature_not_found: 'Feature não encontrada: {slug} (procurado em .aioson/context/, .aioson/plans/{slug}/, .aioson/context/features/{slug}/, .aioson/context/done/{slug}/).',
+      no_closed_features: 'Nenhuma feature fechada em .aioson/context/done/ para minerar.',
+      written: 'Dossiê retrospectivo gerado: {path} ({candidates} candidatos, {observations} observações).',
+      empty: 'Dossiê gerado sem propostas: {path} (fontes sem trilha minerável).',
+      io_error: 'Erro de I/O ao escrever o dossiê: {error}',
+      window_truncated: '--last={n} excede features disponíveis ({available}); minerando todas.',
+      undatable_excluded: '{count} feature(s) sem data de PASS determinável excluída(s) da janela: {slugs}'
+    },
+    harnessPreview: {
+      file_required: 'harness:preview requer um caminho de arquivo <file>.',
+      not_found: 'Arquivo não encontrado: {path}',
+      read_error: 'Não foi possível ler o arquivo: {path} ({error})'
+    },
     help_web_map:
       'aioson web:map [path] --url=<url> [--depth=<N>] [--max-pages=<N>] [--include-external] [--json] [--locale=pt-BR]',
     help_web_scrape: