@harness-engineering/intelligence 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1520 @@
+// src/adapter.ts
+function toRawWorkItem(issue) {
+  return {
+    id: issue.id,
+    title: issue.title,
+    description: issue.description,
+    labels: issue.labels,
+    metadata: {
+      identifier: issue.identifier,
+      priority: issue.priority,
+      state: issue.state,
+      branchName: issue.branchName,
+      url: issue.url,
+      createdAt: issue.createdAt,
+      updatedAt: issue.updatedAt
+    },
+    linkedItems: issue.blockedBy.filter((b) => b.id != null).map((b) => b.id),
+    comments: [],
+    source: "roadmap"
+  };
+}
+
+// src/adapters/jira.ts
+function jiraToRawWorkItem(issue) {
+  const linkedItems = [];
+  for (const link of issue.fields.issuelinks) {
+    if (link.inwardIssue) linkedItems.push(link.inwardIssue.id);
+    if (link.outwardIssue) linkedItems.push(link.outwardIssue.id);
+  }
+  return {
+    id: issue.id,
+    title: issue.fields.summary,
+    description: issue.fields.description,
+    labels: issue.fields.labels,
+    metadata: {
+      key: issue.key,
+      priority: issue.fields.priority,
+      status: issue.fields.status,
+      issuetype: issue.fields.issuetype,
+      created: issue.fields.created,
+      updated: issue.fields.updated
+    },
+    linkedItems,
+    comments: issue.fields.comment.comments.map((c) => c.body),
+    source: "jira"
+  };
+}
+
+// src/adapters/github.ts
+function githubToRawWorkItem(issue) {
+  return {
+    id: String(issue.id),
+    title: issue.title,
+    description: issue.body,
+    labels: issue.labels.map((l) => l.name),
+    metadata: {
+      number: issue.number,
+      state: issue.state,
+      html_url: issue.html_url,
+      created_at: issue.created_at,
+      updated_at: issue.updated_at,
+      isPullRequest: issue.pull_request != null,
+      milestone: issue.milestone,
+      assignees: issue.assignees.map((a) => a.login)
+    },
+    linkedItems: issue.linked_issues.map(String),
+    comments: issue.comments_data.map((c) => c.body),
+    source: "github"
+  };
+}
+
+// src/adapters/linear.ts
+function linearToRawWorkItem(issue) {
+  return {
+    id: issue.id,
+    title: issue.title,
+    description: issue.description,
+    labels: issue.labels.nodes.map((l) => l.name),
+    metadata: {
+      identifier: issue.identifier,
+      priority: issue.priority,
+      state: issue.state,
+      url: issue.url,
+      branchName: issue.branchName,
+      createdAt: issue.createdAt,
+      updatedAt: issue.updatedAt
+    },
+    linkedItems: issue.relations.nodes.map((r) => r.relatedIssue.id),
+    comments: issue.comments.nodes.map((c) => c.body),
+    source: "linear"
+  };
+}
+
+// src/adapters/manual.ts
+import { randomUUID } from "crypto";
+function manualToRawWorkItem(input) {
+  return {
+    id: `manual-${randomUUID()}`,
+    title: input.title,
+    description: input.description ?? null,
+    labels: input.labels ?? [],
+    metadata: {},
+    linkedItems: [],
+    comments: [],
+    source: "manual"
+  };
+}
+
+// src/analysis-provider/anthropic.ts
+import Anthropic from "@anthropic-ai/sdk";
+
+// src/analysis-provider/schema.ts
+function convertObject(def) {
+  const shape = def["shape"]();
+  const properties = {};
+  const required = [];
+  for (const [key, value] of Object.entries(shape)) {
+    properties[key] = zodToJsonSchema(value);
+    const innerDef = value._def;
+    if (innerDef["typeName"] !== "ZodOptional") required.push(key);
+  }
+  const result = { type: "object", properties };
+  if (required.length > 0) result["required"] = required;
+  return result;
+}
+function convertNullable(def) {
+  const inner = zodToJsonSchema(def["innerType"]);
+  if (typeof inner["type"] === "string") return { ...inner, type: [inner["type"], "null"] };
+  return { oneOf: [inner, { type: "null" }] };
+}
+var ZOD_CONVERTERS = {
+  ZodString: () => ({ type: "string" }),
+  ZodNumber: () => ({ type: "number" }),
+  ZodBoolean: () => ({ type: "boolean" }),
+  ZodLiteral: (def) => ({ type: typeof def["value"], const: def["value"] }),
+  ZodEnum: (def) => ({ type: "string", enum: def["values"] }),
+  ZodNativeEnum: (def) => ({ enum: Object.values(def["values"]) }),
+  ZodArray: (def) => ({ type: "array", items: zodToJsonSchema(def["type"]) }),
+  ZodObject: convertObject,
+  ZodOptional: (def) => zodToJsonSchema(def["innerType"]),
+  ZodNullable: convertNullable,
+  ZodDefault: (def) => zodToJsonSchema(def["innerType"]),
+  ZodRecord: (def) => ({
+    type: "object",
+    additionalProperties: zodToJsonSchema(def["valueType"])
+  }),
+  ZodUnion: (def) => ({ oneOf: def["options"].map(zodToJsonSchema) })
+};
+function zodToJsonSchema(schema) {
+  const def = schema._def;
+  const typeName = def["typeName"];
+  const converter = typeName ? ZOD_CONVERTERS[typeName] : void 0;
+  return converter ? converter(def) : {};
+}
+
+// src/analysis-provider/anthropic.ts
+var DEFAULT_MODEL = "claude-sonnet-4-20250514";
+var DEFAULT_MAX_TOKENS = 4096;
+var AnthropicAnalysisProvider = class {
+  client;
+  defaultModel;
+  constructor(options) {
+    this.client = new Anthropic({ apiKey: options.apiKey });
+    this.defaultModel = options.defaultModel ?? DEFAULT_MODEL;
+  }
+  async analyze(request) {
+    const model = request.model ?? this.defaultModel;
+    const maxTokens = request.maxTokens ?? DEFAULT_MAX_TOKENS;
+    const jsonSchema = zodToJsonSchema(request.responseSchema);
+    const tool = {
+      name: "structured_output",
+      description: "Return the analysis result as structured JSON matching the required schema.",
+      input_schema: {
+        type: "object",
+        ...jsonSchema
+      }
+    };
+    const systemParts = [];
+    if (request.systemPrompt) {
+      systemParts.push(request.systemPrompt);
+    }
+    systemParts.push(
+      'You MUST respond by calling the "structured_output" tool with your result. Do not return plain text.'
+    );
+    const startMs = performance.now();
+    const response = await this.client.messages.create({
+      model,
+      max_tokens: maxTokens,
+      system: systemParts.join("\n\n"),
+      tools: [tool],
+      tool_choice: { type: "tool", name: "structured_output" },
+      messages: [{ role: "user", content: request.prompt }]
+    });
+    const latencyMs = Math.round(performance.now() - startMs);
+    const toolUseBlock = response.content.find(
+      (block) => block.type === "tool_use"
+    );
+    if (!toolUseBlock) {
+      throw new Error(
+        `Anthropic response did not contain a tool_use block. Stop reason: ${response.stop_reason}`
+      );
+    }
+    const result = request.responseSchema.parse(toolUseBlock.input);
+    const tokenUsage = {
+      inputTokens: response.usage.input_tokens,
+      outputTokens: response.usage.output_tokens,
+      totalTokens: response.usage.input_tokens + response.usage.output_tokens
+    };
+    return { result, tokenUsage, model, latencyMs };
+  }
+};
+
+// src/analysis-provider/openai-compatible.ts
+import OpenAI from "openai";
+var DEFAULT_MODEL2 = "deepseek-coder-v2";
+var DEFAULT_MAX_TOKENS2 = 8192;
+var DEFAULT_TIMEOUT_MS = 9e4;
+var OpenAICompatibleAnalysisProvider = class {
+  client;
+  defaultModel;
+  promptSuffix;
+  jsonMode;
+  constructor(options) {
+    this.client = new OpenAI({
+      apiKey: options.apiKey,
+      baseURL: options.baseUrl,
+      timeout: options.timeoutMs ?? DEFAULT_TIMEOUT_MS
+    });
+    this.defaultModel = options.defaultModel ?? DEFAULT_MODEL2;
+    this.promptSuffix = options.promptSuffix ?? null;
+    this.jsonMode = options.jsonMode ?? true;
+  }
+  async analyze(request) {
+    const model = request.model ?? this.defaultModel;
+    const maxTokens = request.maxTokens ?? DEFAULT_MAX_TOKENS2;
+    const jsonSchema = zodToJsonSchema(request.responseSchema);
+    const systemParts = [];
+    if (request.systemPrompt) systemParts.push(request.systemPrompt);
+    if (this.jsonMode) {
+      systemParts.push(
+        "Respond ONLY with the JSON object, no other text. Be concise \u2014 use short sentences in string fields and limit arrays to the most important items."
+      );
+    } else {
+      systemParts.push(
+        "You MUST respond with valid JSON matching this schema:\n" + JSON.stringify(jsonSchema, null, 2) + "\n\nRespond ONLY with the JSON object, no other text."
+      );
+    }
+    const startMs = performance.now();
+    const responseFormat = this.jsonMode ? {
+      type: "json_schema",
+      json_schema: { name: "analysis_response", strict: true, schema: jsonSchema }
+    } : void 0;
+    const response = await this.client.chat.completions.create({
+      model,
+      max_tokens: maxTokens,
+      ...responseFormat && { response_format: responseFormat },
+      messages: [
+        { role: "system", content: systemParts.join("\n\n") },
+        {
+          role: "user",
+          content: this.promptSuffix ? `${request.prompt}
+
+${this.promptSuffix}` : request.prompt
+        }
+      ]
+    });
+    const latencyMs = Math.round(performance.now() - startMs);
+    const choice = response.choices[0];
+    const content = choice?.message?.content;
+    if (!content) {
+      throw new Error(
+        `OpenAI-compatible response did not contain content. Finish reason: ${choice?.finish_reason}`
+      );
+    }
+    if (choice.finish_reason === "length") {
+      throw new Error(
+        `Response truncated at max_tokens (${maxTokens}). Increase max_tokens or simplify the request.`
+      );
+    }
+    const parsed = JSON.parse(content);
+    const result = request.responseSchema.parse(parsed);
+    const usage = response.usage;
+    const tokenUsage = {
+      inputTokens: usage?.prompt_tokens ?? 0,
+      outputTokens: usage?.completion_tokens ?? 0,
+      totalTokens: usage?.total_tokens ?? 0
+    };
+    return { result, tokenUsage, model, latencyMs };
+  }
+};
+
+// src/analysis-provider/claude-cli.ts
+import { spawn } from "child_process";
+var DEFAULT_TIMEOUT_MS2 = 18e4;
+var ClaudeCliAnalysisProvider = class {
+  command;
+  defaultModel;
+  timeoutMs;
+  constructor(options = {}) {
+    this.command = options.command ?? "claude";
+    this.defaultModel = options.defaultModel;
+    this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
+  }
+  async analyze(request) {
+    const model = request.model ?? this.defaultModel;
+    const jsonSchema = zodToJsonSchema(request.responseSchema);
+    const prompt = request.systemPrompt ? `${request.systemPrompt}
+
+${request.prompt}` : request.prompt;
+    const args = [
+      "--print",
+      "-p",
+      prompt,
+      "--output-format",
+      "json",
+      "--json-schema",
+      JSON.stringify({ type: "object", ...jsonSchema })
+    ];
+    if (model) {
+      args.push("--model", model);
+    }
+    const startMs = performance.now();
+    const result = await this.runClaude(args);
+    const latencyMs = Math.round(performance.now() - startMs);
+    const parsed = request.responseSchema.parse(result.content);
+    return {
+      result: parsed,
+      tokenUsage: {
+        inputTokens: result.usage?.input_tokens ?? 0,
+        outputTokens: result.usage?.output_tokens ?? 0,
+        totalTokens: (result.usage?.input_tokens ?? 0) + (result.usage?.output_tokens ?? 0)
+      },
+      model: result.model ?? model ?? "claude",
+      latencyMs
+    };
+  }
+  runClaude(args) {
+    return new Promise((resolve, reject) => {
+      const child = spawn(this.command, args, {
+        env: process.env,
+        timeout: this.timeoutMs
+      });
+      let stdout = "";
+      let stderr = "";
+      child.stdout.on("data", (chunk) => {
+        stdout += chunk.toString();
+      });
+      child.stderr.on("data", (chunk) => {
+        stderr += chunk.toString();
+      });
+      child.on("error", (err) => {
+        reject(new Error(`Claude CLI failed to spawn: ${err.message}`));
+      });
+      child.on("exit", (code) => {
+        if (code !== 0) {
+          reject(
+            new Error(`Claude CLI exited with code ${code}: ${stderr.trim() || stdout.trim()}`)
+          );
+          return;
+        }
+        try {
+          const parsed = JSON.parse(stdout);
+          const content = parsed.result ?? parsed;
+          resolve({
+            content: typeof content === "string" ? JSON.parse(content) : content,
+            usage: parsed.usage,
+            model: parsed.model
+          });
+        } catch (err) {
+          reject(
+            new Error(
+              `Failed to parse Claude CLI output: ${err instanceof Error ? err.message : String(err)}`
+            )
+          );
+        }
+      });
+      child.stdin.end();
+    });
+  }
+};
+
+// src/sel/prompts.ts
+import { z } from "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:
+1. **intent** \u2014 a single sentence capturing the core engineering goal.
+2. **summary** \u2014 a concise paragraph summarizing what needs to be done.
+3. **affectedSystems** \u2014 an array of system/module names that will be touched (each as {name: string}).
+4. **functionalRequirements** \u2014 concrete functional requirements implied by the work item.
+5. **nonFunctionalRequirements** \u2014 performance, scalability, security, or reliability concerns.
+6. **apiChanges** \u2014 any API surface changes (new endpoints, changed contracts, etc.).
+7. **dbChanges** \u2014 any database schema or migration changes.
+8. **integrationPoints** \u2014 external systems or services this work integrates with.
+9. **assumptions** \u2014 assumptions you are making about the scope or context.
+10. **unknowns** \u2014 things that are unclear and may need clarification.
+11. **ambiguities** \u2014 parts of the spec that could be interpreted multiple ways.
+12. **riskSignals** \u2014 potential risks (technical debt, breaking changes, security concerns, etc.).
+13. **initialComplexityHints** \u2014 an object with two 0-1 scores:
+    - textualComplexity: how complex the requirement text itself is (0 = trivial, 1 = extremely dense).
+    - structuralComplexity: how many systems/layers are involved (0 = single module, 1 = cross-cutting).
+
+Be thorough but concise. If information is missing or the description is empty, infer what you can from the title and labels, and note gaps in unknowns/ambiguities.
+
+Return your analysis using the structured_output tool.`;
+function buildUserPrompt(item) {
+  const parts = [];
+  parts.push(`## Work Item: ${item.title}`);
+  parts.push(`**ID:** ${item.id}`);
+  parts.push(`**Source:** ${item.source}`);
+  if (item.description) {
+    parts.push(`
+### Description
+${item.description}`);
+  } else {
+    parts.push(`
+### Description
+_No description provided._`);
+  }
+  if (item.labels.length > 0) {
+    parts.push(`
+### Labels
+${item.labels.join(", ")}`);
+  }
+  if (item.linkedItems.length > 0) {
+    parts.push(`
+### Linked Items
+${item.linkedItems.join(", ")}`);
+  }
+  if (item.comments.length > 0) {
+    parts.push(`
+### Comments
+${item.comments.join("\n\n")}`);
+  }
+  const metaEntries = Object.entries(item.metadata).filter(
+    ([, v]) => v !== void 0 && v !== null
+  );
+  if (metaEntries.length > 0) {
+    parts.push(
+      `
+### Metadata
+${metaEntries.map(([k, v]) => `- **${k}:** ${String(v)}`).join("\n")}`
+    );
+  }
+  return parts.join("\n");
+}
+var selResponseSchema = z.object({
+  intent: z.string(),
+  summary: z.string(),
+  affectedSystems: z.array(z.object({ name: z.string() })),
+  functionalRequirements: z.array(z.string()),
+  nonFunctionalRequirements: z.array(z.string()),
+  apiChanges: z.array(z.string()),
+  dbChanges: z.array(z.string()),
+  integrationPoints: z.array(z.string()),
+  assumptions: z.array(z.string()),
+  unknowns: z.array(z.string()),
+  ambiguities: z.array(z.string()),
+  riskSignals: z.array(z.string()),
+  initialComplexityHints: z.object({
+    textualComplexity: z.number().min(0).max(1),
+    structuralComplexity: z.number().min(0).max(1)
+  })
+});
+
+// src/sel/enricher.ts
+async function enrich(item, provider, graphValidator) {
+  const response = await provider.analyze({
+    prompt: buildUserPrompt(item),
+    systemPrompt: SEL_SYSTEM_PROMPT,
+    responseSchema: selResponseSchema
+  });
+  const llmResult = response.result;
+  const affectedSystems = graphValidator.validate(llmResult.affectedSystems);
+  return {
+    id: item.id,
+    title: item.title,
+    intent: llmResult.intent,
+    summary: llmResult.summary,
+    affectedSystems,
+    functionalRequirements: llmResult.functionalRequirements,
+    nonFunctionalRequirements: llmResult.nonFunctionalRequirements,
+    apiChanges: llmResult.apiChanges,
+    dbChanges: llmResult.dbChanges,
+    integrationPoints: llmResult.integrationPoints,
+    assumptions: llmResult.assumptions,
+    unknowns: llmResult.unknowns,
+    ambiguities: llmResult.ambiguities,
+    riskSignals: llmResult.riskSignals,
+    initialComplexityHints: llmResult.initialComplexityHints
+  };
+}
+
+// src/sel/graph-validator.ts
+import { CascadeSimulator } from "@harness-engineering/graph";
+var GraphValidator = class {
+  store;
+  cachedModuleNodes = null;
+  cachedFileNodes = null;
+  constructor(store) {
+    this.store = store;
+  }
+  /**
+   * Validate and enrich a list of affected system names against the graph.
+   */
+  validate(systems) {
+    this.cachedModuleNodes = this.store.findNodes({ type: "module" });
+    this.cachedFileNodes = this.store.findNodes({ type: "file" });
+    const result = systems.map((system) => this.resolveSystem(system.name));
+    this.cachedModuleNodes = null;
+    this.cachedFileNodes = null;
+    return result;
+  }
+  resolveSystem(name) {
+    const moduleNodes = this.cachedModuleNodes ?? this.store.findNodes({ type: "module" });
+    const fileNodes = this.cachedFileNodes ?? this.store.findNodes({ type: "file" });
+    const candidates = [...moduleNodes, ...fileNodes];
+    const normalizedName = name.toLowerCase().replace(/[^a-z0-9]/g, "");
+    let bestMatch = null;
+    for (const node of candidates) {
+      const normalizedNodeName = node.name.toLowerCase().replace(/[^a-z0-9]/g, "");
+      const score2 = this.fuzzyScore(normalizedName, normalizedNodeName);
+      if (score2 > 0 && (!bestMatch || score2 > bestMatch.score)) {
+        bestMatch = { id: node.id, name: node.name, score: score2 };
+      }
+    }
+    if (!bestMatch || bestMatch.score < 0.4) {
+      return {
+        name,
+        graphNodeId: null,
+        confidence: 0,
+        transitiveDeps: [],
+        testCoverage: 0,
+        owner: null
+      };
+    }
+    const transitiveDeps = this.resolveTransitiveDeps(bestMatch.id);
+    const testCoverage = this.resolveTestCoverage(bestMatch.id);
+    const owner = this.resolveOwner(bestMatch.id);
+    return {
+      name,
+      graphNodeId: bestMatch.id,
+      confidence: bestMatch.score,
+      transitiveDeps,
+      testCoverage,
+      owner
+    };
+  }
+  /**
+   * Simple fuzzy scoring: exact match = 1, contains = 0.7, substring overlap.
+   */
+  fuzzyScore(query, candidate) {
+    if (query === candidate) return 1;
+    if (candidate.includes(query)) return 0.8;
+    if (query.includes(candidate)) return 0.7;
+    const shorter = query.length < candidate.length ? query : candidate;
+    const longer = query.length < candidate.length ? candidate : query;
+    let matches = 0;
+    for (let i = 0; i <= longer.length - shorter.length; i++) {
+      let current = 0;
+      for (let j = 0; j < shorter.length && i + j < longer.length; j++) {
+        if (shorter[j] === longer[i + j]) current++;
+      }
+      matches = Math.max(matches, current);
+    }
+    return shorter.length > 0 ? matches / longer.length : 0;
+  }
+  resolveTransitiveDeps(nodeId) {
+    try {
+      const simulator = new CascadeSimulator(this.store);
+      const result = simulator.simulate(nodeId, {
+        maxDepth: 3,
+        probabilityFloor: 0.1
+      });
+      return result.flatSummary.map((n) => n.nodeId);
+    } catch {
+      return [];
+    }
+  }
+  resolveTestCoverage(nodeId) {
+    const testedByEdges = this.store.getEdges({ from: nodeId, type: "tested_by" });
+    const verifiedByEdges = this.store.getEdges({ from: nodeId, type: "verified_by" });
+    return testedByEdges.length + verifiedByEdges.length;
+  }
+  resolveOwner(nodeId) {
+    const node = this.store.getNode(nodeId);
+    if (!node) return null;
+    const owner = node.metadata?.["owner"];
+    return typeof owner === "string" ? owner : null;
+  }
+};
+
+// src/cml/structural.ts
+import { CascadeSimulator as CascadeSimulator2 } from "@harness-engineering/graph";
+var NORMALIZATION_CEILING = 100;
+function computeStructuralComplexity(spec, store) {
+  const emptyResult = {
+    score: 0,
+    blastRadius: { services: 0, modules: 0, filesEstimated: 0, testFilesAffected: 0 }
+  };
+  const systemsWithGraph = spec.affectedSystems.filter((s) => s.graphNodeId !== null);
+  if (systemsWithGraph.length === 0) {
+    return emptyResult;
+  }
+  const simulator = new CascadeSimulator2(store);
+  let weightedTotal = 0;
+  const seenServices = /* @__PURE__ */ new Set();
+  const seenModules = /* @__PURE__ */ new Set();
+  let totalFiles = 0;
+  let totalTestFiles = 0;
+  for (const system of systemsWithGraph) {
+    let cascadeResult;
+    try {
+      cascadeResult = simulator.simulate(system.graphNodeId);
+    } catch {
+      continue;
+    }
+    for (const node of cascadeResult.flatSummary) {
+      weightedTotal += node.cumulativeProbability;
+    }
+    const { categoryBreakdown } = cascadeResult.summary;
+    totalFiles += categoryBreakdown.code;
+    totalTestFiles += categoryBreakdown.tests;
+    for (const node of cascadeResult.flatSummary) {
+      if (node.type === "repository") {
+        seenServices.add(node.nodeId);
+      }
+      if (node.type === "module") {
+        seenModules.add(node.nodeId);
+      }
+    }
+  }
+  const score2 = Math.min(weightedTotal / NORMALIZATION_CEILING, 1);
+  return {
+    score: score2,
+    blastRadius: {
+      services: seenServices.size,
+      modules: seenModules.size,
+      filesEstimated: totalFiles,
+      testFilesAffected: totalTestFiles
+    }
+  };
+}
+
+// src/cml/semantic.ts
+var W_UNKNOWNS = 0.4;
+var W_AMBIGUITIES = 0.35;
+var W_RISK_SIGNALS = 0.25;
+var DECAY = 0.3;
+function computeSemanticComplexity(spec) {
+  const unknownsScore = 1 - Math.exp(-spec.unknowns.length * DECAY);
+  const ambiguitiesScore = 1 - Math.exp(-spec.ambiguities.length * DECAY);
+  const riskSignalsScore = 1 - Math.exp(-spec.riskSignals.length * DECAY);
+  const raw = unknownsScore * W_UNKNOWNS + ambiguitiesScore * W_AMBIGUITIES + riskSignalsScore * W_RISK_SIGNALS;
+  return Math.max(0, Math.min(1, raw));
+}
+
+// src/cml/historical.ts
+var SMOOTHING = 2;
+function countOutcomesForSystem(store, systemNodeId) {
+  const edges = store.getEdges({ to: systemNodeId, type: "outcome_of" });
+  let failures = 0;
+  let successes = 0;
+  for (const edge of edges) {
+    const outcomeNode = store.getNode(edge.from);
+    if (!outcomeNode || outcomeNode.type !== "execution_outcome") continue;
+    if (outcomeNode.metadata.result === "failure") {
+      failures++;
+    } else if (outcomeNode.metadata.result === "success") {
+      successes++;
+    }
+  }
+  return { failures, successes };
+}
+function computeFailureRate(counts) {
+  const total = counts.failures + counts.successes;
+  if (total === 0) return 0;
+  return counts.failures / (total + SMOOTHING);
+}
+function computeHistoricalComplexity(spec, store) {
+  const systemsWithGraph = spec.affectedSystems.filter((s) => s.graphNodeId !== null);
+  if (systemsWithGraph.length === 0) return 0;
+  let maxFailureRate = 0;
+  for (const system of systemsWithGraph) {
+    const counts = countOutcomesForSystem(store, system.graphNodeId);
+    const rate = computeFailureRate(counts);
+    if (rate > maxFailureRate) {
+      maxFailureRate = rate;
+    }
+  }
+  return Math.max(0, Math.min(1, maxFailureRate));
+}
+
+// src/cml/scorer.ts
+var W_STRUCTURAL = 0.5;
+var W_SEMANTIC = 0.35;
+var W_HISTORICAL = 0.15;
+function computeConfidence(structuralScore, semanticScore, historicalScore) {
+  const hasStructural = structuralScore > 0;
+  const hasSemantic = semanticScore > 0;
+  const hasHistorical = historicalScore > 0;
+  const dataSourceCount = (hasStructural ? 1 : 0) + (hasSemantic ? 1 : 0) + (hasHistorical ? 1 : 0);
+  if (dataSourceCount >= 2) return 0.8;
+  if (dataSourceCount === 1) return 0.5;
+  return 0.3;
+}
+function classifyRiskLevel(overall) {
+  if (overall >= 0.8) return "critical";
+  if (overall >= 0.6) return "high";
+  if (overall >= 0.3) return "medium";
+  return "low";
+}
+function determineRoute(riskLevel, semantic) {
+  if (riskLevel === "low") return "local";
+  if (riskLevel === "medium" && semantic < 0.5) return "local";
+  if (riskLevel === "high" || riskLevel === "critical") return "human";
+  return "simulation-required";
+}
+function score(spec, store) {
+  const structural = computeStructuralComplexity(spec, store);
+  const semantic = computeSemanticComplexity(spec);
+  const historical = computeHistoricalComplexity(spec, store);
+  const overall = structural.score * W_STRUCTURAL + semantic * W_SEMANTIC + historical * W_HISTORICAL;
+  const confidence = computeConfidence(structural.score, semantic, historical);
+  const riskLevel = classifyRiskLevel(overall);
+  const recommendedRoute = determineRoute(riskLevel, semantic);
+  const reasoning = [
+    `Structural complexity: ${structural.score.toFixed(2)} (${structural.blastRadius.filesEstimated} files, ${structural.blastRadius.services} services, ${structural.blastRadius.modules} modules affected)`,
+    `Semantic complexity: ${semantic.toFixed(2)} (${spec.unknowns.length} unknowns, ${spec.ambiguities.length} ambiguities, ${spec.riskSignals.length} risk signals)`,
+    `Historical complexity: ${historical.toFixed(2)} (from past execution outcomes)`,
+    `Overall: ${overall.toFixed(2)} \u2192 risk level "${riskLevel}", recommended route "${recommendedRoute}"`
+  ];
+  return {
+    overall,
+    confidence,
+    riskLevel,
+    blastRadius: structural.blastRadius,
+    dimensions: { structural: structural.score, semantic, historical },
+    reasoning,
+    recommendedRoute
+  };
+}
+
+// src/cml/signals.ts
+function scoreToConcernSignals(score2) {
+  const signals = [];
+  if (score2.overall >= 0.7) {
+    signals.push({
+      name: "highComplexity",
+      reason: score2.reasoning.join("; ")
+    });
+  }
+  if (score2.blastRadius.filesEstimated > 20) {
+    signals.push({
+      name: "largeBlastRadius",
+      reason: `${score2.blastRadius.filesEstimated} files estimated to be affected`
+    });
+  }
+  if (score2.dimensions.semantic > 0.6) {
+    signals.push({
+      name: "highAmbiguity",
+      reason: "Significant unknowns or ambiguities in spec"
+    });
+  }
+  return signals;
+}
+
+// src/pesl/graph-checks.ts
+import { CascadeSimulator as CascadeSimulator3, groupNodesByImpact } from "@harness-engineering/graph";
+var BASE_CONFIDENCE = 0.85;
+var HOTSPOT_PENALTY = 0.05;
+var TEST_GAP_PENALTY = 0.08;
+var FAILURE_PENALTY = 0.1;
+function runGraphOnlyChecks(spec, score2, store) {
+  const riskHotspots = [];
+  const predictedFailures = [];
+  const testGaps = [];
+  const recommendedChanges = [];
+  const systemsWithGraph = spec.affectedSystems.filter((s) => s.graphNodeId !== null);
+  const simulator = new CascadeSimulator3(store);
+  for (const system of systemsWithGraph) {
+    let cascadeResult;
+    try {
+      cascadeResult = simulator.simulate(system.graphNodeId);
+    } catch {
+      continue;
+    }
+    for (const nodeId of cascadeResult.summary.amplificationPoints) {
+      const node = store.getNode(nodeId);
+      riskHotspots.push(node ? `${node.name} (high fan-out)` : `${nodeId} (high fan-out)`);
+    }
+    const highRiskNodes = cascadeResult.flatSummary.filter((n) => n.cumulativeProbability >= 0.5);
+    if (highRiskNodes.length > 5) {
+      predictedFailures.push(
+        `${system.name}: cascade affects ${highRiskNodes.length} high-probability nodes`
+      );
+    }
+    const affectedNodes = cascadeResult.flatSummary.map((n) => store.getNode(n.nodeId)).filter((n) => n !== void 0);
+    const groups = groupNodesByImpact(affectedNodes);
+    if (groups.code.length > 0 && groups.tests.length === 0) {
+      recommendedChanges.push(`${system.name}: affected code has no test coverage in cascade path`);
+    }
+  }
+  for (const system of spec.affectedSystems) {
+    if (system.testCoverage === 0) {
+      testGaps.push(`${system.name}: no test coverage detected`);
+    }
+  }
+  if (score2.blastRadius.filesEstimated > 10 && score2.blastRadius.testFilesAffected === 0) {
+    testGaps.push(
+      `Blast radius covers ${score2.blastRadius.filesEstimated} files but no test files are affected`
+    );
+  }
+  let confidence = BASE_CONFIDENCE;
+  confidence -= riskHotspots.length * HOTSPOT_PENALTY;
+  confidence -= testGaps.length * TEST_GAP_PENALTY;
+  confidence -= predictedFailures.length * FAILURE_PENALTY;
+  confidence -= score2.overall * 0.2;
+  confidence = Math.max(0, Math.min(1, confidence));
+  return {
+    simulatedPlan: [],
+    // Graph-only checks do not produce a plan
+    predictedFailures,
+    riskHotspots,
+    missingSteps: [],
+    // Graph-only checks do not produce missing steps
+    testGaps,
+    executionConfidence: confidence,
+    recommendedChanges,
+    abort: confidence < 0.3,
+    tier: "graph-only"
+  };
+}
+
+// src/pesl/prompts.ts
+import { z as z2 } from "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:
+1. **Plan expansion** -- Break the spec into concrete implementation steps a coding agent would take.
+2. **Dependency simulation** -- For each step, identify what files, modules, or services would be touched and what dependencies exist between steps.
+3. **Failure injection** -- Predict likely failure modes: type errors, missing imports, test regressions, breaking API changes, race conditions, etc.
+4. **Test projection** -- Identify what tests should exist but don't, and what existing tests are likely to break.
+
+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 = z2.object({
+  simulatedPlan: z2.array(z2.string()).describe("Ordered implementation steps the agent would take"),
+  predictedFailures: z2.array(z2.string()).describe("Likely failure modes during implementation"),
+  riskHotspots: z2.array(z2.string()).describe("Files or modules that are high-risk change points"),
+  missingSteps: z2.array(z2.string()).describe("Steps the agent might miss or overlook"),
+  testGaps: z2.array(z2.string()).describe("Tests that should exist but likely do not"),
+  recommendedChanges: z2.array(z2.string()).describe("Adjustments to improve success likelihood")
+});
+function appendSection(parts, heading, items) {
+  if (items.length === 0) return;
+  parts.push(`
+### ${heading}`);
+  for (const item of items) {
+    parts.push(`- ${item}`);
+  }
+}
+function buildAffectedSystems(spec) {
+  const lines = [`
+### Affected Systems`];
+  for (const system of spec.affectedSystems) {
+    const graphStatus = system.graphNodeId ? `(graph-resolved: ${system.graphNodeId})` : "(not in graph)";
+    lines.push(
+      `- **${system.name}** ${graphStatus} -- confidence: ${system.confidence}, deps: ${system.transitiveDeps.length}, test coverage: ${system.testCoverage}`
+    );
+  }
+  return lines;
+}
+function buildComplexitySection(score2) {
+  const lines = [
+    `
+### Complexity Assessment`,
+    `- **Overall:** ${score2.overall.toFixed(2)} (risk: ${score2.riskLevel})`,
+    `- **Blast radius:** ${score2.blastRadius.filesEstimated} files, ${score2.blastRadius.modules} modules, ${score2.blastRadius.services} services`,
+    `- **Structural:** ${score2.dimensions.structural.toFixed(2)}`,
+    `- **Semantic:** ${score2.dimensions.semantic.toFixed(2)}`
+  ];
+  for (const reason of score2.reasoning) {
+    lines.push(`- ${reason}`);
+  }
+  return lines;
+}
+function buildPeslPrompt(spec, score2) {
+  const parts = [
+    `## Enriched Specification: ${spec.title}`,
+    `**Intent:** ${spec.intent}`,
+    `**Summary:** ${spec.summary}`
+  ];
+  parts.push(...buildAffectedSystems(spec));
+  appendSection(parts, "Functional Requirements", spec.functionalRequirements);
+  appendSection(parts, "Non-Functional Requirements", spec.nonFunctionalRequirements);
+  appendSection(parts, "API Changes", spec.apiChanges);
+  appendSection(parts, "Database Changes", spec.dbChanges);
+  appendSection(parts, "Integration Points", spec.integrationPoints);
+  appendSection(parts, "Unknowns", spec.unknowns);
+  appendSection(parts, "Ambiguities", spec.ambiguities);
+  appendSection(parts, "Risk Signals", spec.riskSignals);
+  parts.push(...buildComplexitySection(score2));
+  parts.push(`
+### Instructions`);
+  parts.push(
+    `Simulate implementation of this spec by an autonomous coding agent. Produce a step-by-step plan, predict failures, identify risk hotspots, flag missing steps, and project test gaps.`
+  );
+  return parts.join("\n");
+}
+
+// src/pesl/llm-simulation.ts
+var BASE_CONFIDENCE2 = 0.75;
+var FAILURE_PENALTY2 = 0.06;
+var TEST_GAP_PENALTY2 = 0.05;
+var MISSING_STEP_PENALTY = 0.04;
+var COMPLEXITY_PENALTY_FACTOR = 0.15;
+async function runLlmSimulation(spec, score2, store, provider, model) {
+  const graphResult = runGraphOnlyChecks(spec, score2, store);
+  const response = await provider.analyze({
+    prompt: buildPeslPrompt(spec, score2),
+    systemPrompt: PESL_SYSTEM_PROMPT,
+    responseSchema: peslResponseSchema,
+    ...model !== void 0 && { model }
+  });
+  const llm = response.result;
+  const riskHotspots = dedup([...graphResult.riskHotspots, ...llm.riskHotspots]);
+  const predictedFailures = dedup([...graphResult.predictedFailures, ...llm.predictedFailures]);
+  const testGaps = dedup([...graphResult.testGaps, ...llm.testGaps]);
+  const recommendedChanges = dedup([...graphResult.recommendedChanges, ...llm.recommendedChanges]);
+  let confidence = BASE_CONFIDENCE2;
+  confidence -= predictedFailures.length * FAILURE_PENALTY2;
+  confidence -= testGaps.length * TEST_GAP_PENALTY2;
+  confidence -= llm.missingSteps.length * MISSING_STEP_PENALTY;
+  confidence -= score2.overall * COMPLEXITY_PENALTY_FACTOR;
+  confidence = Math.max(0, Math.min(1, confidence));
+  return {
+    simulatedPlan: llm.simulatedPlan,
+    predictedFailures,
+    riskHotspots,
+    missingSteps: llm.missingSteps,
+    testGaps,
+    executionConfidence: confidence,
+    recommendedChanges,
+    abort: confidence < 0.3,
+    tier: "full-simulation"
+  };
+}
+function dedup(items) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const item of items) {
+    const key = item.toLowerCase();
+    if (!seen.has(key)) {
+      seen.add(key);
+      result.push(item);
+    }
+  }
+  return result;
+}
+
+// src/pesl/simulator.ts
+var GRAPH_ONLY_TIERS = /* @__PURE__ */ new Set(["quick-fix", "diagnostic"]);
+var PeslSimulator = class {
+  provider;
+  store;
+  options;
+  constructor(provider, store, options = {}) {
+    this.provider = provider;
+    this.store = store;
+    this.options = options;
+  }
+  /**
+   * Run pre-execution simulation for a spec.
+   *
+   * @param spec - Enriched spec from SEL
+   * @param score - Complexity score from CML
+   * @param tier - Scope tier of the issue
+   * @returns SimulationResult with tier, confidence, and abort recommendation
+   */
+  async simulate(spec, score2, tier) {
+    const needsFullSimulation = score2.recommendedRoute === "simulation-required" || !GRAPH_ONLY_TIERS.has(tier);
+    if (needsFullSimulation) {
+      return runLlmSimulation(spec, score2, this.store, this.provider, this.options.model);
+    }
+    return runGraphOnlyChecks(spec, score2, this.store);
+  }
+};
+
+// src/outcome/connector.ts
+var ExecutionOutcomeConnector = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  ingest(outcome) {
+    const errors = [];
+    this.store.addNode({
+      id: outcome.id,
+      type: "execution_outcome",
+      name: `${outcome.result}: ${outcome.identifier}`,
+      metadata: {
+        issueId: outcome.issueId,
+        identifier: outcome.identifier,
+        result: outcome.result,
+        retryCount: outcome.retryCount,
+        failureReasons: outcome.failureReasons,
+        durationMs: outcome.durationMs,
+        linkedSpecId: outcome.linkedSpecId,
+        timestamp: outcome.timestamp,
+        ...outcome.agentPersona !== void 0 && { agentPersona: outcome.agentPersona },
+        ...outcome.taskType !== void 0 && { taskType: outcome.taskType }
+      }
+    });
+    let edgesAdded = 0;
+    for (const systemNodeId of outcome.affectedSystemNodeIds) {
+      const systemNode = this.store.getNode(systemNodeId);
+      if (!systemNode) continue;
+      this.store.addEdge({
+        from: outcome.id,
+        to: systemNodeId,
+        type: "outcome_of"
+      });
+      edgesAdded++;
+    }
+    return { nodesAdded: 1, edgesAdded, errors };
+  }
+};
+
+// src/pipeline.ts
+var IntelligencePipeline = class {
+  provider;
+  graphValidator;
+  store;
+  simulator;
+  outcomeConnector;
+  constructor(provider, store, options) {
+    this.provider = provider;
+    this.store = store;
+    this.graphValidator = new GraphValidator(store);
+    this.simulator = new PeslSimulator(provider, store, {
+      ...options?.peslModel !== void 0 && { model: options.peslModel }
+    });
+    this.outcomeConnector = new ExecutionOutcomeConnector(store);
+  }
+  /**
+   * Enrich a raw work item into an EnrichedSpec via LLM + graph validation.
+   */
+  async enrich(item) {
+    return enrich(item, this.provider, this.graphValidator);
+  }
+  /**
+   * Score an enriched spec using graph-based structural + semantic analysis.
+   * Synchronous — no LLM calls.
+   */
+  score(spec) {
+    return score(spec, this.store);
+  }
+  /**
+   * Run pre-execution simulation for a spec.
+   */
+  async simulate(spec, score2, tier = "guided-change") {
+    return this.simulator.simulate(spec, score2, tier);
+  }
+  /**
+   * Record an execution outcome in the knowledge graph.
+   * Called by the orchestrator after a worker exits.
+   */
+  recordOutcome(outcome) {
+    return this.outcomeConnector.ingest(outcome);
+  }
+  /**
+   * Preprocess an issue through the intelligence pipeline.
+   *
+   * Behavior depends on which escalation tier the issue's scope falls into:
+   * - `autoExecute`: returns immediately with null spec/score and empty signals
+   * - `alwaysHuman`: runs SEL for enrichment context (human gets pre-analyzed view),
+   *   skips CML, returns empty signals (routing stays needs-human)
+   * - `signalGated`: runs full SEL → CML → signals pipeline
+   */
+  async preprocessIssue(issue, scopeTier, escalationConfig) {
+    if (escalationConfig.autoExecute.includes(scopeTier)) {
+      return { spec: null, score: null, signals: [] };
+    }
+    const workItem = toRawWorkItem(issue);
+    const spec = await this.enrich(workItem);
+    const complexityScore = this.score(spec);
+    if (escalationConfig.alwaysHuman.includes(scopeTier)) {
+      return { spec, score: complexityScore, signals: [] };
+    }
+    const signals = scoreToConcernSignals(complexityScore);
+    return { spec, score: complexityScore, signals };
+  }
+};
+
+// src/effectiveness/scorer.ts
+var LAPLACE_ALPHA = 1;
+var NEUTRAL_PRIOR = 0.5;
+var DEFAULT_MIN_FAILURES = 2;
+var DEFAULT_MIN_FAILURE_RATE = 0.5;
+function bucket(map, persona, systemNodeId, result) {
+  let perPersona = map.get(persona);
+  if (!perPersona) {
+    perPersona = /* @__PURE__ */ new Map();
+    map.set(persona, perPersona);
+  }
+  let counts = perPersona.get(systemNodeId);
+  if (!counts) {
+    counts = { successes: 0, failures: 0 };
+    perPersona.set(systemNodeId, counts);
+  }
+  if (result === "success") counts.successes += 1;
+  else if (result === "failure") counts.failures += 1;
+}
+function gatherOutcomes(store) {
+  const map = /* @__PURE__ */ new Map();
+  const nodes = store.findNodes({ type: "execution_outcome" });
+  for (const node of nodes) {
+    const persona = node.metadata.agentPersona;
+    if (typeof persona !== "string" || persona.length === 0) continue;
+    const result = node.metadata.result;
+    if (result !== "success" && result !== "failure") continue;
+    const edges = store.getEdges({ from: node.id, type: "outcome_of" });
+    for (const edge of edges) {
+      bucket(map, persona, edge.to, result);
+    }
+  }
+  return map;
+}
+function smoothedSuccessRate(counts) {
+  const total = counts.successes + counts.failures;
+  return (counts.successes + LAPLACE_ALPHA) / (total + 2 * LAPLACE_ALPHA);
+}
+function computePersonaEffectiveness(store, opts) {
+  const map = gatherOutcomes(store);
+  const rows = [];
+  for (const [persona, perSystem] of map) {
+    if (opts?.persona !== void 0 && persona !== opts.persona) continue;
+    for (const [systemNodeId, counts] of perSystem) {
+      if (opts?.systemNodeId !== void 0 && systemNodeId !== opts.systemNodeId) continue;
+      const sampleSize = counts.successes + counts.failures;
+      if (sampleSize === 0) continue;
+      rows.push({
+        persona,
+        systemNodeId,
+        successes: counts.successes,
+        failures: counts.failures,
+        sampleSize,
+        successRate: smoothedSuccessRate(counts)
+      });
+    }
+  }
+  rows.sort((a, b) => {
+    const rateDiff = b.successRate - a.successRate;
+    if (Math.abs(rateDiff) > 1e-10) return rateDiff;
+    return b.sampleSize - a.sampleSize;
+  });
+  return rows;
+}
+function detectBlindSpots(store, opts) {
+  const minFailures = opts?.minFailures ?? DEFAULT_MIN_FAILURES;
+  const minFailureRate = opts?.minFailureRate ?? DEFAULT_MIN_FAILURE_RATE;
+  const map = gatherOutcomes(store);
+  const spots = [];
+  for (const [persona, perSystem] of map) {
+    if (opts?.persona !== void 0 && persona !== opts.persona) continue;
+    for (const [systemNodeId, counts] of perSystem) {
+      const total = counts.successes + counts.failures;
+      if (total === 0) continue;
+      const failureRate = counts.failures / total;
+      if (counts.failures < minFailures) continue;
+      if (failureRate < minFailureRate) continue;
+      spots.push({
+        persona,
+        systemNodeId,
+        successes: counts.successes,
+        failures: counts.failures,
+        failureRate
+      });
+    }
+  }
+  spots.sort((a, b) => {
+    const rateDiff = b.failureRate - a.failureRate;
+    if (Math.abs(rateDiff) > 1e-10) return rateDiff;
+    return b.failures - a.failures;
+  });
+  return spots;
+}
+function recommendPersona(store, opts) {
+  const { systemNodeIds } = opts;
+  if (systemNodeIds.length === 0) return [];
+  const map = gatherOutcomes(store);
+  const candidates = opts.candidatePersonas ?? Array.from(map.keys());
+  if (candidates.length === 0) return [];
+  const minSamples = opts.minSamples ?? 0;
+  const recommendations = [];
+  for (const persona of candidates) {
+    const perSystem = map.get(persona);
+    let totalScore = 0;
+    let covered = 0;
+    let unknown = 0;
+    let samples = 0;
+    for (const systemNodeId of systemNodeIds) {
+      const counts = perSystem?.get(systemNodeId);
+      if (counts && counts.successes + counts.failures > 0) {
+        totalScore += smoothedSuccessRate(counts);
+        covered += 1;
+        samples += counts.successes + counts.failures;
+      } else {
+        totalScore += NEUTRAL_PRIOR;
+        unknown += 1;
+      }
+    }
+    if (samples < minSamples) continue;
+    recommendations.push({
+      persona,
+      score: totalScore / systemNodeIds.length,
+      coveredSystems: covered,
+      unknownSystems: unknown,
+      totalSamples: samples
+    });
+  }
+  recommendations.sort((a, b) => {
+    const scoreDiff = b.score - a.score;
+    if (Math.abs(scoreDiff) > 1e-10) return scoreDiff;
+    return b.totalSamples - a.totalSamples;
+  });
+  return recommendations;
+}
+
+// src/specialization/temporal.ts
+function decayWeight(ageDays, halfLifeDays) {
+  const clamped = Math.max(0, ageDays);
+  return Math.exp(-Math.LN2 / halfLifeDays * clamped);
+}
+function temporalSuccessRate(outcomes, config) {
+  if (outcomes.length === 0) return 0.5;
+  const refMs = config.referenceTime ? Date.parse(config.referenceTime) : Date.now();
+  const msPerDay = 864e5;
+  let weightedSuccesses = 0;
+  let totalWeight = 0;
+  for (const outcome of outcomes) {
+    const ageMs = refMs - Date.parse(outcome.timestamp);
+    const ageDays = ageMs / msPerDay;
+    const weight = decayWeight(ageDays, config.halfLifeDays);
+    if (outcome.result === "success") {
+      weightedSuccesses += weight;
+    }
+    totalWeight += weight;
+  }
+  const smoothingWeight = totalWeight > 0 ? totalWeight / outcomes.length : 1;
+  return (weightedSuccesses + smoothingWeight) / (totalWeight + 2 * smoothingWeight);
+}
+
+// src/specialization/scorer.ts
+var EXPERT_THRESHOLD = 30;
+var DEFAULT_HALF_LIFE = 30;
+var DEFAULT_MIN_SAMPLES = 1;
+var CONSISTENCY_WINDOW = 5;
+var W_TEMPORAL = 0.6;
+var W_CONSISTENCY = 0.25;
+var W_VOLUME = 0.15;
+function computeExpertiseLevel(sampleSize, successRate) {
+  if (sampleSize < 5) return "novice";
+  if (sampleSize < 15) return successRate >= 0.6 ? "competent" : "novice";
+  if (sampleSize < 30) return successRate >= 0.7 ? "proficient" : "competent";
+  return successRate >= 0.75 ? "expert" : "proficient";
+}
+function gatherOutcomesWithTaskType(store) {
+  const records = [];
+  const nodes = store.findNodes({ type: "execution_outcome" });
+  for (const node of nodes) {
+    const persona = node.metadata.agentPersona;
+    if (typeof persona !== "string" || persona.length === 0) continue;
+    const result = node.metadata.result;
+    if (result !== "success" && result !== "failure") continue;
+    const taskType = typeof node.metadata.taskType === "string" ? node.metadata.taskType : "*";
+    const edges = store.getEdges({ from: node.id, type: "outcome_of" });
+    const timestamp = typeof node.metadata.timestamp === "string" ? node.metadata.timestamp : "";
+    for (const edge of edges) {
+      records.push({ result, timestamp, persona, systemNodeId: edge.to, taskType });
+    }
+  }
+  return records;
+}
+function computeConsistency(results) {
+  if (results.length < CONSISTENCY_WINDOW) {
+    const successes = results.filter((r) => r === "success").length;
+    return results.length > 0 ? successes / results.length : 0.5;
+  }
+  const windowRates = [];
+  for (let i = 0; i <= results.length - CONSISTENCY_WINDOW; i++) {
+    const window = results.slice(i, i + CONSISTENCY_WINDOW);
+    const rate = window.filter((r) => r === "success").length / CONSISTENCY_WINDOW;
+    windowRates.push(rate);
+  }
+  if (windowRates.length <= 1) return windowRates[0] ?? 0.5;
+  const mean = windowRates.reduce((a, b) => a + b, 0) / windowRates.length;
+  const variance = windowRates.reduce((sum, r) => sum + (r - mean) ** 2, 0) / windowRates.length;
+  const stddev = Math.sqrt(variance);
+  return Math.max(0, Math.min(1, 1 - stddev / 0.5));
+}
+function computeVolumeBonus(sampleSize) {
+  return Math.min(1, Math.log2(sampleSize + 1) / Math.log2(EXPERT_THRESHOLD + 1));
+}
+function bucketKey(persona, systemNodeId, taskType) {
+  return `${persona}|${systemNodeId}|${taskType}`;
+}
+function computeSpecialization(store, opts) {
+  const records = gatherOutcomesWithTaskType(store);
+  if (records.length === 0) return [];
+  const temporal = opts?.temporal ?? { halfLifeDays: DEFAULT_HALF_LIFE };
+  const minSamples = opts?.minSamples ?? DEFAULT_MIN_SAMPLES;
+  const buckets = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    if (opts?.persona && record.persona !== opts.persona) continue;
+    if (opts?.systemNodeId && record.systemNodeId !== opts.systemNodeId) continue;
+    if (opts?.taskType && record.taskType !== opts.taskType) continue;
+    const key = bucketKey(record.persona, record.systemNodeId, record.taskType);
+    let arr = buckets.get(key);
+    if (!arr) {
+      arr = [];
+      buckets.set(key, arr);
+    }
+    arr.push(record);
+  }
+  const entries = [];
+  for (const [, records2] of buckets) {
+    if (records2.length < minSamples) continue;
+    const first = records2[0];
+    const { persona, systemNodeId, taskType } = first;
+    const sorted = [...records2].sort((a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp));
+    const tsr = temporalSuccessRate(
+      sorted.map((r) => ({ result: r.result, timestamp: r.timestamp })),
+      temporal
+    );
+    const consistency = computeConsistency(sorted.map((r) => r.result));
+    const volume = computeVolumeBonus(sorted.length);
+    const composite = W_TEMPORAL * tsr + W_CONSISTENCY * consistency + W_VOLUME * volume;
+    const lastOutcome = sorted[sorted.length - 1].timestamp;
+    const rawSuccessRate = sorted.filter((r) => r.result === "success").length / sorted.length;
+    entries.push({
+      persona,
+      systemNodeId,
+      taskType,
+      score: {
+        temporalSuccessRate: tsr,
+        consistencyScore: consistency,
+        volumeBonus: volume,
+        composite
+      },
+      expertiseLevel: computeExpertiseLevel(sorted.length, rawSuccessRate),
+      sampleSize: sorted.length,
+      lastOutcome
+    });
+  }
+  entries.sort((a, b) => b.score.composite - a.score.composite);
+  return entries;
+}
+function buildSpecializationProfile(store, persona, opts) {
+  const entries = computeSpecialization(store, { ...opts, persona });
+  if (entries.length === 0) {
+    return {
+      persona,
+      entries: [],
+      strengths: [],
+      weaknesses: [],
+      overallLevel: "novice",
+      computedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  const weaknessSet = /* @__PURE__ */ new Set();
+  const weaknesses = entries.filter((e) => e.score.temporalSuccessRate < 0.5).sort((a, b) => a.score.temporalSuccessRate - b.score.temporalSuccessRate).slice(0, 3);
+  for (const w of weaknesses) {
+    weaknessSet.add(`${w.systemNodeId}|${w.taskType}`);
+  }
+  const strengths = entries.filter((e) => !weaknessSet.has(`${e.systemNodeId}|${e.taskType}`)).slice(0, 3);
+  const levelOrder = ["novice", "competent", "proficient", "expert"];
+  const sortedLevels = entries.map((e) => levelOrder.indexOf(e.expertiseLevel)).sort((a, b) => a - b);
+  const medianIdx = Math.floor(sortedLevels.length / 2);
+  const medianValue = sortedLevels[medianIdx] ?? 0;
+  const overallLevel = levelOrder[medianValue] ?? "novice";
+  return {
+    persona,
+    entries,
+    strengths,
+    weaknesses,
+    overallLevel,
+    computedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function weightedRecommendPersona(store, opts) {
+  const { systemNodeIds } = opts;
+  if (systemNodeIds.length === 0) return [];
+  const recOpts = { systemNodeIds };
+  if (opts.candidatePersonas !== void 0) recOpts.candidatePersonas = opts.candidatePersonas;
+  if (opts.minSamples !== void 0) recOpts.minSamples = opts.minSamples;
+  const baseRecs = recommendPersona(store, recOpts);
+  if (baseRecs.length === 0) return [];
+  const temporal = opts.temporal ?? { halfLifeDays: DEFAULT_HALF_LIFE };
+  const results = [];
+  for (const rec of baseRecs) {
+    const specOpts = { persona: rec.persona, temporal };
+    if (opts.taskType !== void 0) specOpts.taskType = opts.taskType;
+    const specEntries = computeSpecialization(store, specOpts);
+    const relevant = specEntries.filter((e) => systemNodeIds.includes(e.systemNodeId));
+    let multiplier;
+    let expertiseLevel;
+    let specializedSystems;
+    if (relevant.length === 0) {
+      multiplier = 1;
+      expertiseLevel = "novice";
+      specializedSystems = 0;
+    } else {
+      const meanComposite = relevant.reduce((sum, e) => sum + e.score.composite, 0) / relevant.length;
+      multiplier = 0.5 + meanComposite;
+      specializedSystems = relevant.length;
+      const levelOrder = ["novice", "competent", "proficient", "expert"];
+      const bestLevel = relevant.reduce((best, e) => {
+        const idx = levelOrder.indexOf(e.expertiseLevel);
+        return idx > levelOrder.indexOf(best) ? e.expertiseLevel : best;
+      }, "novice");
+      expertiseLevel = bestLevel;
+    }
+    results.push({
+      persona: rec.persona,
+      baseScore: rec.score,
+      specializationMultiplier: multiplier,
+      weightedScore: rec.score * multiplier,
+      expertiseLevel,
+      specializedSystems
+    });
+  }
+  results.sort((a, b) => b.weightedScore - a.weightedScore);
+  return results;
+}
+
+// src/specialization/persistence.ts
+import * as fs from "fs";
+import * as path from "path";
+var PROFILE_FILE = "specialization-profiles.json";
+var HARNESS_DIR = ".harness";
+function profilePath(projectRoot) {
+  return path.join(projectRoot, HARNESS_DIR, PROFILE_FILE);
+}
+function loadProfiles(projectRoot) {
+  const filePath = profilePath(projectRoot);
+  if (!fs.existsSync(filePath)) {
+    return { profiles: {}, computedAt: (/* @__PURE__ */ new Date()).toISOString(), version: 1 };
+  }
+  const raw = fs.readFileSync(filePath, "utf-8");
+  const parsed = JSON.parse(raw);
+  if (parsed.version !== 1 || typeof parsed.profiles !== "object" || parsed.profiles === null) {
+    return { profiles: {}, computedAt: (/* @__PURE__ */ new Date()).toISOString(), version: 1 };
+  }
+  return parsed;
+}
+function saveProfiles(projectRoot, store) {
+  const dirPath = path.join(projectRoot, HARNESS_DIR);
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+  fs.writeFileSync(profilePath(projectRoot), JSON.stringify(store, null, 2), "utf-8");
+}
+function refreshProfiles(projectRoot, graphStore, opts) {
+  const nodes = graphStore.findNodes({ type: "execution_outcome" });
+  const personas = /* @__PURE__ */ new Set();
+  for (const node of nodes) {
+    const persona = node.metadata.agentPersona;
+    if (typeof persona === "string" && persona.length > 0) {
+      personas.add(persona);
+    }
+  }
+  const profiles = {};
+  for (const persona of personas) {
+    profiles[persona] = buildSpecializationProfile(graphStore, persona, opts);
+  }
+  const store = {
+    profiles,
+    computedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    version: 1
+  };
+  saveProfiles(projectRoot, store);
+  return store;
+}
+export {
+  AnthropicAnalysisProvider,
+  ClaudeCliAnalysisProvider,
+  ExecutionOutcomeConnector,
+  GraphValidator,
+  IntelligencePipeline,
+  OpenAICompatibleAnalysisProvider,
+  PeslSimulator,
+  buildSpecializationProfile,
+  computeExpertiseLevel,
+  computeHistoricalComplexity,
+  computePersonaEffectiveness,
+  computeSemanticComplexity,
+  computeSpecialization,
+  computeStructuralComplexity,
+  decayWeight,
+  detectBlindSpots,
+  enrich,
+  githubToRawWorkItem,
+  jiraToRawWorkItem,
+  linearToRawWorkItem,
+  loadProfiles,
+  manualToRawWorkItem,
+  recommendPersona,
+  refreshProfiles,
+  runGraphOnlyChecks,
+  runLlmSimulation,
+  saveProfiles,
+  score as scoreCML,
+  scoreToConcernSignals,
+  temporalSuccessRate,
+  toRawWorkItem,
+  weightedRecommendPersona
+};