@orchestrator-claude/definitions 3.37.1 → 3.37.2

package/hooks/security-gate-honest.mjs

@@ -0,0 +1,302 @@
+import { createRequire as __createRequireShim } from 'node:module'; const require = __createRequireShim(import.meta.url);
+
+// hooks/lib/api-client.ts
+import { readFileSync, writeFileSync, mkdirSync, statSync, unlinkSync, readdirSync } from "node:fs";
+import { join as join2 } from "node:path";
+import { tmpdir } from "node:os";
+import { createHash } from "node:crypto";
+
+// ../project-root-resolver/dist/index.js
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+function hasProjectRootMarker(candidate, sentinel) {
+  return existsSync(join(candidate, ".git")) || existsSync(join(candidate, "package.json")) || existsSync(join(candidate, sentinel, ".root"));
+}
+function resolveProjectRoot(cwd, sentinel = ".orchestrator") {
+  const candidates = [];
+  let currentDir = cwd;
+  for (; ; ) {
+    if (existsSync(join(currentDir, sentinel))) {
+      candidates.push(currentDir);
+    }
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+  const [innermost] = candidates;
+  if (innermost === void 0) {
+    return null;
+  }
+  for (const candidate of candidates) {
+    if (hasProjectRootMarker(candidate, sentinel)) {
+      return candidate;
+    }
+  }
+  return innermost;
+}
+
+// hooks/lib/api-client.ts
+function resolveFallbackStateDir(cwd) {
+  const cwdHash = createHash("sha256").update(cwd).digest("hex").slice(0, 16);
+  return join2(tmpdir(), "orchestrator-hook-fallback", cwdHash);
+}
+var PROJECT_ROOT = (() => {
+  const resolved = resolveHookProjectRoot(process.cwd());
+  if (resolved !== null && hasProjectRootMarker(resolved, ".orchestrator")) {
+    return resolved;
+  }
+  return null;
+})();
+var STATE_DIR_OVERRIDE = process.env.ORCHESTRATOR_STATE_DIR;
+var STATE_DIR = STATE_DIR_OVERRIDE !== void 0 && STATE_DIR_OVERRIDE !== "" ? STATE_DIR_OVERRIDE : PROJECT_ROOT !== null ? join2(PROJECT_ROOT, ".orchestrator", ".state") : resolveFallbackStateDir(process.cwd());
+var JWT_CACHE = join2(STATE_DIR, "jwt-token");
+var DEBUG_LOG = join2(STATE_DIR, "hook-debug.log");
+mkdirSync(STATE_DIR, { recursive: true });
+if ((STATE_DIR_OVERRIDE === void 0 || STATE_DIR_OVERRIDE === "") && PROJECT_ROOT === null) {
+  log(
+    "API-CLIENT",
+    `PROJECT_ROOT: no marker-verified ".orchestrator" project root found above ${process.cwd()} \u2014 falling back to isolated state dir ${STATE_DIR} (RF-003)`
+  );
+}
+var API_URL = process.env.ORCHESTRATOR_API_URL || "http://localhost:3001";
+var AUTH_EMAIL = process.env.ORCHESTRATOR_ADMIN_EMAIL || process.env.ORCHESTRATOR_AUTH_EMAIL || "system@orchestrator.local";
+var AUTH_PASSWORD = process.env.ORCHESTRATOR_ADMIN_PASSWORD || process.env.ORCHESTRATOR_AUTH_PASSWORD || "system123";
+var PROJECT_ID = process.env.ORCHESTRATOR_PROJECT_ID || "";
+function resolveHookProjectRoot(cwd) {
+  return resolveProjectRoot(cwd);
+}
+function log(prefix, msg) {
+  const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d+Z$/, "Z");
+  try {
+    const line = `[${ts}] ${prefix}: ${msg}
+`;
+    writeFileSync(DEBUG_LOG, line, { flag: "a" });
+  } catch {
+  }
+}
+var LAST_COMPLETED_FILE = join2(STATE_DIR, "last-completed-workflow.json");
+var LAST_COMPLETED_TTL_MS = 60 * 60 * 1e3;
+var INVOCATIONS_DIR = join2(STATE_DIR, "invocations");
+var INVOCATION_STATE_TTL_MS = 4 * 60 * 60 * 1e3;
+var DISPATCH_INTENT_DIR = join2(STATE_DIR, "dispatch-intent");
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  const raw = Buffer.concat(chunks).toString("utf-8").trim();
+  if (!raw) return {};
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function getField(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current == null || typeof current !== "object") return "";
+    current = current[part];
+  }
+  return current != null ? String(current) : "";
+}
+
+// hooks/security-gate-honest.ts
+import { execFileSync } from "node:child_process";
+
+// hooks/lib/security-gate-core.ts
+var L2_LATENCY_FLOOR_MS = 400;
+var L1_COVERAGE = "literais de credencial no diff (chaves de provedor, tokens, blocos PEM, URLs com senha)";
+var SECRET_RULES = [
+  { rule: "aws-access-key-id", re: /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/ },
+  { rule: "anthropic-api-key", re: /\bsk-ant-[A-Za-z0-9_-]{20,}/ },
+  { rule: "openai-api-key", re: /\bsk-(?:proj-)?[A-Za-z0-9]{32,}\b/ },
+  { rule: "github-token", re: /\bgh[pousr]_[A-Za-z0-9]{36,}\b/ },
+  { rule: "slack-token", re: /\bxox[abprs]-[A-Za-z0-9-]{10,}/ },
+  { rule: "google-api-key", re: /\bAIza[0-9A-Za-z_-]{35}\b/ },
+  { rule: "npm-token", re: /\bnpm_[A-Za-z0-9]{36}\b/ },
+  { rule: "private-key-block", re: /-----BEGIN (?:RSA |EC |OPENSSH |PGP )?PRIVATE KEY-----/ },
+  { rule: "jwt", re: /\beyJ[A-Za-z0-9_-]{10,}\.eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/ },
+  { rule: "url-with-password", re: /\b[a-z][a-z0-9+.-]*:\/\/[^\s:@/]+:[^\s:@/]{6,}@/i }
+];
+var PLACEHOLDER = /(?:x{6,}|\.{3,}|<[^>]{2,}>|\$\{|EXAMPLE|PLACEHOLDER|YOUR_|CHANGEME|REDACTED|FAKE|DUMMY|\bTODO\b)/i;
+function maskEvidence(s) {
+  const t = s.trim().slice(0, 80);
+  return t.length <= 12 ? "***" : `${t.slice(0, 6)}\u2026${t.slice(-4)} (${String(t.length)} ch)`;
+}
+function scanDiff(diff) {
+  const out = [];
+  let file = "(desconhecido)";
+  let lineNo = 0;
+  for (const raw of diff.split("\n")) {
+    if (raw.startsWith("+++ b/")) {
+      file = raw.slice(6);
+      lineNo = 0;
+      continue;
+    }
+    if (raw.startsWith("@@")) {
+      const m = /\+(\d+)/.exec(raw);
+      lineNo = m ? parseInt(m[1], 10) - 1 : 0;
+      continue;
+    }
+    if (!raw.startsWith("+") || raw.startsWith("+++")) continue;
+    lineNo += 1;
+    const content = raw.slice(1);
+    if (PLACEHOLDER.test(content)) continue;
+    for (const { rule, re } of SECRET_RULES) {
+      const hit = re.exec(content);
+      if (hit) out.push({ rule, file, line: lineNo, evidence: maskEvidence(hit[0]) });
+    }
+  }
+  return out;
+}
+function isCommitCommand(command) {
+  return /git\s+(?:-\S+(?:\s+\S+)?\s+)*commit\b/.test(command) && !/--dry-run\b/.test(command);
+}
+function evaluate(deps) {
+  const verdicts = [];
+  let src;
+  try {
+    src = deps.getDiff();
+  } catch (e) {
+    const reason = `n\xE3o consegui ler o diff do commit (${e.message.slice(0, 80)})`;
+    return [
+      { state: "not-analyzed", layer: "L1", reason },
+      { state: "not-analyzed", layer: "L2", reason }
+    ];
+  }
+  const diff = src.text;
+  if (!diff.trim()) {
+    const reason = `o diff veio vazio via ${src.how} \u2014 nada para analisar. Isto N\xC3O \xE9 o mesmo que limpo`;
+    return [
+      { state: "not-analyzed", layer: "L1", reason },
+      { state: "not-analyzed", layer: "L2", reason }
+    ];
+  }
+  const hits = scanDiff(diff);
+  const cover = `${L1_COVERAGE} \xB7 via ${src.how}`;
+  verdicts.push(
+    hits.length ? { state: "findings", layer: "L1", detail: cover, hits } : { state: "clean", layer: "L1", detail: cover }
+  );
+  const sem = deps.runSemantic(diff);
+  if (sem === null) {
+    verdicts.push({ state: "not-analyzed", layer: "L2", reason: deps.l2UnavailableReason() });
+  } else if (sem.elapsedMs < L2_LATENCY_FLOOR_MS) {
+    verdicts.push({
+      state: "not-analyzed",
+      layer: "L2",
+      reason: `devolveu veredito em ${String(sem.elapsedMs)} ms, abaixo do piso de ${String(L2_LATENCY_FLOOR_MS)} ms \u2014 tratado como fallback, n\xE3o como an\xE1lise`
+    });
+  } else {
+    verdicts.push(
+      sem.hits.length ? { state: "findings", layer: "L2", detail: "an\xE1lise sem\xE2ntica", hits: sem.hits } : { state: "clean", layer: "L2", detail: "an\xE1lise sem\xE2ntica" }
+    );
+  }
+  return verdicts;
+}
+function renderShort(verdicts) {
+  const findings = verdicts.filter((v) => v.state === "findings");
+  if (findings.length) {
+    const n = findings.reduce((a, v) => a + (v.state === "findings" ? v.hits.length : 0), 0);
+    const layers = findings.map((v) => v.layer).join("+");
+    return `SECURITY-GATE: ${String(n)} achado(s) em ${layers} \u2014 confira antes de publicar`;
+  }
+  const analyzed = verdicts.filter((v) => v.state !== "not-analyzed").map((v) => v.layer);
+  const skipped = verdicts.filter((v) => v.state === "not-analyzed").map((v) => v.layer);
+  if (!analyzed.length) {
+    return 'SECURITY-GATE: NENHUMA camada analisou o commit \u2014 isto N\xC3O \xE9 "limpo", \xE9 aus\xEAncia de an\xE1lise';
+  }
+  if (skipped.length) {
+    return `SECURITY-GATE: cobertura PARCIAL \u2014 ${analyzed.join("+")} analisou, ${skipped.join("+")} n\xE3o`;
+  }
+  return `SECURITY-GATE: ${analyzed.join("+")} analisou, sem achados`;
+}
+function render(verdicts) {
+  const lines = ["[SECURITY-GATE] Revis\xE3o do commit \u2014 veredito por camada:"];
+  for (const v of verdicts) {
+    if (v.state === "clean") {
+      lines.push(`  ${v.layer} ANALISADO \u2014 LIMPO \xB7 cobertura: ${v.detail}`);
+    } else if (v.state === "findings") {
+      lines.push(
+        `  ${v.layer} ANALISADO \u2014 ${String(v.hits.length)} ACHADO(S) \xB7 cobertura: ${v.detail}`
+      );
+      for (const h of v.hits.slice(0, 10)) {
+        lines.push(`      ${h.rule} \xB7 ${h.file}:${String(h.line)} \xB7 ${h.evidence}`);
+      }
+      if (v.hits.length > 10) lines.push(`      \u2026 e mais ${String(v.hits.length - 10)}`);
+    } else {
+      lines.push(`  ${v.layer} N\xC3O ANALISEI \u2014 ${v.reason}`);
+    }
+  }
+  const analyzed = verdicts.filter((v) => v.state !== "not-analyzed").map((v) => v.layer);
+  const skipped = verdicts.filter((v) => v.state === "not-analyzed").map((v) => v.layer);
+  if (!analyzed.length) {
+    lines.push(
+      '  \u26A0 NENHUMA camada analisou este commit. Isto N\xC3O \xE9 "limpo" \u2014 \xE9 aus\xEAncia de informa\xE7\xE3o.'
+    );
+  } else if (skipped.length) {
+    lines.push(
+      `  \u26A0 Cobertura PARCIAL: ${analyzed.join("+")} rodou, ${skipped.join("+")} n\xE3o. O que n\xE3o foi analisado n\xE3o est\xE1 limpo \u2014 est\xE1 por analisar.`
+    );
+  }
+  if (verdicts.some((v) => v.state === "findings")) {
+    lines.push("  \u2192 Confira antes de publicar. O commit local j\xE1 existe; nada foi bloqueado.");
+  }
+  return lines.join("\n");
+}
+
+// hooks/security-gate-honest.ts
+var HOOK = "SECURITY-GATE";
+var defaultDeps = {
+  getDiff: () => {
+    const git = (args2) => execFileSync("git", args2, { encoding: "utf8", maxBuffer: 8 * 1024 * 1024, timeout: 1e4 });
+    const parents = git(["rev-list", "--parents", "-n", "1", "HEAD"]).trim().split(/\s+/).length - 1;
+    const args = parents > 1 ? ["show", "--format=", "--unified=0", "-m", "--first-parent", "HEAD"] : ["show", "--format=", "--unified=0", "HEAD"];
+    const how = parents > 1 ? `git show -m --first-parent HEAD (merge de ${parents} pais)` : "git show HEAD";
+    return { text: git(args), how };
+  },
+  // Ficha 3 item (d): o gate é honesto ANTES de voltar a funcionar. Enquanto a
+  // credencial/SDK não forem decididos pelo PM, L2 declara ausência — nunca
+  // finge limpeza.
+  runSemantic: () => null,
+  l2UnavailableReason: () => "camada sem\xE2ntica sem credencial decidida (ficha 3 da S505, item d) \u2014 nenhuma chamada foi tentada, nada foi analisado nesta camada"
+};
+async function mainWithDeps(deps, stdinFn = readStdin) {
+  const stdin = await stdinFn();
+  const command = getField(stdin, "tool_input.command") || getField(stdin, "command") || "";
+  if (!isCommitCommand(command)) return;
+  const verdicts = evaluate(deps);
+  const text = render(verdicts);
+  log(HOOK, text.replace(/\n/g, " | "));
+  console.log(
+    JSON.stringify({
+      systemMessage: renderShort(verdicts),
+      hookSpecificOutput: { hookEventName: "PostToolUse", additionalContext: text }
+    })
+  );
+}
+async function main() {
+  await mainWithDeps(defaultDeps);
+}
+main().catch((e) => {
+  try {
+    log(HOOK, `N\xC3O ANALISEI \u2014 o pr\xF3prio gate falhou: ${e.message.slice(0, 120)}`);
+  } catch {
+  }
+  process.exit(0);
+});
+export {
+  L1_COVERAGE,
+  L2_LATENCY_FLOOR_MS,
+  SECRET_RULES,
+  evaluate,
+  isCommitCommand,
+  mainWithDeps,
+  maskEvidence,
+  render,
+  renderShort,
+  scanDiff
+};

package/hooks/security-gate-honest.ts

@@ -0,0 +1,148 @@
+/**
+ * security-gate-honest.ts — PostToolUse[Bash] hook
+ *
+ * Substituto honesto do `security-guidance@claude-plugins-official` para a
+ * revisão de commits (ficha 3 da S505; decisão do PM: trocar por algo que
+ * FALHE ALTO).
+ *
+ * ─── O DEFEITO QUE ESTE HOOK EXISTE PARA NÃO COMETER ──────────────────────
+ * Medido na S505, `security_reminder_hook.py:1418`: quando a chamada de API
+ * falha, o Commit review emite `no security issues found` e sai com 0 — três
+ * MILISSEGUNDOS depois do erro. A informação de que nada foi analisado está
+ * disponível ali (`llm._last_call_claude_http_error`) e é enviada para a
+ * telemetria como `api_error`, mas NÃO muda o veredito mostrado.
+ *
+ * O mesmo arquivo faz a coisa certa 667 linhas abaixo: o Stop hook (:2085)
+ * testa `_last_call_claude_http_error` ANTES do veredito e, quando há erro,
+ * chama `restore_unreviewed_stop_state` em vez de declarar limpo. Duas
+ * rotinas, a mesma variável, duas condutas — e só uma é honesta.
+ *
+ * ─── A REGRA, E É A ÚNICA QUE IMPORTA ─────────────────────────────────────
+ * AUSÊNCIA DE ANÁLISE NUNCA VIRA VEREDITO POSITIVO. Um gate que degrada para
+ * "limpo" é pior que gate nenhum: gate nenhum é uma ausência que se percebe;
+ * "no security issues found" é uma afirmação que se cita depois.
+ *
+ * Três estados, sempre explícitos, nunca implícitos:
+ *   ANALISADO — LIMPO ......... a camada rodou e não achou nada
+ *   ANALISADO — ACHADOS ....... a camada rodou e achou
+ *   NÃO ANALISEI — <motivo> ... a camada não rodou, e o motivo vai junto
+ *
+ * E a cobertura é declarada em toda saída: dizer "limpo" sem dizer "limpo
+ * DE QUÊ" é a mesma família de defeito, um degrau mais sutil.
+ *
+ * ─── CAMADAS ──────────────────────────────────────────────────────────────
+ *   L1 · varredura local de segredos (regex sobre o diff) — SEM API, sempre
+ *        disponível, cobertura estreita e declarada.
+ *   L2 · análise semântica por LLM — hoje NÃO DISPONÍVEL (sem credencial,
+ *        ver §credencial na ficha). O gancho e o piso de latência ficam
+ *        escritos para quando a credencial for decidida; enquanto isso L2
+ *        reporta NÃO ANALISEI, que é o comportamento correto.
+ *
+ * ─── PISO DE LATÊNCIA (segunda guarda, achado da S505) ────────────────────
+ * Análise semântica de um diff não fecha em milissegundos. Quando L2 existir
+ * e devolver veredito em menos de L2_LATENCY_FLOOR_MS, o resultado é tratado
+ * como fallback, não como análise — vira NÃO ANALISEI. É guarda secundária:
+ * a primária é testar o erro explicitamente, como o Stop hook do plugin faz.
+ *
+ * NUNCA BLOQUEIA. Emite contexto. O objetivo é informar com honestidade, não
+ * impedir o commit — bloquear seria decisão de outra ficha.
+ */
+
+import { log, readStdin, getField } from './lib/api-client.js';
+import { execFileSync } from 'node:child_process';
+import {
+  evaluate,
+  render,
+  renderShort,
+  isCommitCommand,
+  type GateDeps,
+} from './lib/security-gate-core.js';
+
+export {
+  L1_COVERAGE,
+  L2_LATENCY_FLOOR_MS,
+  SECRET_RULES,
+  maskEvidence,
+  scanDiff,
+  isCommitCommand,
+  evaluate,
+  render,
+  renderShort,
+  type Finding,
+  type Verdict,
+  type GateDeps,
+} from './lib/security-gate-core.js';
+
+const HOOK = 'SECURITY-GATE';
+
+// ─────────────────────────────────────────────────────────────
+// Produção
+// ─────────────────────────────────────────────────────────────
+
+const defaultDeps: GateDeps = {
+  getDiff: () => {
+    const git = (args: string[]) =>
+      execFileSync('git', args, { encoding: 'utf8', maxBuffer: 8 * 1024 * 1024, timeout: 10_000 });
+    // Um merge commit devolve diff VAZIO em `git show` sem `-m` (medido S505: o
+    // HEAD de merge dava 0 linhas e um commit normal, 159). Sem esta distinção o
+    // gate diria "não analisei" para todo merge, misturando-o com falha real.
+    const parents =
+      git(['rev-list', '--parents', '-n', '1', 'HEAD']).trim().split(/\s+/).length - 1;
+    const args =
+      parents > 1
+        ? ['show', '--format=', '--unified=0', '-m', '--first-parent', 'HEAD']
+        : ['show', '--format=', '--unified=0', 'HEAD'];
+    const how =
+      parents > 1 ? `git show -m --first-parent HEAD (merge de ${parents} pais)` : 'git show HEAD';
+    return { text: git(args), how };
+  },
+  // Ficha 3 item (d): o gate é honesto ANTES de voltar a funcionar. Enquanto a
+  // credencial/SDK não forem decididos pelo PM, L2 declara ausência — nunca
+  // finge limpeza.
+  runSemantic: () => null,
+  l2UnavailableReason: () =>
+    'camada semântica sem credencial decidida (ficha 3 da S505, item d) — ' +
+    'nenhuma chamada foi tentada, nada foi analisado nesta camada',
+};
+
+export async function mainWithDeps(deps: GateDeps, stdinFn = readStdin): Promise<void> {
+  const stdin = await stdinFn();
+  const command =
+    (getField(stdin, 'tool_input.command') as string | undefined) ||
+    (getField(stdin, 'command') as string | undefined) ||
+    '';
+
+  if (!isCommitCommand(command)) return;
+
+  const verdicts = evaluate(deps);
+  const text = render(verdicts);
+  log(HOOK, text.replace(/\n/g, ' | '));
+
+  // DOIS canais, e a distinção é a ficha inteira (achado do Manager, S505):
+  //   additionalContext → só o MODELO lê;
+  //   systemMessage     → a PESSOA vê, sem bloquear.
+  // Um gate que "falha alto" apenas para o modelo não falha alto para ninguém —
+  // é o mesmo efeito prático do plugin que este substitui. `outputContext` da
+  // casa não emite systemMessage, então o JSON sai montado aqui.
+  console.log(
+    JSON.stringify({
+      systemMessage: renderShort(verdicts),
+      hookSpecificOutput: { hookEventName: 'PostToolUse', additionalContext: text },
+    })
+  );
+}
+
+async function main(): Promise<void> {
+  await mainWithDeps(defaultDeps);
+}
+
+// Falha do próprio gate também não pode virar silêncio-que-parece-limpo:
+// o motivo vai para o log, e a saída 0 apenas não bloqueia o fluxo.
+main().catch((e: unknown) => {
+  try {
+    log(HOOK, `NÃO ANALISEI — o próprio gate falhou: ${(e as Error).message.slice(0, 120)}`);
+  } catch {
+    /* nada a fazer; nunca derrubar a sessão por causa do gate */
+  }
+  process.exit(0);
+});

package/hooks/session-start.mjs

@@ -7862,6 +7862,10 @@ var MEMORY_TYPES = ["feedback", "project", "reference", "user"];
 function truncateSummary(summary, cap) {
   return summary.length > cap ? `${summary.slice(0, cap)}\u2026` : summary;
 }
+function hasRenderableSummary(entry) {
+  return typeof entry.summary === "string";
+}
+var MEMORY_SKIPPED_WARNING_PREFIX = "- [AVISO] ";
 function countByType(list) {
   const counts = {};
   for (const e of list) {
@@ -7870,31 +7874,35 @@ function countByType(list) {
   return counts;
 }
 function formatMemoryContext(selected, allEntries) {
-  if (selected.length === 0) return "";
-  const selectedCounts = countByType(selected);
+  const renderable = selected.filter(hasRenderableSummary);
+  const skipped = selected.filter((e) => !hasRenderableSummary(e));
+  const warning = skipped.length > 0 ? `${MEMORY_SKIPPED_WARNING_PREFIX}${String(skipped.length)} entrada(s) sem 'summary:' pulada(s) \u2014 conserte o \xEDndice: ${skipped.map((e) => e.file).join(", ")}` : "";
+  if (renderable.length === 0) return warning ? `[MEMORY-CONTEXT] 0 mem\xF3rias
+${warning}` : "";
+  const selectedCounts = countByType(renderable);
   const totalCounts = countByType(allEntries);
   const perTypeSummary = MEMORY_TYPES.map(
     (t) => `${t}: ${selectedCounts[t] ?? 0}/${totalCounts[t] ?? 0}`
   ).join(", ");
-  const headerBase = `[MEMORY-CONTEXT] ${selected.length} de ${allEntries.length} mem\xF3rias (${perTypeSummary}); crit\xE9rio: cota m\xEDnima de 2 por tipo n\xE3o-feedback + prioridade feedback\u2192rec\xEAncia no restante`;
-  const availableForLines = AGGREGATE_CHAR_BUDGET - headerBase.length - SUFFIX_RESERVE;
+  const headerBase = `[MEMORY-CONTEXT] ${renderable.length} de ${allEntries.length} mem\xF3rias (${perTypeSummary}); crit\xE9rio: cota m\xEDnima de 2 por tipo n\xE3o-feedback + prioridade feedback\u2192rec\xEAncia no restante`;
+  const availableForLines = AGGREGATE_CHAR_BUDGET - headerBase.length - SUFFIX_RESERVE - (warning ? warning.length + 1 : 0);
   const lines = [];
   let used = 0;
   let droppedByBudget = 0;
-  for (let i = 0; i < selected.length; i++) {
-    const entry = selected[i];
+  for (let i = 0; i < renderable.length; i++) {
+    const entry = renderable[i];
     const name = entry.file.replace(/\.md$/, "");
     const truncated = truncateSummary(entry.summary, PER_ENTRY_SUMMARY_CHAR_CAP);
     const line = `- [${entry.type}] ${name}: ${truncated}`;
     if (used + line.length + 1 > availableForLines) {
-      droppedByBudget = selected.length - i;
+      droppedByBudget = renderable.length - i;
       break;
     }
     lines.push(line);
     used += line.length + 1;
   }
   const header = droppedByBudget > 0 ? `${headerBase}; +${droppedByBudget} truncadas por or\xE7amento de caracteres` : headerBase;
-  return [header, ...lines].join("\n");
+  return [header, ...lines, warning].filter(Boolean).join("\n");
 }
 function isWellFormedMemoryEntry(value) {
   return typeof value === "object" && value !== null && typeof value.file === "string";
@@ -8226,32 +8234,46 @@ function buildMemoryLine(memoryIndexPath) {
   const filtered = filterRelevantMemories(memoryEntries);
   return formatMemoryContext(filtered, memoryEntries);
 }
-function buildCapabilityMatrixContext() {
+function resolveVaultPaths(caller) {
   if (VAULT_CONFIG_PATH === null || AGENTS_DIR === null || PROFILES_PATH === null || MEMORY_INDEX_PATH === null || CAPABILITY_CACHE_PATH === null) {
-    log(
-      HOOK,
-      "buildCapabilityMatrixContext: PROJECT_ROOT unresolved (unregistered cwd) \u2014 skipping"
-    );
-    return "";
+    log(HOOK, `${caller}: PROJECT_ROOT unresolved (unregistered cwd) \u2014 skipping`);
+    return null;
   }
-  let matrixLine = "";
+  return {
+    vaultConfigPath: VAULT_CONFIG_PATH,
+    agentsDir: AGENTS_DIR,
+    profilesPath: PROFILES_PATH,
+    memoryIndexPath: MEMORY_INDEX_PATH,
+    capabilityCachePath: CAPABILITY_CACHE_PATH
+  };
+}
+function buildMatrixContext() {
+  const paths = resolveVaultPaths("buildMatrixContext");
+  if (!paths) return "";
   try {
-    matrixLine = buildMatrixLine(
-      VAULT_CONFIG_PATH,
-      AGENTS_DIR,
-      PROFILES_PATH,
-      CAPABILITY_CACHE_PATH
+    return buildMatrixLine(
+      paths.vaultConfigPath,
+      paths.agentsDir,
+      paths.profilesPath,
+      paths.capabilityCachePath
     );
   } catch (err) {
     log(HOOK, `Capability matrix failed: ${err}`);
+    return "";
   }
-  let memoryLine = "";
+}
+function buildMemoryContext() {
+  const paths = resolveVaultPaths("buildMemoryContext");
+  if (!paths) return "";
   try {
-    memoryLine = buildMemoryLine(MEMORY_INDEX_PATH);
+    return buildMemoryLine(paths.memoryIndexPath);
   } catch (err) {
     log(HOOK, `Memory context failed: ${err}`);
+    return "";
   }
-  return [matrixLine, memoryLine].filter(Boolean).join("\n");
+}
+function buildCapabilityMatrixContext() {
+  return [buildMatrixContext(), buildMemoryContext()].filter(Boolean).join("\n");
 }
 function checkSprintInbox() {
   const sprintId = process.env.SPRINT_ID;
@@ -8307,7 +8329,8 @@ async function main() {
   const backlog = getBacklogSummary();
   const tierInfo = await checkTier();
   const tierSegment = formatTierSegment(tierInfo);
-  const capabilityContext = buildCapabilityMatrixContext();
+  const memoryContext = buildMemoryContext();
+  const matrixContext = buildMatrixContext();
   const sprintInboxContext = checkSprintInbox();
   await getToken();
   const selection = PROJECT_SELECTION_ENABLED && sessionId ? readSessionSelection(SESSION_SELECTION_STATE_DIR, sessionId) : void 0;
@@ -8329,6 +8352,7 @@ async function main() {
       "SessionStart",
       [
         `${isRecovery ? "[ORCHESTRATOR-RECOVERY]" : "[ORCHESTRATOR-DATA]"} ${stateLine2}`,
+        memoryContext,
         ...isRecovery ? RECOVERY_DIRECTIVE : [
           backlog.lastSession ? `[LAST-SESSION] ${backlog.lastSession}` : "",
           backlog.status ? `[PENDENTE] ${backlog.status}` : "",
@@ -8336,7 +8360,7 @@ async function main() {
           "Do NOT invoke /orchestrator skill for the greeting \u2014 use AskUserQuestion directly.",
           "Invoke /orchestrator skill only when the user chooses to start a workflow."
         ],
-        capabilityContext,
+        matrixContext,
         sprintInboxContext,
         projectSelectionPrompt
       ].filter(Boolean).join("\n")
@@ -8354,12 +8378,13 @@ async function main() {
     "SessionStart",
     [
       `${isRecovery ? "[ORCHESTRATOR-RECOVERY]" : "[ORCHESTRATOR-DATA]"} ${stateLine}`,
+      memoryContext,
       ...isRecovery ? RECOVERY_DIRECTIVE : [
         `[ORCHESTRATOR] Active workflow detected. Greet the user via AskUserQuestion showing workflow state (orchestrator identity, MUST rule #1).`,
         "Do NOT invoke /orchestrator skill for the greeting \u2014 use AskUserQuestion directly.",
         "Invoke /orchestrator skill when the user chooses to continue the workflow."
       ],
-      capabilityContext,
+      matrixContext,
       projectSelectionPrompt
     ].filter(Boolean).join("\n")
   );
@@ -8367,6 +8392,8 @@ async function main() {
 main().catch(() => process.exit(0));
 export {
   buildCapabilityMatrixContext,
+  buildMatrixContext,
+  buildMemoryContext,
   buildProjectSelectionPrompt,
   formatProjectBindingSegment,
   formatSessionNumberSegment,