@harness-engineering/intelligence 0.2.7 → 0.3.0

package/dist/index.js

@@ -35,16 +35,21 @@ __export(index_exports, {
   ExecutionOutcomeConnector: () => ExecutionOutcomeConnector,
   GraphValidator: () => GraphValidator,
   IntelligencePipeline: () => IntelligencePipeline,
+  OUTCOME_EVAL_SYSTEM_PROMPT: () => OUTCOME_EVAL_SYSTEM_PROMPT,
   OpenAICompatibleAnalysisProvider: () => OpenAICompatibleAnalysisProvider,
+  OutcomeEvaluator: () => OutcomeEvaluator,
   PeslSimulator: () => PeslSimulator,
   buildSpecializationProfile: () => buildSpecializationProfile,
+  buildUserPrompt: () => buildUserPrompt2,
   computeExpertiseLevel: () => computeExpertiseLevel,
   computeHistoricalComplexity: () => computeHistoricalComplexity,
   computePersonaEffectiveness: () => computePersonaEffectiveness,
   computeSemanticComplexity: () => computeSemanticComplexity,
   computeSpecialization: () => computeSpecialization,
   computeStructuralComplexity: () => computeStructuralComplexity,
+  createCanaryAdapter: () => createCanaryAdapter,
   decayWeight: () => decayWeight,
+  deriveAuthority: () => deriveAuthority,
   detectBlindSpots: () => detectBlindSpots,
   enrich: () => enrich,
   githubToRawWorkItem: () => githubToRawWorkItem,
@@ -54,6 +59,7 @@ __export(index_exports, {
   manualToRawWorkItem: () => manualToRawWorkItem,
   recommendPersona: () => recommendPersona,
   refreshProfiles: () => refreshProfiles,
+  resolveSection: () => resolveSection,
   runGraphOnlyChecks: () => runGraphOnlyChecks,
   runLlmSimulation: () => runLlmSimulation,
   saveProfiles: () => saveProfiles,
@@ -61,6 +67,7 @@ __export(index_exports, {
   scoreToConcernSignals: () => scoreToConcernSignals,
   temporalSuccessRate: () => temporalSuccessRate,
   toRawWorkItem: () => toRawWorkItem,
+  verdictSchema: () => verdictSchema,
   weightedRecommendPersona: () => weightedRecommendPersona
 });
 module.exports = __toCommonJS(index_exports);
@@ -173,6 +180,105 @@ function manualToRawWorkItem(input) {
   };
 }
 
+// src/adapters/canary.ts
+var import_zod = require("zod");
+var import_node_child_process = require("child_process");
+var frameworkRecommendationSchema = import_zod.z.object({
+  status: import_zod.z.string(),
+  test_type: import_zod.z.string(),
+  framework: import_zod.z.string(),
+  file_extension: import_zod.z.string(),
+  reasoning: import_zod.z.array(import_zod.z.string()),
+  alternatives: import_zod.z.array(import_zod.z.string())
+});
+var canaryFindingSchema = import_zod.z.object({
+  file: import_zod.z.string(),
+  line: import_zod.z.number(),
+  rule: import_zod.z.string(),
+  severity: import_zod.z.string(),
+  message: import_zod.z.string(),
+  suggestion: import_zod.z.string()
+});
+var canaryFindingsSchema = import_zod.z.array(canaryFindingSchema);
+var EXEC_TIMEOUT_MS = 3e4;
+var EXEC_MAX_BUFFER = 16 * 1024 * 1024;
+var defaultExec = (cmd, args) => new Promise((resolve, reject) => {
+  (0, import_node_child_process.execFile)(
+    cmd,
+    args,
+    { encoding: "utf8", timeout: EXEC_TIMEOUT_MS, maxBuffer: EXEC_MAX_BUFFER },
+    (err, stdout) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      resolve({ stdout });
+    }
+  );
+});
+function canaryInvocation(subArgs) {
+  return ["canary", subArgs];
+}
+function parseVersion(stdout) {
+  return stdout.match(/\d+\.\d+\.\d+/)?.[0];
+}
+function safeJson(stdout) {
+  try {
+    return JSON.parse(stdout);
+  } catch {
+    return void 0;
+  }
+}
+function degradedRecommendation() {
+  return {
+    status: "degraded",
+    test_type: "",
+    framework: "",
+    file_extension: "",
+    reasoning: [],
+    alternatives: []
+  };
+}
+function createCanaryAdapter(exec = defaultExec) {
+  async function execCanary(subArgs) {
+    const [cmd, args] = canaryInvocation(subArgs);
+    try {
+      const { stdout } = await exec(cmd, args);
+      return { ok: true, stdout };
+    } catch (err) {
+      const e = err;
+      if (e.code === "ENOENT") return { ok: false, reason: "not-installed" };
+      if (e.code === 1 && /canary binary not found/i.test(e.stderr ?? "")) {
+        return { ok: false, reason: "binary-missing" };
+      }
+      return { ok: false, reason: "exec-failed" };
+    }
+  }
+  let cachedProbe;
+  const probe = () => cachedProbe ??= (async () => {
+    const res = await execCanary(["version"]);
+    if (!res.ok) return { status: "degraded", reason: res.reason };
+    if (res.stdout.trim() === "") return { status: "degraded", reason: "bad-output" };
+    const version = parseVersion(res.stdout);
+    return version ? { status: "available", version } : { status: "available" };
+  })();
+  const recommendFramework = async (prompt) => {
+    const res = await execCanary(["recommend", prompt, "--json"]);
+    if (!res.ok) return degradedRecommendation();
+    const parsed = frameworkRecommendationSchema.safeParse(safeJson(res.stdout));
+    return parsed.success ? parsed.data : degradedRecommendation();
+  };
+  const reviewTest = async (path2, framework) => {
+    const args = ["review-test", path2, "--json"];
+    if (framework) args.push("--framework", framework);
+    const res = await execCanary(args);
+    if (!res.ok) return [];
+    const parsed = canaryFindingsSchema.safeParse(safeJson(res.stdout));
+    return parsed.success ? parsed.data : [];
+  };
+  return { probe, recommendFramework, reviewTest };
+}
+
 // src/analysis-provider/anthropic.ts
 var import_sdk = __toESM(require("@anthropic-ai/sdk"));
 
@@ -372,7 +478,7 @@ ${this.promptSuffix}` : request.prompt
 };
 
 // src/analysis-provider/claude-cli.ts
-var import_node_child_process = require("child_process");
+var import_node_child_process2 = require("child_process");
 var DEFAULT_TIMEOUT_MS2 = 18e4;
 var ClaudeCliAnalysisProvider = class {
   command;
@@ -418,7 +524,7 @@ ${request.prompt}` : request.prompt;
   }
   runClaude(args) {
     return new Promise((resolve, reject) => {
-      const child = (0, import_node_child_process.spawn)(this.command, args, {
+      const child = (0, import_node_child_process2.spawn)(this.command, args, {
         env: process.env,
         timeout: this.timeoutMs
       });
@@ -464,7 +570,7 @@ ${request.prompt}` : request.prompt;
 };
 
 // src/sel/prompts.ts
-var import_zod = require("zod");
+var import_zod2 = require("zod");
 var SEL_SYSTEM_PROMPT = `You are a spec enrichment agent. Your job is to analyze a work item (feature request, bug report, task, etc.) and produce structured output that captures the full engineering intent.
 
 Analyze the provided work item and extract:
@@ -528,22 +634,22 @@ ${metaEntries.map(([k, v]) => `- **${k}:** ${String(v)}`).join("\n")}`
   }
   return parts.join("\n");
 }
-var selResponseSchema = import_zod.z.object({
-  intent: import_zod.z.string(),
-  summary: import_zod.z.string(),
-  affectedSystems: import_zod.z.array(import_zod.z.object({ name: import_zod.z.string() })),
-  functionalRequirements: import_zod.z.array(import_zod.z.string()),
-  nonFunctionalRequirements: import_zod.z.array(import_zod.z.string()),
-  apiChanges: import_zod.z.array(import_zod.z.string()),
-  dbChanges: import_zod.z.array(import_zod.z.string()),
-  integrationPoints: import_zod.z.array(import_zod.z.string()),
-  assumptions: import_zod.z.array(import_zod.z.string()),
-  unknowns: import_zod.z.array(import_zod.z.string()),
-  ambiguities: import_zod.z.array(import_zod.z.string()),
-  riskSignals: import_zod.z.array(import_zod.z.string()),
-  initialComplexityHints: import_zod.z.object({
-    textualComplexity: import_zod.z.number().min(0).max(1),
-    structuralComplexity: import_zod.z.number().min(0).max(1)
+var selResponseSchema = import_zod2.z.object({
+  intent: import_zod2.z.string(),
+  summary: import_zod2.z.string(),
+  affectedSystems: import_zod2.z.array(import_zod2.z.object({ name: import_zod2.z.string() })),
+  functionalRequirements: import_zod2.z.array(import_zod2.z.string()),
+  nonFunctionalRequirements: import_zod2.z.array(import_zod2.z.string()),
+  apiChanges: import_zod2.z.array(import_zod2.z.string()),
+  dbChanges: import_zod2.z.array(import_zod2.z.string()),
+  integrationPoints: import_zod2.z.array(import_zod2.z.string()),
+  assumptions: import_zod2.z.array(import_zod2.z.string()),
+  unknowns: import_zod2.z.array(import_zod2.z.string()),
+  ambiguities: import_zod2.z.array(import_zod2.z.string()),
+  riskSignals: import_zod2.z.array(import_zod2.z.string()),
+  initialComplexityHints: import_zod2.z.object({
+    textualComplexity: import_zod2.z.number().min(0).max(1),
+    structuralComplexity: import_zod2.z.number().min(0).max(1)
   })
 });
 
@@ -917,7 +1023,7 @@ function runGraphOnlyChecks(spec, score2, store) {
 }
 
 // src/pesl/prompts.ts
-var import_zod2 = require("zod");
+var import_zod3 = require("zod");
 var PESL_SYSTEM_PROMPT = `You are a pre-execution simulation agent. Your job is to analyze an enriched specification and its complexity assessment, then simulate what would happen if an autonomous coding agent attempted to implement this change.
 
 Your simulation should:
@@ -929,13 +1035,13 @@ Your simulation should:
 Be realistic and specific. Reference actual system names from the spec. Err on the side of flagging potential issues -- it is better to over-predict failures than to miss them.
 
 Return your analysis using the structured_output tool.`;
-var peslResponseSchema = import_zod2.z.object({
-  simulatedPlan: import_zod2.z.array(import_zod2.z.string()).describe("Ordered implementation steps the agent would take"),
-  predictedFailures: import_zod2.z.array(import_zod2.z.string()).describe("Likely failure modes during implementation"),
-  riskHotspots: import_zod2.z.array(import_zod2.z.string()).describe("Files or modules that are high-risk change points"),
-  missingSteps: import_zod2.z.array(import_zod2.z.string()).describe("Steps the agent might miss or overlook"),
-  testGaps: import_zod2.z.array(import_zod2.z.string()).describe("Tests that should exist but likely do not"),
-  recommendedChanges: import_zod2.z.array(import_zod2.z.string()).describe("Adjustments to improve success likelihood")
+var peslResponseSchema = import_zod3.z.object({
+  simulatedPlan: import_zod3.z.array(import_zod3.z.string()).describe("Ordered implementation steps the agent would take"),
+  predictedFailures: import_zod3.z.array(import_zod3.z.string()).describe("Likely failure modes during implementation"),
+  riskHotspots: import_zod3.z.array(import_zod3.z.string()).describe("Files or modules that are high-risk change points"),
+  missingSteps: import_zod3.z.array(import_zod3.z.string()).describe("Steps the agent might miss or overlook"),
+  testGaps: import_zod3.z.array(import_zod3.z.string()).describe("Tests that should exist but likely do not"),
+  recommendedChanges: import_zod3.z.array(import_zod3.z.string()).describe("Adjustments to improve success likelihood")
 });
 function appendSection(parts, heading, items) {
   if (items.length === 0) return;
@@ -1073,6 +1179,30 @@ var PeslSimulator = class {
 };
 
 // src/outcome/connector.ts
+var RESERVED_METADATA_KEYS = /* @__PURE__ */ new Set([
+  "id",
+  "identifier",
+  "type",
+  "name",
+  "result",
+  "retryCount",
+  "failureReasons",
+  "durationMs",
+  "linkedSpecId",
+  "timestamp",
+  "issueId",
+  "agentPersona",
+  "taskType",
+  "affectedSystemNodeIds",
+  "edges"
+]);
+function stripReservedKeys(metadata) {
+  const safe = {};
+  for (const [key, value] of Object.entries(metadata)) {
+    if (!RESERVED_METADATA_KEYS.has(key)) safe[key] = value;
+  }
+  return safe;
+}
 var ExecutionOutcomeConnector = class {
   constructor(store) {
     this.store = store;
@@ -1085,6 +1215,11 @@ var ExecutionOutcomeConnector = class {
       type: "execution_outcome",
       name: `${outcome.result}: ${outcome.identifier}`,
       metadata: {
+        // Caller-supplied extras are STRIPPED of all reserved/core keys before
+        // merge, so they can never shadow a core field — even conditionally-
+        // written ones like agentPersona/taskType. Only genuinely additive
+        // keys (e.g. verdict/confidence/source) survive.
+        ...stripReservedKeys(outcome.metadata ?? {}),
         issueId: outcome.issueId,
         identifier: outcome.identifier,
         result: outcome.result,
@@ -1112,6 +1247,256 @@ var ExecutionOutcomeConnector = class {
   }
 };
 
+// src/outcome-eval/authority.ts
+function deriveAuthority(verdict, confidence) {
+  return verdict === "NOT_SATISFIED" && confidence === "high" ? "blocking" : "advisory";
+}
+
+// src/outcome-eval/prompts.ts
+var import_zod4 = require("zod");
+var verdictSchema = import_zod4.z.object({
+  verdict: import_zod4.z.enum(["SATISFIED", "NOT_SATISFIED", "INCONCLUSIVE"]).describe("Whether the change satisfies the judged spec section"),
+  confidence: import_zod4.z.enum(["low", "medium", "high"]).describe("Confidence in the verdict; high requires a named criterion"),
+  rationale: import_zod4.z.string().describe("Cites specific met / unmet criteria"),
+  unmetCriteria: import_zod4.z.array(import_zod4.z.string()).describe("Unmet criteria; empty when SATISFIED")
+}).strict();
+var OUTCOME_EVAL_SYSTEM_PROMPT = `You are a post-execution outcome judge. Given a spec acceptance section, a unified diff, and test output, decide whether the change SATISFIED, NOT_SATISFIED, or is INCONCLUSIVE against that section.
+
+Confidence calibration (be conservative \u2014 false alarms are costly):
+- Default to "medium" confidence.
+- Use "high" ONLY when you can name a SPECIFIC criterion from the section that the diff and test output clearly met or clearly failed to meet, and quote or paraphrase it in the rationale.
+- Use "low" when the diff or test output is ambiguous, partial, or insufficient to judge.
+- When the change only PARTIALLY meets the criteria, do not exceed "medium" confidence.
+- Bias toward advisory caution: if unsure between two confidence levels, choose the lower one.
+
+Rules:
+- The rationale MUST cite specific met or unmet criteria from the section.
+- "unmetCriteria" lists the section criteria the change failed to meet; it is empty when the verdict is SATISFIED.
+- Do NOT emit an "authority" field. Authority is computed downstream in TypeScript from (verdict, confidence) and must never come from you.
+
+Return your judgment using the structured_output tool.`;
+var PROMPT_FIELD_MAX_CHARS = 12e3;
+var FENCE = "````";
+function clampField(text) {
+  const trimmed = text.trim();
+  if (trimmed.length <= PROMPT_FIELD_MAX_CHARS) return trimmed;
+  const dropped = trimmed.length - PROMPT_FIELD_MAX_CHARS;
+  return `${trimmed.slice(0, PROMPT_FIELD_MAX_CHARS)}
+\u2026 [truncated ${dropped} chars]`;
+}
+function buildUserPrompt2(section, diff, testOutput) {
+  return [
+    "## Spec Acceptance Criteria (judge against this section)",
+    section.trim() || "(empty \u2014 treat as inconclusive)",
+    "",
+    "## Change Diff",
+    `${FENCE}diff`,
+    clampField(diff) || "(empty diff)",
+    FENCE,
+    "",
+    "## Test Output",
+    FENCE,
+    clampField(testOutput) || "(no test output captured)",
+    FENCE,
+    "",
+    "## Instructions",
+    "Judge whether the diff satisfies the acceptance criteria above. Calibrate confidence conservatively per your system instructions. Cite specific criteria in the rationale."
+  ].join("\n");
+}
+
+// src/outcome-eval/section-resolver.ts
+var CHAIN = [
+  { tag: "success-criteria", matches: (h) => h === "success criteria" },
+  { tag: "user-visible-behavior", matches: (h) => h === "user visible behavior" },
+  { tag: "overview", matches: (h) => h === "overview" }
+];
+var HEADING_RE = /^(#{1,6})\s+(.*\S)\s*$/;
+var FENCE_RE = /^\s*(```|~~~)/;
+var normalizeHeading = (text) => text.toLowerCase().replace(/-/g, " ").replace(/\s+/g, " ").trim();
+var parseHeading = (line, index) => {
+  const m = HEADING_RE.exec(line);
+  if (!m || m[1] === void 0 || m[2] === void 0) return null;
+  const normalized = normalizeHeading(m[2]);
+  const entry = CHAIN.find((c) => c.matches(normalized));
+  return { index, level: m[1].length, tag: entry ? entry.tag : null };
+};
+function resolveSection(markdown) {
+  const lines = markdown.split(/\r?\n/);
+  const headings = [];
+  let inFence = false;
+  lines.forEach((line, index) => {
+    if (FENCE_RE.test(line)) {
+      inFence = !inFence;
+      return;
+    }
+    if (inFence) return;
+    const heading = parseHeading(line, index);
+    if (heading) headings.push(heading);
+  });
+  for (const { tag } of CHAIN) {
+    const start = headings.find((h) => h.tag === tag);
+    if (!start) continue;
+    const next = headings.find((h) => h.index > start.index && h.level <= start.level);
+    const endExclusive = next ? next.index : lines.length;
+    const body = lines.slice(start.index + 1, endExclusive).join("\n").trim();
+    return { judgedAgainst: tag, body };
+  }
+  return null;
+}
+
+// src/outcome-eval/evaluator.ts
+var import_promises = require("fs/promises");
+var import_node_crypto2 = require("crypto");
+var OutcomeEvaluator = class {
+  provider;
+  store;
+  options;
+  constructor(provider, store, options = {}) {
+    this.provider = provider;
+    this.store = store;
+    this.options = options;
+  }
+  async evaluate(input) {
+    let resolved;
+    try {
+      resolved = await this.resolveJudgmentSection(input);
+    } catch {
+      return this.finish(this.degradedVerdict("overview"), input);
+    }
+    if (resolved === null) {
+      const verdict2 = this.buildVerdict(
+        "INCONCLUSIVE",
+        "low",
+        "No judgable spec section found.",
+        "overview",
+        []
+      );
+      return this.finish(verdict2, input);
+    }
+    const verdict = await this.judge(resolved, input);
+    return this.finish(verdict, input);
+  }
+  /**
+   * Run the provider call and strict re-parse. ANY failure here — provider
+   * rejection (rate limit/network), or a strict-parse rejection of a malformed
+   * or authority-injected payload — degrades safely to INCONCLUSIVE/low/
+   * advisory rather than throwing. This reconciles Criterion 3 (never block on
+   * noise) with Criterion 4: an injected `authority` key is discarded by the
+   * .strict() re-parse, and the degraded verdict's authority is DERIVED from
+   * INCONCLUSIVE/low = advisory — so the LLM gains nothing by injecting it.
+   */
+  async judge(resolved, input) {
+    try {
+      const response = await this.provider.analyze({
+        prompt: buildUserPrompt2(resolved.body, input.diff, input.testOutput),
+        systemPrompt: OUTCOME_EVAL_SYSTEM_PROMPT,
+        responseSchema: verdictSchema,
+        ...this.options.model !== void 0 && { model: this.options.model }
+      });
+      const llm = verdictSchema.parse(response.result);
+      return this.buildVerdict(
+        llm.verdict,
+        llm.confidence,
+        llm.rationale,
+        resolved.judgedAgainst,
+        llm.unmetCriteria
+      );
+    } catch {
+      return this.degradedVerdict(resolved.judgedAgainst);
+    }
+  }
+  /**
+   * Build the safe-degradation verdict. INCONCLUSIVE/low yields advisory
+   * authority via deriveAuthority — never blocking. The rationale names only a
+   * coarse reason category, never a stack trace or secret.
+   */
+  degradedVerdict(judgedAgainst) {
+    return this.buildVerdict(
+      "INCONCLUSIVE",
+      "low",
+      "Evaluation could not be completed; defaulting to an inconclusive, advisory verdict.",
+      judgedAgainst,
+      []
+    );
+  }
+  /** Persist (Phase 4 seam) then return the verdict. */
+  async finish(verdict, input) {
+    await this.persistOutcome(verdict, input);
+    return verdict;
+  }
+  async resolveJudgmentSection(input) {
+    if (input.specSection !== void 0) {
+      return input.specSection.trim() === "" ? null : { judgedAgainst: "success-criteria", body: input.specSection };
+    }
+    const markdown = await (0, import_promises.readFile)(input.specPath, "utf8");
+    return resolveSection(markdown);
+  }
+  buildVerdict(verdict, confidence, rationale, judgedAgainst, unmetCriteria) {
+    return {
+      verdict,
+      confidence,
+      rationale,
+      judgedAgainst,
+      unmetCriteria,
+      authority: deriveAuthority(verdict, confidence)
+    };
+  }
+  /**
+   * Map an OutcomeVerdict + OutcomeEvalInput to the connector's ExecutionOutcome.
+   * - result: SATISFIED -> 'success'; otherwise 'failure'. INCONCLUSIVE is
+   *   'failure' for type-validity but omits agentPersona/affected systems so
+   *   the effectiveness scorer ignores it (plan D2).
+   * - linkedSpecId: input.specPath (metadata only; no spec edge — plan D1).
+   * - affectedSystemNodeIds: [] in v1 (not available from OutcomeEvalInput — D4).
+   * - id: one node per EVALUATION. GraphStore.addNode upserts by id, so the id
+   *   carries a collision-free randomUUID() — two evaluate() calls in the same
+   *   millisecond can never overwrite each other (data-loss fix). specPath is
+   *   included for human readability only.
+   * - taskType: OMITTED. The outcome-eval judge has no task categorization, and
+   *   asserting a false 'feature' would mislead specialization analytics (SUG-2).
+   * - metadata: verdict-specific signal carried through the connector's
+   *   additive pass-through (verdict/confidence/judgedAgainst/source) so the
+   *   true 3-valued verdict is durable on the node (Truth 3).
+   */
+  toExecutionOutcome(verdict, input) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    return {
+      id: `outcome:outcome-eval:${input.specPath}:${(0, import_node_crypto2.randomUUID)()}`,
+      issueId: "outcome-eval",
+      identifier: `outcome-eval:${input.specPath}`,
+      result: verdict.verdict === "SATISFIED" ? "success" : "failure",
+      retryCount: 0,
+      failureReasons: verdict.unmetCriteria,
+      // 0 means "not applicable to outcome-eval" — the judge does not time work.
+      durationMs: 0,
+      linkedSpecId: input.specPath,
+      affectedSystemNodeIds: [],
+      timestamp,
+      metadata: {
+        verdict: verdict.verdict,
+        confidence: verdict.confidence,
+        judgedAgainst: verdict.judgedAgainst,
+        source: "outcome-eval"
+      }
+    };
+  }
+  /**
+   * Phase 4: writes exactly one execution_outcome node via
+   * ExecutionOutcomeConnector. Degrade-safe (plan D3): a graph-write failure is
+   * swallowed-and-logged, never thrown — the verdict is already computed before
+   * this runs, so swallowing keeps evaluate() total. No secrets/stack frames in
+   * the log message.
+   */
+  async persistOutcome(verdict, input) {
+    try {
+      const connector = new ExecutionOutcomeConnector(this.store);
+      connector.ingest(this.toExecutionOutcome(verdict, input));
+    } catch {
+      console.warn("[outcome-eval] execution_outcome persistence failed; verdict unaffected.");
+    }
+  }
+};
+
 // src/pipeline.ts
 var IntelligencePipeline = class {
   provider;
@@ -1589,16 +1974,21 @@ function refreshProfiles(projectRoot, graphStore, opts) {
   ExecutionOutcomeConnector,
   GraphValidator,
   IntelligencePipeline,
+  OUTCOME_EVAL_SYSTEM_PROMPT,
   OpenAICompatibleAnalysisProvider,
+  OutcomeEvaluator,
   PeslSimulator,
   buildSpecializationProfile,
+  buildUserPrompt,
   computeExpertiseLevel,
   computeHistoricalComplexity,
   computePersonaEffectiveness,
   computeSemanticComplexity,
   computeSpecialization,
   computeStructuralComplexity,
+  createCanaryAdapter,
   decayWeight,
+  deriveAuthority,
   detectBlindSpots,
   enrich,
   githubToRawWorkItem,
@@ -1608,6 +1998,7 @@ function refreshProfiles(projectRoot, graphStore, opts) {
   manualToRawWorkItem,
   recommendPersona,
   refreshProfiles,
+  resolveSection,
   runGraphOnlyChecks,
   runLlmSimulation,
   saveProfiles,
@@ -1615,5 +2006,6 @@ function refreshProfiles(projectRoot, graphStore, opts) {
   scoreToConcernSignals,
   temporalSuccessRate,
   toRawWorkItem,
+  verdictSchema,
   weightedRecommendPersona
 });