@wrongstack/core 0.313.1 → 0.316.2

package/dist/chunk-YWXT3JNM.js

@@ -0,0 +1,425 @@
+import {
+  JsonlFindingStore
+} from "./chunk-4LCZVJVF.js";
+import {
+  computeFindingFingerprint
+} from "./chunk-UJILKYES.js";
+import {
+  JsonlReportStore
+} from "./chunk-HXKZ7OBQ.js";
+
+// src/plugins/review-finding-parser.ts
+import { randomUUID } from "node:crypto";
+var SEVERITIES = /* @__PURE__ */ new Set(["critical", "high", "medium", "low"]);
+var CATEGORIES = /* @__PURE__ */ new Set([
+  "bug",
+  "security",
+  "performance",
+  "type",
+  "contract",
+  "test",
+  "other"
+]);
+var CONFIDENCES = /* @__PURE__ */ new Set(["high", "medium", "low"]);
+var FENCED_BLOCK = /```json[ \t]*\r?\n([\s\S]*?)\r?\n```/gi;
+function extractStructuredFindingsBlock(reportText) {
+  if (!reportText) return null;
+  let best = null;
+  for (const match of reportText.matchAll(FENCED_BLOCK)) {
+    const body = match[1];
+    if (!body?.trim()) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(body);
+    } catch {
+      continue;
+    }
+    if (typeof parsed !== "object" || parsed === null) continue;
+    const findings = parsed.findings;
+    if (!Array.isArray(findings)) continue;
+    const items = [];
+    for (const raw of findings) {
+      const item = normalizeStructuredItem(raw);
+      if (item) items.push(item);
+    }
+    if (findings.length > 0 && items.length === 0) continue;
+    const durationRaw = parsed.durationSeconds;
+    const durationSeconds = typeof durationRaw === "number" && Number.isFinite(durationRaw) && durationRaw > 0 ? Math.floor(durationRaw) : void 0;
+    best = { findings: items, ...durationSeconds !== void 0 ? { durationSeconds } : {} };
+  }
+  return best;
+}
+function normalizeStructuredItem(raw) {
+  if (typeof raw !== "object" || raw === null) return null;
+  const item = raw;
+  const severity = typeof item.severity === "string" ? item.severity.toLowerCase() : "";
+  if (!SEVERITIES.has(severity)) return null;
+  const title = typeof item.title === "string" ? item.title.trim() : "";
+  if (title.length === 0) return null;
+  const file = typeof item.file === "string" && item.file.trim().length > 0 ? item.file.trim() : void 0;
+  const line = typeof item.line === "number" && Number.isInteger(item.line) && item.line >= 1 ? item.line : void 0;
+  const categoryRaw = typeof item.category === "string" ? item.category.toLowerCase() : "";
+  const category = CATEGORIES.has(categoryRaw) ? categoryRaw : void 0;
+  const confidenceRaw = typeof item.confidence === "string" ? item.confidence.toLowerCase() : "";
+  const confidence = CONFIDENCES.has(confidenceRaw) ? confidenceRaw : void 0;
+  return {
+    severity,
+    ...file ? { file } : {},
+    ...line !== void 0 ? { line } : {},
+    ...category ? { category } : {},
+    ...confidence ? { confidence } : {},
+    title,
+    ...typeof item.description === "string" && item.description.trim().length > 0 ? { description: item.description.trim() } : {},
+    ...typeof item.suggestedFix === "string" && item.suggestedFix.trim().length > 0 ? { suggestedFix: item.suggestedFix.trim() } : {}
+  };
+}
+var SUGGEST_LINE = /^\s*(?:→|->|=>)\s*(.+)$/;
+var DURATION_LINE = /^Duration:\s*(\d+)s\s*$/im;
+function parseChimeraReviewReport(reportText, context = {}) {
+  if (!reportText || reportText.trim().length === 0) {
+    return { findings: [], unparseableCount: 0 };
+  }
+  const structured = extractStructuredFindingsBlock(reportText);
+  if (structured) {
+    const reportId2 = context.reportId ?? randomUUID();
+    const findings2 = structured.findings.map(
+      (item) => buildFindingFromStructuredItem(item, { ...context, reportId: reportId2 })
+    );
+    return {
+      findings: findings2,
+      unparseableCount: 0,
+      ...structured.durationSeconds !== void 0 ? { durationSeconds: structured.durationSeconds } : {},
+      structured: true
+    };
+  }
+  const findings = [];
+  const reportId = context.reportId ?? randomUUID();
+  let unparseableCount = 0;
+  let durationSeconds;
+  let currentSeverity = null;
+  let currentLines = [];
+  const lines = reportText.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const headingMatch = line.trim().match(/^###\s+(critical|high|medium|low)\b/i);
+    if (headingMatch) {
+      flushSection();
+      currentSeverity = headingMatch[1].toLowerCase();
+      continue;
+    }
+    const durMatch = line.match(DURATION_LINE);
+    if (durMatch) {
+      durationSeconds = Number.parseInt(durMatch[1], 10);
+      continue;
+    }
+    if (currentSeverity !== null) {
+      currentLines.push(line);
+    }
+  }
+  flushSection();
+  return { findings, unparseableCount, durationSeconds };
+  function flushSection() {
+    if (currentSeverity === null || currentLines.length === 0) {
+      currentSeverity = null;
+      currentLines = [];
+      return;
+    }
+    const combined = currentLines.join("\n");
+    const segments = combined.split(/\n\s*(?=\d+\.\s)/).filter((s) => s.trim().length > 0);
+    for (const segment of segments) {
+      const finding = parseFindingSegment(segment, currentSeverity, { ...context, reportId });
+      if (finding) {
+        findings.push(finding);
+      } else {
+        unparseableCount++;
+      }
+    }
+    currentSeverity = null;
+    currentLines = [];
+  }
+}
+function parseFindingSegment(segment, severity, context) {
+  const lines = segment.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
+  if (lines.length === 0) return null;
+  const first = lines[0];
+  const match = first.match(/^\d+\.\s+(.*)$/);
+  if (!match) return null;
+  const content = match[1].trim();
+  let remaining = content;
+  const tagMatch = content.match(/^\[(\w+)\]\s*/);
+  if (tagMatch) {
+    remaining = content.slice(tagMatch[0].length).trim();
+  }
+  const citationMatch = remaining.match(
+    /^(`+)([a-zA-Z_./\\:][^`]*[a-zA-Z0-9_./\\:])\1(?=\s*[—–-]|\s*$)/
+  );
+  if (citationMatch) {
+    const inner = citationMatch[2];
+    const afterCitation = remaining.slice(citationMatch[0].length);
+    remaining = `${inner}${afterCitation}`;
+  }
+  let file;
+  let line;
+  let desc = remaining;
+  const refMatch = remaining.match(
+    /^([a-zA-Z_./\\][a-zA-Z0-9_./\\-]*\.\w+)(?::(\d+))?\s+(?:[—–]|-)\s+(.+)$/
+  );
+  if (refMatch) {
+    file = refMatch[1].trim();
+    if (refMatch[2] !== void 0) {
+      line = Number.parseInt(refMatch[2], 10);
+    }
+    desc = refMatch[3].trim();
+  }
+  if (!file) {
+    const pathMatch = remaining.match(/^([a-zA-Z_./\\][a-zA-Z0-9_./\\-]*\.\w+)(?::(\d+))?/);
+    if (pathMatch) {
+      file = pathMatch[1].trim();
+      if (pathMatch[2] !== void 0) {
+        line = Number.parseInt(pathMatch[2], 10);
+      }
+      const afterFile = remaining.slice(pathMatch[0].length).trim();
+      desc = afterFile.replace(/^[—–-]\s*/, "").trim() || desc;
+    }
+  }
+  const cleanDesc = desc.replace(/^[—–-]\s*/, "").trim();
+  const suggestions = [];
+  for (let i = 1; i < lines.length; i++) {
+    const suggest = lines[i].match(SUGGEST_LINE);
+    if (suggest) {
+      suggestions.push(suggest[1].trim());
+    }
+  }
+  const title = cleanDesc.split(/\.\s/)[0].trim() || content;
+  const fullDesc = suggestions.length > 0 ? cleanDesc + "\n" + suggestions.map((s) => "  \u2192 " + s).join("\n") : cleanDesc;
+  const suggestedFix = suggestions.length > 0 ? suggestions.join("\n") : void 0;
+  return {
+    id: randomUUID(),
+    fingerprint: computeFindingFingerprint(file ?? "", line ?? null, title),
+    severity,
+    source: normalizeFindingSource(context.reviewType),
+    ...file ? { location: { file, ...line !== void 0 ? { line } : {} } } : {},
+    title,
+    description: fullDesc,
+    ...suggestedFix ? { suggestedFix } : {},
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    status: "active",
+    originReport: {
+      reportId: context.reportId ?? randomUUID(),
+      sessionId: context.sessionId ?? "",
+      agentId: context.agentId ?? "",
+      reviewerModel: context.reviewerModel ?? ""
+    }
+  };
+}
+function normalizeFindingSource(reviewType) {
+  switch (reviewType) {
+    case "auto":
+    case "chimera":
+    case "cascade":
+    case "security-scanner":
+      return reviewType;
+    default:
+      return "chimera";
+  }
+}
+function buildFindingFromStructuredItem(item, context) {
+  const file = item.file;
+  const line = item.line;
+  const title = item.title;
+  const description = item.description ?? title;
+  return {
+    id: randomUUID(),
+    fingerprint: computeFindingFingerprint(file ?? "", line ?? null, title),
+    severity: item.severity,
+    source: normalizeFindingSource(context.reviewType),
+    ...file ? { location: { file, ...line !== void 0 ? { line } : {} } } : {},
+    ...item.category ? { category: item.category } : {},
+    ...item.confidence ? { confidence: item.confidence } : {},
+    title,
+    description,
+    ...item.suggestedFix ? { suggestedFix: item.suggestedFix } : {},
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    status: "active",
+    originReport: {
+      reportId: context.reportId ?? randomUUID(),
+      sessionId: context.sessionId ?? "",
+      agentId: context.agentId ?? "",
+      reviewerModel: context.reviewerModel ?? ""
+    }
+  };
+}
+
+// src/plugins/review-finding-integration.ts
+function classifyChimeraReviewSource(bundle) {
+  const cascadeDepth = bundle.cascadeDepth ?? 0;
+  if (cascadeDepth > 0) return "cascade";
+  const cascadeOn = bundle.cascadeOn;
+  if (cascadeOn !== void 0 && cascadeOn !== "off") return "auto";
+  return "chimera";
+}
+async function integrateFindings(payload, projectDir, reportId) {
+  if ((!payload.reviewText || payload.reviewText.trim().length === 0) && !payload.parsedReport) {
+    return { created: 0, relinked: 0, reopened: 0, totalFindings: 0, unparseableCount: 0 };
+  }
+  const store = new JsonlFindingStore(projectDir);
+  const source = classifyChimeraReviewSource(payload.bundle);
+  const agentId = payload.bundle.fileProvenance?.find((entry) => entry.agentId)?.agentId ?? "chimera-review";
+  const sessionId = payload.sessionId ?? payload.cwd;
+  const model = payload.bundle.config.model;
+  const parsed = payload.parsedReport ?? parseChimeraReviewReport(payload.reviewText, {
+    sessionId,
+    agentId,
+    reviewerModel: model,
+    reviewType: source,
+    reportId
+  });
+  if (parsed.findings.length === 0) {
+    return {
+      created: 0,
+      relinked: 0,
+      reopened: 0,
+      totalFindings: 0,
+      unparseableCount: parsed.unparseableCount
+    };
+  }
+  const result = await store.upsert(parsed.findings, {
+    sessionId,
+    reportId,
+    agentId,
+    model
+  });
+  return {
+    created: result.created,
+    relinked: result.relinked,
+    reopened: result.reopened,
+    reportId,
+    totalFindings: parsed.findings.length,
+    unparseableCount: parsed.unparseableCount
+  };
+}
+
+// src/plugins/review-report-integration.ts
+async function updateReviewReportEvidence(reportId, projectDir, evidenceStatus, evidenceChecks) {
+  await new JsonlReportStore(projectDir).updateEvidence(
+    reportId,
+    evidenceStatus,
+    evidenceChecks
+  );
+}
+async function persistReviewReport(payload, reportId, projectDir) {
+  const store = new JsonlReportStore(projectDir);
+  const existed = await store.get(reportId);
+  const source = classifyChimeraReviewSource(payload.bundle);
+  const agentId = payload.bundle.fileProvenance?.find((entry) => entry.agentId)?.agentId ?? "chimera-review";
+  const sessionId = payload.sessionId ?? payload.cwd;
+  const model = payload.bundle.config.model;
+  const cascadeDepth = payload.bundle.cascadeDepth;
+  const files = payload.bundle.files.map((f) => ({
+    path: f.path,
+    status: f.status
+  }));
+  const reviewStatus = payload.status === "success" ? "success" : "failed";
+  const parsed = reviewStatus === "success" ? payload.parsedReport ?? parseChimeraReviewReport(payload.reviewText, {
+    sessionId,
+    agentId,
+    reviewerModel: model,
+    reviewType: source,
+    reportId
+  }) : { findings: [], unparseableCount: 0, durationSeconds: void 0 };
+  const counts = { critical: 0, high: 0, medium: 0, low: 0 };
+  for (const finding of parsed.findings) {
+    counts[finding.severity]++;
+  }
+  const input = {
+    id: reportId,
+    sessionId,
+    agentId,
+    reviewerModel: model,
+    source,
+    reviewStatus,
+    files,
+    counts,
+    totalFindings: parsed.findings.length,
+    unparseableCount: parsed.unparseableCount,
+    durationSeconds: parsed.durationSeconds,
+    rawText: payload.reviewText,
+    ...cascadeDepth !== void 0 ? { cascadeDepth } : {},
+    // P0-3: carry the cascade evidence verification (status + per-check
+    // comparisons) so the persisted report is auditable. Absent on initial
+    // reviews — no cascade step produced evidence yet.
+    ...payload.bundle.evidenceStatus !== void 0 ? { evidenceStatus: payload.bundle.evidenceStatus } : {},
+    ...payload.bundle.evidenceChecks !== void 0 ? { evidenceChecks: payload.bundle.evidenceChecks } : {}
+  };
+  await store.persist(input);
+  if (reviewStatus === "success" && parsed.findings.length === 0 && parsed.unparseableCount === 0 && isExplicitAllClearReview(payload.reviewText)) {
+    await store.transition(
+      reportId,
+      "completed",
+      { id: "chimera", kind: "system" },
+      {
+        reason: "Successful Chimera review produced no actionable findings"
+      }
+    );
+  }
+  return {
+    reportId,
+    created: !existed,
+    totalFindings: parsed.findings.length
+  };
+}
+function isExplicitAllClearReview(text) {
+  const normalized = text.trim().toLowerCase();
+  return normalized.startsWith("## \u{1F982} chimera review \u2014 all clear") || normalized.includes("chimera review: all clear");
+}
+async function syncReportCompletion(reportId, projectDir, actor) {
+  const reportStore = new JsonlReportStore(projectDir);
+  const findingStore = new JsonlFindingStore(projectDir);
+  const report = await reportStore.get(reportId);
+  if (!report) {
+    return { reportId, completed: false, totalFindings: 0, remaining: 0 };
+  }
+  if (report.lifecycle === "completed" || report.lifecycle === "skipped") {
+    return { reportId, completed: false, totalFindings: 0, remaining: 0 };
+  }
+  const findings = await findingStore.list({ reportId, limit: 9999 });
+  const total = findings.length;
+  if (total === 0) {
+    return { reportId, completed: false, totalFindings: 0, remaining: 0 };
+  }
+  const remaining = findings.filter(
+    (f) => f.status !== "resolved" && f.status !== "ignored"
+  ).length;
+  if (remaining > 0) {
+    return { reportId, completed: false, totalFindings: total, remaining };
+  }
+  await reportStore.transition(reportId, "completed", actor, {
+    reason: `All ${total} finding(s) resolved or ignored`
+  });
+  return { reportId, completed: true, totalFindings: total, remaining: 0 };
+}
+async function syncReportReopen(reportId, projectDir, actor, reason) {
+  const reportStore = new JsonlReportStore(projectDir);
+  const report = await reportStore.get(reportId);
+  if (!report) {
+    return { reportId, reopened: false, previousLifecycle: "not_found" };
+  }
+  if (report.lifecycle !== "completed" && report.lifecycle !== "skipped") {
+    return { reportId, reopened: false, previousLifecycle: report.lifecycle };
+  }
+  await reportStore.transition(reportId, "open", actor, {
+    reason: reason ?? `Finding reopened \u2014 report was ${report.lifecycle}`
+  });
+  return { reportId, reopened: true, previousLifecycle: report.lifecycle };
+}
+
+export {
+  parseChimeraReviewReport,
+  classifyChimeraReviewSource,
+  integrateFindings,
+  updateReviewReportEvidence,
+  persistReviewReport,
+  syncReportCompletion,
+  syncReportReopen
+};
+//# sourceMappingURL=chunk-YWXT3JNM.js.map

package/dist/{chunk-EFEHDQGY.js → chunk-ZHZ2Y2DH.js}

@@ -1,12 +1,12 @@
 import {
   computeMessageTokens
-} from "./chunk-FSWCWSTS.js";
-import {
-  isTextBlock
-} from "./chunk-O37BQ65S.js";
+} from "./chunk-HMLIGAU7.js";
 import {
   expectDefined
 } from "./chunk-PFZO3C6H.js";
+import {
+  isTextBlock
+} from "./chunk-O37BQ65S.js";
 
 // src/utils/context-evidence.ts
 import * as path from "node:path";
@@ -695,6 +695,12 @@ function wrapAsState(ctx) {
 // src/core/context.ts
 import { realpathSync } from "node:fs";
 import * as path2 from "node:path";
+import { requireSessionId } from "@wrongstack/primitives";
+function isAppendableSessionWriter(writer) {
+  return Boolean(
+    writer && typeof writer === "object" && typeof writer.append === "function"
+  );
+}
 var Context = class _Context {
   messages = [];
   /**
@@ -979,6 +985,7 @@ var Context = class _Context {
   _conversationJournalQueue = [];
   _conversationJournalBytes = 0;
   _conversationJournalDrain = null;
+  _conversationJournalLastError = null;
   static CONVERSATION_JOURNAL_MAX_EVENTS = 256;
   static CONVERSATION_JOURNAL_MAX_BYTES = 4 * 1024 * 1024;
   static MAX_FILE_EVENTS = 1e3;
@@ -990,9 +997,13 @@ var Context = class _Context {
       const drain = this._conversationJournalDrain;
       if (!drain) break;
       await drain;
+      if (this._conversationJournalQueue.length > 0 && this._conversationJournalLastError) {
+        throw this._conversationJournalLastError;
+      }
     }
     this._conversationJournalQueue.length = 0;
     this._conversationJournalBytes = 0;
+    this._conversationJournalLastError = null;
   }
   conversationJournalBytes(event) {
     try {
@@ -1024,6 +1035,11 @@ var Context = class _Context {
     );
   }
   enqueueConversationJournal(event, writer) {
+    if (!isAppendableSessionWriter(writer)) {
+      this.warnConversationJournalDrop(event.type);
+      return;
+    }
+    this._conversationJournalLastError = null;
     const bytes = this.conversationJournalBytes(event);
     const shouldSnapshot = event.type === "messages_replaced" || this._conversationJournalQueue.length >= _Context.CONVERSATION_JOURNAL_MAX_EVENTS || this._conversationJournalBytes + bytes > _Context.CONVERSATION_JOURNAL_MAX_BYTES;
     if (shouldSnapshot) {
@@ -1065,12 +1081,42 @@ var Context = class _Context {
         const queued = this._conversationJournalQueue.shift();
         if (!queued) continue;
         this._conversationJournalBytes = Math.max(0, this._conversationJournalBytes - queued.bytes);
-        await queued.writer.append(queued.event).catch(() => {
-        });
+        if (!isAppendableSessionWriter(queued.writer)) {
+          this.warnConversationJournalDrop(queued.event.type);
+          continue;
+        }
+        try {
+          await queued.writer.append(queued.event);
+          this._conversationJournalLastError = null;
+        } catch (err) {
+          const attempts = (queued.attempts ?? 0) + 1;
+          this._conversationJournalQueue.unshift({ ...queued, attempts });
+          this._conversationJournalBytes += queued.bytes;
+          const error = err instanceof Error ? err : new Error(String(err));
+          this._conversationJournalLastError = error;
+          if (attempts < 3) {
+            await new Promise((resolve3) => setTimeout(resolve3, attempts * 25));
+            continue;
+          }
+          console.warn(
+            JSON.stringify({
+              level: "error",
+              event: "session.conversation_journal_write_failed",
+              sessionId: this.session?.id,
+              eventType: queued.event.type,
+              attempts,
+              message: error.message,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            })
+          );
+          break;
+        }
       }
     })().finally(() => {
       if (this._conversationJournalDrain === drain) this._conversationJournalDrain = null;
-      if (this._conversationJournalQueue.length > 0) this.startConversationJournalDrain();
+      if (this._conversationJournalQueue.length > 0 && !this._conversationJournalLastError) {
+        this.startConversationJournalDrain();
+      }
     });
     this._conversationJournalDrain = drain;
   }
@@ -1456,9 +1502,16 @@ var Context = class _Context {
   }
 };
 function resolveEventSessionId(ctx) {
-  if (ctx.activeRunSessionId) return ctx.activeRunSessionId;
+  if (ctx.activeRunSessionId) {
+    return requireSessionId(ctx.activeRunSessionId, "agent event emission");
+  }
   const session = ctx.session;
-  return session?.id ?? "";
+  return requireSessionId(session?.id, "agent event emission");
+}
+function resolveOwningSessionId(ctx) {
+  const owning = ctx.meta?.["sessionId"];
+  if (typeof owning === "string" && owning.length > 0) return owning;
+  return resolveEventSessionId(ctx);
 }
 
 // src/utils/json-repair.ts
@@ -1582,8 +1635,9 @@ export {
   wrapAsState,
   Context,
   resolveEventSessionId,
+  resolveOwningSessionId,
   bindRequestProvider,
   providerBoundToRequest,
   completePartialObject
 };
-//# sourceMappingURL=chunk-EFEHDQGY.js.map
+//# sourceMappingURL=chunk-ZHZ2Y2DH.js.map

package/dist/{chunk-CQQL4ZOQ.js → chunk-ZT7JNIGX.js}

@@ -1,6 +1,6 @@
 import {
   ensureProjectGitignore
-} from "./chunk-4XV6IR37.js";
+} from "./chunk-HI3JGZR2.js";
 
 // src/utils/config-backup.ts
 import * as fs from "node:fs/promises";
@@ -11,7 +11,7 @@ function configHistoryDir(globalRoot) {
 function configSlug(absolutePath, globalRoot) {
   const rel = path.relative(globalRoot, absolutePath);
   const normalized = rel.replace(/\\/g, "/").replace(/\.json$/i, "");
-  return normalized.replace(/\//g, "-");
+  return normalized.replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/^-+|-+$/g, "") || "config";
 }
 async function backupConfigFile(filePath, paths) {
   let currentContent;
@@ -144,8 +144,9 @@ async function activateProjectStateGuard(projectRoot, options = {}) {
 
 export {
   configHistoryDir,
+  configSlug,
   backupConfigFile,
   startProjectStateGuard,
   activateProjectStateGuard
 };
-//# sourceMappingURL=chunk-CQQL4ZOQ.js.map
+//# sourceMappingURL=chunk-ZT7JNIGX.js.map

package/dist/coordination/agent-monitor.d.ts

@@ -104,8 +104,16 @@ export declare class AgentMonitorService {
      *
      * Entries already in the ring win: a live subagent's in-memory segment is
      * newer than its JSONL, which is only written when a segment closes.
+     *
+     * `only` restricts BOTH the disk scan and the returned set to a known list of
+     * subagent ids. This is how a session gets ITS OWN subagents back: the
+     * transcripts directory is shared by every session of the project, so the
+     * unfiltered form hands each of four open tabs the union of all four tabs'
+     * workers. The caller derives the list from the session's own journal
+     * (`deriveSessionAgents`), which is the only record that says which agents
+     * belong to which session.
      */
-    loadSessionsFromDisk(): Promise<AgentVirtualSession[]>;
+    loadSessionsFromDisk(only?: readonly string[]): Promise<AgentVirtualSession[]>;
     private _readTranscriptFile;
     /** Get a specific agent's virtual session, or undefined. */
     getSession(subagentId: string): AgentVirtualSession | undefined;

package/dist/coordination/agent-subagent-runner.d.ts

@@ -36,7 +36,7 @@ export interface AgentFactoryResult {
      * thrown here are swallowed so a flaky cleanup can't mask the task's
      * real result.
      */
-    dispose?: ((() => Promise<void> | void)) | undefined;
+    dispose?: (() => Promise<void> | void) | undefined;
 }
 export interface AgentRunnerOptions {
     factory: AgentFactory;

package/dist/coordination/agents/agent-prompts.d.ts

@@ -1,2 +1,10 @@
+/**
+ * Number of live prompt-cache entries.
+ *
+ * Exposed so the "one entry per role, regardless of how many times the overlay
+ * is rewritten" bound above is testable. The old fingerprint-in-key scheme grew
+ * this without limit and nothing could observe it.
+ */
+export declare function agentPromptCacheSize(): number;
 export declare function agentPrompt(id: string): string;
 //# sourceMappingURL=agent-prompts.d.ts.map

package/dist/coordination/agents/index.d.ts

@@ -23,13 +23,33 @@ import { WAVE3_AGENTS } from './phase8-wave3-products.js';
 import { META_AGENTS } from './phase9-meta.js';
 import { WAVE4_AGENTS } from './phase9-wave4-platform-meta.js';
 import { ROLE_SKILL_SETS, SHADOW_AGENT_SKILLS } from './role-skills.js';
-import type { AgentDefinition } from './types.js';
+import type { AgentCapability, AgentDefinition } from './types.js';
 export * from './capability-manifest.js';
 export * from './phase3-wave1-platform.js';
 export * from './phase3-wave2-meta.js';
 export * from './phase8-wave3-products.js';
 export * from './phase9-wave4-platform-meta.js';
+export * from './project-agent-auto-optimize.js';
+export * from './project-agent-capture-window.js';
+export * from './project-agent-capture.js';
+export * from './project-agent-config-io.js';
+export * from './project-agent-config-validation.js';
+export * from './project-agent-consolidation.js';
+export * from './project-agent-directive-outcome.js';
+export * from './project-agent-files.js';
+export * from './project-agent-identity-types.js';
 export * from './project-agent-identity.js';
+export * from './project-agent-knowledge-manifests.js';
+export * from './project-agent-learning-entries.js';
+export * from './project-agent-learning-normalize.js';
+export * from './project-agent-learning-policy.js';
+export * from './project-agent-learning-structured.js';
+export * from './project-agent-optimizer.js';
+export * from './project-agent-paths.js';
+export * from './project-agent-profile.js';
+export * from './project-agent-quarantine.js';
+export * from './project-agent-roster.js';
+export * from './project-agent-skill-layer.js';
 export * from './role-skills.js';
 export * from './types.js';
 export { BUILD_AGENTS, DELIVERY_AGENTS, DISCOVERY_AGENTS, DOMAIN_AGENTS, KNOWLEDGE_AGENTS, META_AGENTS, PLANNING_AGENTS, REVIEW_AGENTS, VERIFY_AGENTS, WAVE1_AGENTS, WAVE2_AGENTS, WAVE3_AGENTS, WAVE4_AGENTS, };
@@ -53,5 +73,17 @@ export declare const AGENTS_BY_PHASE: {
 export declare const AGENT_CATALOG: Record<string, AgentDefinition>;
 /** Role lookup helper. Returns undefined for unknown roles. */
 export declare function getAgentDefinition(role: string): AgentDefinition | undefined;
+/**
+ * Role → dispatcher rationale, for every role that declares one.
+ *
+ * Derived from the catalog rather than hand-listed. There used to be four
+ * hand-maintained `WAVE*_ROLE_METAS` maps beside the agent arrays; nothing
+ * read them, and `WAVE2_ROLE_METAS` had drifted to carry six roles that live
+ * in `WAVE4_AGENTS` — a duplicate set no consumer would ever have noticed
+ * because the map itself was dead. Deriving from `AGENT_CATALOG` makes that
+ * class of drift impossible: a role is listed here exactly when its own
+ * `capability.rationale` is set.
+ */
+export declare const ROLE_DISPATCH_RATIONALE: Record<string, NonNullable<AgentCapability['rationale']>>;
 export { ROLE_SKILL_SETS, SHADOW_AGENT_SKILLS };
 //# sourceMappingURL=index.d.ts.map