@orchestrator-claude/definitions 3.37.0 → 3.37.2

package/hooks/session-start.mjs

@@ -7324,38 +7324,68 @@ var require_dist = __commonJS({
 var import_yaml2 = __toESM(require_dist(), 1);
 import { readFileSync as readFileSync4, readdirSync as readdirSync3, existsSync as existsSync4 } from "node:fs";
 import { join as join5, dirname as dirname3 } from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { fileURLToPath } from "node:url";
 
 // hooks/lib/api-client.ts
 import { readFileSync, writeFileSync, mkdirSync, statSync, unlinkSync, readdirSync } from "node:fs";
-import { join as join2, dirname as dirname2 } from "node:path";
-import { fileURLToPath } from "node:url";
+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))) {
-      return currentDir;
+      candidates.push(currentDir);
     }
     const parentDir = dirname(currentDir);
     if (parentDir === currentDir) {
-      return null;
+      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
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname2(__filename);
-var PROJECT_ROOT = join2(__dirname, "..", "..", "..");
-var STATE_DIR = join2(PROJECT_ROOT, ".orchestrator", ".state");
+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";
@@ -7533,6 +7563,19 @@ async function allocateSessionNumber(projectId) {
     projectId
   });
 }
+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 outputContext(hookEvent, context) {
   console.log(
     JSON.stringify({
@@ -7546,8 +7589,8 @@ function outputContext(hookEvent, context) {
 
 // hooks/lib/capability-scanner.ts
 var import_yaml = __toESM(require_dist(), 1);
-import { readFileSync as readFileSync2, readdirSync as readdirSync2, existsSync as existsSync2, statSync as statSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { join as join3 } from "node:path";
+import { readFileSync as readFileSync2, readdirSync as readdirSync2, existsSync as existsSync2, statSync as statSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "node:fs";
+import { join as join3, dirname as dirname2 } from "node:path";
 function pluginNameFromKey(key) {
   return key.split("@")[0] ?? "";
 }
@@ -7728,13 +7771,14 @@ function buildCapabilityIndex(opts) {
     gaps
   };
 }
-function writeCapabilitiesToVault(vaultConfigPath, index) {
+var CAPABILITY_CACHE_FILENAME = "capability-cache.yaml";
+function resolveCapabilityCachePath(projectRoot, env = process.env) {
+  const override = env.ORCHESTRATOR_STATE_DIR;
+  const stateDir = override !== void 0 && override !== "" ? override : join3(projectRoot, ".orchestrator", ".state");
+  return join3(stateDir, CAPABILITY_CACHE_FILENAME);
+}
+function writeCapabilityCache(cachePath, index) {
   try {
-    let config = {};
-    if (existsSync2(vaultConfigPath)) {
-      const raw = readFileSync2(vaultConfigPath, "utf-8");
-      config = (0, import_yaml.parse)(raw) ?? {};
-    }
     const pluginEntries = index.plugins.map((p) => {
       const entry = { name: p.name };
       if (p.version !== "unknown") entry.version = p.version;
@@ -7745,25 +7789,27 @@ function writeCapabilitiesToVault(vaultConfigPath, index) {
       if (p.hasHooks) entry.hooks = true;
       return entry;
     });
-    config.capabilities = {
+    const payload = {
+      schema: "capability-cache/v1",
       last_scanned: index.lastScanned,
       installed_plugins_mtime: index.installedPluginsMtime,
       plugins: pluginEntries,
       routing: index.routing,
       gaps: index.gaps
     };
-    writeFileSync2(vaultConfigPath, (0, import_yaml.stringify)(config, { lineWidth: 120 }));
+    mkdirSync2(dirname2(cachePath), { recursive: true });
+    writeFileSync2(cachePath, (0, import_yaml.stringify)(payload, { lineWidth: 120 }));
   } catch {
   }
 }
-function readCapabilitiesFromVault(vaultConfigPath) {
+function readCapabilityCache(cachePath, vaultConfigPath) {
   try {
-    if (!existsSync2(vaultConfigPath)) return null;
-    const raw = readFileSync2(vaultConfigPath, "utf-8");
-    const config = (0, import_yaml.parse)(raw);
-    const caps = config?.capabilities;
-    if (!caps) return null;
-    const rawPlugins = Array.isArray(caps.plugins) ? caps.plugins : [];
+    if (!existsSync2(cachePath)) return null;
+    const raw = readFileSync2(cachePath, "utf-8");
+    const cache = (0, import_yaml.parse)(raw);
+    if (!cache || typeof cache !== "object") return null;
+    if (cache.last_scanned === void 0 && cache.plugins === void 0) return null;
+    const rawPlugins = Array.isArray(cache.plugins) ? cache.plugins : [];
     const plugins = rawPlugins.map((p) => ({
       name: p.name ?? "",
       version: p.version ?? "unknown",
@@ -7774,14 +7820,14 @@ function readCapabilitiesFromVault(vaultConfigPath) {
       hasHooks: p.hooks ?? false
     }));
     return {
-      lastScanned: caps.last_scanned ?? "",
-      installedPluginsMtime: caps.installed_plugins_mtime ?? "",
+      lastScanned: cache.last_scanned ?? "",
+      installedPluginsMtime: cache.installed_plugins_mtime ?? "",
       plugins,
       agents: [],
       // agents are always scanned fresh (fast, <10ms)
       vault: readVaultSummary(vaultConfigPath),
-      routing: caps.routing ?? {},
-      gaps: caps.gaps ?? []
+      routing: cache.routing ?? {},
+      gaps: cache.gaps ?? []
     };
   } catch {
     return null;
@@ -7809,32 +7855,102 @@ function formatCapabilityMatrix(index) {
     `gaps: ${gapsLine}`
   ].join("\n");
 }
-function formatMemoryContext(entries) {
-  if (entries.length === 0) return "";
-  const byType = {};
-  for (const e of entries) {
-    byType[e.type] = (byType[e.type] ?? 0) + 1;
+var PER_ENTRY_SUMMARY_CHAR_CAP = 300;
+var AGGREGATE_CHAR_BUDGET = 8e3;
+var SUFFIX_RESERVE = 64;
+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) {
+    counts[e.type] = (counts[e.type] ?? 0) + 1;
   }
-  const typeSummary = Object.entries(byType).map(([t, n]) => `${n} ${t}`).join(", ");
-  const recentNames = entries.slice(0, 5).map((e) => e.file.replace(/\.md$/, "").replace(/^(feedback|project|reference|user)_/, "")).join(", ");
-  return [
-    `[MEMORY-CONTEXT] ${entries.length} entries: ${typeSummary}`,
-    `recent: ${recentNames}`
-  ].join("\n");
+  return counts;
 }
-function readMemoryIndex(indexPath) {
+function formatMemoryContext(selected, allEntries) {
+  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] ${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 < 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 = 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, warning].filter(Boolean).join("\n");
+}
+function isWellFormedMemoryEntry(value) {
+  return typeof value === "object" && value !== null && typeof value.file === "string";
+}
+function readMemoryIndex(indexPath, diag) {
   try {
     if (!existsSync2(indexPath)) return null;
     const raw = readFileSync2(indexPath, "utf-8");
-    const parsed = (0, import_yaml.parse)(raw);
-    return parsed?.entries ?? null;
-  } catch {
+    let parsed;
+    try {
+      parsed = (0, import_yaml.parse)(raw);
+    } catch (err) {
+      if (diag) diag.reason = `YAML inv\xE1lido em ${indexPath}: ${String(err).split("\n")[0]}`;
+      return null;
+    }
+    let candidate = null;
+    if (Array.isArray(parsed)) {
+      candidate = parsed;
+    } else if (typeof parsed === "object" && parsed !== null && Array.isArray(parsed.entries)) {
+      candidate = parsed.entries;
+    }
+    if (candidate === null) {
+      const chaves = typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? Object.keys(parsed).join(", ") : typeof parsed;
+      if (diag) {
+        diag.reason = `formato n\xE3o reconhecido em ${indexPath} \u2014 topo tem [${chaves}]; esperado uma lista no topo ou a chave 'entries:'`;
+      }
+      return null;
+    }
+    const bemFormadas = candidate.filter(isWellFormedMemoryEntry);
+    if (diag && candidate.length > 0) {
+      const descartadas = candidate.length - bemFormadas.length;
+      if (bemFormadas.length === 0) {
+        diag.reason = `${candidate.length} entrada(s) lidas e NENHUMA bem-formada em ${indexPath} \u2014 toda entrada precisa da chave 'file:'`;
+      } else if (descartadas > 0) {
+        diag.reason = `${descartadas} de ${candidate.length} entrada(s) descartadas em ${indexPath} (falta a chave 'file:')`;
+      }
+    }
+    return bemFormadas;
+  } catch (err) {
+    if (diag) diag.reason = `falha ao ler ${indexPath}: ${String(err).split("\n")[0]}`;
     return null;
   }
 }
 function filterRelevantMemories(entries, contextTags = []) {
   const now = Date.now();
   const fourteenDays = 14 * 24 * 60 * 60 * 1e3;
+  const MAX_TOTAL = 20;
+  const RESERVED_SLOTS_PER_TYPE = 2;
   const relevant = entries.filter((e) => {
     if (e.type === "feedback") return true;
     const accessed = new Date(e.last_accessed).getTime();
@@ -7848,17 +7964,32 @@ function filterRelevantMemories(entries, contextTags = []) {
     reference: 2,
     user: 3
   };
-  relevant.sort((a, b) => {
+  const byPriorityThenRecency = (a, b) => {
     const pa = typePriority[a.type] ?? 9;
     const pb = typePriority[b.type] ?? 9;
     if (pa !== pb) return pa - pb;
     return b.last_accessed.localeCompare(a.last_accessed);
-  });
-  return relevant.slice(0, 20);
+  };
+  relevant.sort(byPriorityThenRecency);
+  const reserved = /* @__PURE__ */ new Set();
+  const nonFeedbackTypes = new Set(entries.filter((e) => e.type !== "feedback").map((e) => e.type));
+  for (const type of nonFeedbackTypes) {
+    const ofType = entries.filter((e) => e.type === type).sort((a, b) => b.last_accessed.localeCompare(a.last_accessed));
+    for (const entry of ofType.slice(0, RESERVED_SLOTS_PER_TYPE)) {
+      reserved.add(entry);
+    }
+  }
+  const selected = new Set(reserved);
+  for (const entry of relevant) {
+    if (selected.size >= MAX_TOTAL) break;
+    if (reserved.has(entry)) continue;
+    selected.add(entry);
+  }
+  return [...selected].sort(byPriorityThenRecency);
 }
 
 // hooks/lib/session-selection.ts
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync3, mkdirSync as mkdirSync2 } from "node:fs";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync3, mkdirSync as mkdirSync3 } from "node:fs";
 import { join as join4 } from "node:path";
 function selectionFilePath(stateDir, sessionId) {
   const safeId = sessionId.replace(/[^a-zA-Z0-9_-]/g, "_");
@@ -7879,8 +8010,8 @@ function readSessionSelection(stateDir, sessionId) {
 
 // hooks/session-start.ts
 var HOOK = "SESSION-START";
-var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = dirname3(__filename2);
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname3(__filename);
 var PROJECT_ROOT2 = resolveHookProjectRoot(process.cwd());
 var PROJECT_ID2 = process.env.ORCHESTRATOR_PROJECT_ID ?? "";
 var HOME = process.env.HOME ?? process.env.USERPROFILE ?? "/home/user";
@@ -7889,18 +8020,35 @@ var PROJECT_SELECTION_ENABLED = process.env.ORCHESTRATOR_ENABLE_PROJECT_SELECTIO
 var SESSION_SELECTION_STATE_DIR = join5(HOME, ".orchestrator", "session-selection");
 var AGENTS_DIR = PROJECT_ROOT2 ? join5(PROJECT_ROOT2, ".claude", "agents") : null;
 var VAULT_CONFIG_PATH = PROJECT_ROOT2 ? join5(PROJECT_ROOT2, "project-guidelines", ".vault-config.yaml") : null;
+var CAPABILITY_CACHE_PATH = PROJECT_ROOT2 ? resolveCapabilityCachePath(PROJECT_ROOT2) : null;
 var PROFILES_PATH = PROJECT_ROOT2 ? join5(PROJECT_ROOT2, ".claude", "plugin-profiles.yaml") : null;
 var MEMORY_INDEX_PATH = PROJECT_ROOT2 ? join5(PROJECT_ROOT2, ".claude", "agent-memory", "orchestrator", "memory-index.yaml") : null;
-function readSessionId() {
+async function readSessionStartPayload() {
   try {
-    const raw = readFileSync4("/dev/stdin", "utf-8").trim();
-    if (!raw) return null;
-    const payload = JSON.parse(raw);
-    return payload.session_id ?? null;
-  } catch {
-    return null;
+    const payload = await readStdin();
+    log(HOOK, `stdin keys: [${Object.keys(payload).join(", ")}]`);
+    if (!payload.session_id && !payload.source) {
+      log(
+        HOOK,
+        `[WARN] stdin payload has neither session_id nor source \u2014 read likely empty or unparseable (readStdin() collapses both cases to {}); raw keys=[${Object.keys(payload).join(", ")}]`
+      );
+    }
+    return {
+      sessionId: payload.session_id ?? null,
+      source: payload.source ?? null
+    };
+  } catch (err) {
+    log(HOOK, `[WARN] readStdin() itself threw (not just empty/malformed stdin) \u2014 ${String(err)}`);
+    return { sessionId: null, source: null };
   }
 }
+function isRecoverySource(source) {
+  return source === "compact";
+}
+var RECOVERY_DIRECTIVE = [
+  "[ORCHESTRATOR] Context was compacted mid-session. This is NOT a session start.",
+  "Do NOT greet. Do NOT call AskUserQuestion. Resume the in-flight task."
+];
 var PROJECT_STATE_PATH = PROJECT_ROOT2 ? join5(PROJECT_ROOT2, "project-guidelines", "project-state.yaml") : null;
 function synthesizeStatus(pending) {
   const { critical, high, medium, ci_gating: ciGating } = pending;
@@ -8057,43 +8205,76 @@ async function buildProjectSelectionPrompt() {
     return "";
   }
 }
-function buildCapabilityMatrixContext() {
+function buildMatrixLine(vaultConfigPath, agentsDir, profilesPath, cachePath) {
+  let index = readCapabilityCache(cachePath, vaultConfigPath);
+  const cachedMtime = index?.installedPluginsMtime ?? "";
+  if (!index || needsRescan(INSTALLED_PLUGINS_PATH, cachedMtime)) {
+    log(HOOK, "Capability rescan triggered");
+    index = buildCapabilityIndex({
+      installedPluginsPath: INSTALLED_PLUGINS_PATH,
+      agentsDir,
+      vaultConfigPath,
+      profilesPath
+    });
+    writeCapabilityCache(cachePath, index);
+  } else {
+    index.agents = scanAgentDefinitions(agentsDir);
+    log(HOOK, "Using cached capability index");
+  }
+  return formatCapabilityMatrix(index);
+}
+function buildMemoryLine(memoryIndexPath) {
+  const diag = {};
+  const memoryEntries = readMemoryIndex(memoryIndexPath, diag);
+  if (diag.reason) log(HOOK, `Memory index: ${diag.reason}`);
+  if (diag.reason && (!memoryEntries || memoryEntries.length === 0)) {
+    return `[MEMORY-CONTEXT] INDISPON\xCDVEL \u2014 nenhuma mem\xF3ria injetada. ${diag.reason}`;
+  }
+  if (!memoryEntries) return "";
+  const filtered = filterRelevantMemories(memoryEntries);
+  return formatMemoryContext(filtered, memoryEntries);
+}
+function resolveVaultPaths(caller) {
+  if (VAULT_CONFIG_PATH === null || AGENTS_DIR === null || PROFILES_PATH === null || MEMORY_INDEX_PATH === null || CAPABILITY_CACHE_PATH === null) {
+    log(HOOK, `${caller}: PROJECT_ROOT unresolved (unregistered cwd) \u2014 skipping`);
+    return null;
+  }
+  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 {
-    if (VAULT_CONFIG_PATH === null || AGENTS_DIR === null || PROFILES_PATH === null || MEMORY_INDEX_PATH === null) {
-      log(
-        HOOK,
-        "buildCapabilityMatrixContext: PROJECT_ROOT unresolved (unregistered cwd) \u2014 skipping"
-      );
-      return "";
-    }
-    let index = readCapabilitiesFromVault(VAULT_CONFIG_PATH);
-    const cachedMtime = index?.installedPluginsMtime ?? "";
-    if (!index || needsRescan(INSTALLED_PLUGINS_PATH, cachedMtime)) {
-      log(HOOK, "Capability rescan triggered");
-      index = buildCapabilityIndex({
-        installedPluginsPath: INSTALLED_PLUGINS_PATH,
-        agentsDir: AGENTS_DIR,
-        vaultConfigPath: VAULT_CONFIG_PATH,
-        profilesPath: PROFILES_PATH
-      });
-      writeCapabilitiesToVault(VAULT_CONFIG_PATH, index);
-    } else {
-      index.agents = scanAgentDefinitions(AGENTS_DIR);
-      log(HOOK, "Using cached capability index");
-    }
-    const matrixLine = formatCapabilityMatrix(index);
-    const memoryEntries = readMemoryIndex(MEMORY_INDEX_PATH);
-    let memoryLine = "";
-    if (memoryEntries) {
-      const filtered = filterRelevantMemories(memoryEntries);
-      memoryLine = formatMemoryContext(filtered);
-    }
-    return [matrixLine, memoryLine].filter(Boolean).join("\n");
+    return buildMatrixLine(
+      paths.vaultConfigPath,
+      paths.agentsDir,
+      paths.profilesPath,
+      paths.capabilityCachePath
+    );
   } catch (err) {
     log(HOOK, `Capability matrix failed: ${err}`);
     return "";
   }
 }
+function buildMemoryContext() {
+  const paths = resolveVaultPaths("buildMemoryContext");
+  if (!paths) return "";
+  try {
+    return buildMemoryLine(paths.memoryIndexPath);
+  } catch (err) {
+    log(HOOK, `Memory context failed: ${err}`);
+    return "";
+  }
+}
+function buildCapabilityMatrixContext() {
+  return [buildMatrixContext(), buildMemoryContext()].filter(Boolean).join("\n");
+}
 function checkSprintInbox() {
   const sprintId = process.env.SPRINT_ID;
   const paneRole = process.env.PANE_ROLE;
@@ -8140,13 +8321,16 @@ async function main() {
       "PROJECT_ROOT unresolved: cwd has no .orchestrator sentinel up to the filesystem root \u2014 vault-dependent sections (tier, capability matrix, BACKLOG fallback) will be skipped this session (RFC-040 C5, AC-C5-2)."
     );
   }
-  const sessionId = readSessionId();
+  const { sessionId, source } = await readSessionStartPayload();
+  const isRecovery = isRecoverySource(source);
   const sessionSegment = sessionId ? ` | session=${sessionId}` : "";
   if (sessionId) log(HOOK, `Claude session: ${sessionId}`);
+  log(HOOK, `source=${source ?? "unknown"} mode=${isRecovery ? "recovery" : "boot"}`);
   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;
@@ -8157,22 +8341,26 @@ async function main() {
   });
   const projectBindingSegment = formatProjectBindingSegment(projectBinding);
   setEffectiveProjectId(projectBinding.projectId);
-  const projectSelectionPrompt = PROJECT_SELECTION_ENABLED && projectBinding.source === "none" ? await buildProjectSelectionPrompt() : "";
+  const projectSelectionPrompt = PROJECT_SELECTION_ENABLED && !isRecovery && projectBinding.source === "none" ? await buildProjectSelectionPrompt() : "";
   const sessionAllocation = await allocateSessionNumber(projectBinding.projectId);
   const sessionNumberSegment = formatSessionNumberSegment(sessionAllocation);
   const workflow = await getActiveWorkflow();
   if (!workflow) {
-    log(HOOK, "No active workflow, injecting greeting data");
+    log(HOOK, `No active workflow, injecting ${isRecovery ? "recovery" : "greeting"} data`);
+    const stateLine2 = `version=${backlog.version}${sessionSegment} | workflow=none${tierSegment}${sessionNumberSegment}${projectBindingSegment} | next=${backlog.next}`;
     outputContext(
       "SessionStart",
       [
-        `[ORCHESTRATOR-DATA] version=${backlog.version}${sessionSegment} | workflow=none${tierSegment}${sessionNumberSegment}${projectBindingSegment} | next=${backlog.next}`,
-        backlog.lastSession ? `[LAST-SESSION] ${backlog.lastSession}` : "",
-        backlog.status ? `[PENDENTE] ${backlog.status}` : "",
-        `[ORCHESTRATOR] Greet the user via AskUserQuestion using the data above (CLAUDE.md Rule #1).`,
-        "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,
+        `${isRecovery ? "[ORCHESTRATOR-RECOVERY]" : "[ORCHESTRATOR-DATA]"} ${stateLine2}`,
+        memoryContext,
+        ...isRecovery ? RECOVERY_DIRECTIVE : [
+          backlog.lastSession ? `[LAST-SESSION] ${backlog.lastSession}` : "",
+          backlog.status ? `[PENDENTE] ${backlog.status}` : "",
+          `[ORCHESTRATOR] Greet the user via AskUserQuestion using the data above (orchestrator identity, MUST rule #1).`,
+          "Do NOT invoke /orchestrator skill for the greeting \u2014 use AskUserQuestion directly.",
+          "Invoke /orchestrator skill only when the user chooses to start a workflow."
+        ],
+        matrixContext,
         sprintInboxContext,
         projectSelectionPrompt
       ].filter(Boolean).join("\n")
@@ -8181,21 +8369,31 @@ async function main() {
   }
   const action = await getNextAction(workflow.id);
   const actionHint = action?.hasAction && action.pendingAction ? ` | pending=${action.pendingAction.agent} (${action.pendingAction.status})` : "";
-  log(HOOK, `Injecting workflow context (wf=${workflow.id} phase=${workflow.currentPhase})`);
+  log(
+    HOOK,
+    `Injecting workflow ${isRecovery ? "recovery" : "context"} (wf=${workflow.id} phase=${workflow.currentPhase})`
+  );
+  const stateLine = `version=${backlog.version}${sessionSegment} | workflow=${workflow.id} | type=${workflow.type} | phase=${workflow.currentPhase} | status=${workflow.status}${actionHint}${tierSegment}${sessionNumberSegment}${projectBindingSegment}`;
   outputContext(
     "SessionStart",
     [
-      `[ORCHESTRATOR-DATA] version=${backlog.version}${sessionSegment} | workflow=${workflow.id} | type=${workflow.type} | phase=${workflow.currentPhase} | status=${workflow.status}${actionHint}${tierSegment}${sessionNumberSegment}${projectBindingSegment}`,
-      `[ORCHESTRATOR] Active workflow detected. Greet the user via AskUserQuestion showing workflow state (CLAUDE.md 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,
+      `${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."
+      ],
+      matrixContext,
       projectSelectionPrompt
     ].filter(Boolean).join("\n")
   );
 }
 main().catch(() => process.exit(0));
 export {
+  buildCapabilityMatrixContext,
+  buildMatrixContext,
+  buildMemoryContext,
   buildProjectSelectionPrompt,
   formatProjectBindingSegment,
   formatSessionNumberSegment,