@tech-leads-club/harness-toolkit 0.3.0 → 0.3.2

package/dist/chunks/compact-before-j9y4jgn4.mjs

@@ -0,0 +1,845 @@
+import {
+  claudeWiring,
+  cursorWiring
+} from "./compact-before-w1293m4n.mjs";
+import {
+  isEffortLevel,
+  readTail,
+  sanitizeSegment
+} from "./compact-before-49j320yp.mjs";
+import {
+  projectConfigPath
+} from "./compact-before-4jrq0sqs.mjs";
+
+// src/providers/claude/claude.lessons-view.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+var IMPORT_LINE = "@.tlc/harness/lessons.md";
+function claudeLessonsSourcePath(root) {
+  return join(dirname(projectConfigPath(root)), "lessons.md");
+}
+function claudeMdPath(root) {
+  return join(root, "CLAUDE.md");
+}
+function renderClaudeLessonsView(root) {
+  if (!existsSync(claudeLessonsSourcePath(root))) {
+    return null;
+  }
+  const path = claudeMdPath(root);
+  const existing = existsSync(path) ? readFileSync(path, "utf8") : "";
+  const alreadyImported = existing.split(`
+`).some((line) => line.trim() === IMPORT_LINE);
+  if (alreadyImported) {
+    return path;
+  }
+  const separator = existing.length > 0 && !existing.endsWith(`
+`) ? `
+` : "";
+  const content = existing.length > 0 ? `${existing}${separator}
+${IMPORT_LINE}
+` : `${IMPORT_LINE}
+`;
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, content, "utf8");
+  return path;
+}
+
+// src/providers/claude/claude.transcript.ts
+var DEFAULT_TAIL_LINES = 200;
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function asRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+function usageOf(record) {
+  const message = asRecord(asRecord(record)?.message);
+  return asRecord(message?.usage);
+}
+function readClaudeUsage(transcriptPath, tailLines = DEFAULT_TAIL_LINES) {
+  if (!transcriptPath) {
+    return null;
+  }
+  let records;
+  try {
+    records = readTail(transcriptPath, tailLines);
+  } catch {
+    return null;
+  }
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let cacheReadTokens = 0;
+  let cacheWriteTokens = 0;
+  let found = false;
+  for (const record of records) {
+    const usage = usageOf(record);
+    if (!usage) {
+      continue;
+    }
+    found = true;
+    inputTokens += asNumber(usage.input_tokens);
+    outputTokens += asNumber(usage.output_tokens);
+    cacheReadTokens += asNumber(usage.cache_read_input_tokens);
+    cacheWriteTokens += asNumber(usage.cache_creation_input_tokens);
+  }
+  return found ? { inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens } : null;
+}
+
+// src/providers/cursor/cursor.lessons-view.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2, join as join2 } from "node:path";
+function cursorLessonsSourcePath(root) {
+  return join2(dirname2(projectConfigPath(root)), "lessons.md");
+}
+function cursorLessonsViewPath(root) {
+  return join2(root, ".cursor", "rules", "harness-lessons.mdc");
+}
+function renderCursorLessonsView(root) {
+  const sourcePath = cursorLessonsSourcePath(root);
+  if (!existsSync2(sourcePath)) {
+    return null;
+  }
+  const body = readFileSync2(sourcePath, "utf8");
+  const path = cursorLessonsViewPath(root);
+  mkdirSync2(dirname2(path), { recursive: true });
+  const content = `---
+description: Harness-learned lessons (auto-synced from gate failures)
+alwaysApply: true
+---
+
+${body}`;
+  writeFileSync2(path, content, "utf8");
+  return path;
+}
+
+// src/providers/provider.degrade.ts
+var DEGRADE_RULES = { rewriteUnavailable: "rewrite-unavailable" };
+var ESCALATION_PREFIX = "Escalation unavailable on this provider — ";
+var NO_HUMAN_PREFIX = "No operator is answering prompts in this permission mode — ";
+var NO_HUMAN_MODES = new Set(["bypassPermissions", "dontAsk"]);
+var ADVISORY_PREFIX = "ADVISORY — this provider cannot enforce: ";
+var TRUNCATION_MARKER = `
+…(truncated — over context budget)`;
+function isEnforcing(decision) {
+  return decision.kind === "deny" || decision.kind === "ask" || decision.kind === "continue" || decision.kind === "rewriteInput";
+}
+function describeDecision(decision) {
+  switch (decision.kind) {
+    case "deny":
+    case "ask":
+      return decision.reason;
+    case "continue":
+      return decision.text;
+    case "rewriteInput":
+      return `${decision.reason} (proposed input: ${JSON.stringify(decision.input)})`;
+    default:
+      return "";
+  }
+}
+function truncateContext(text, budgetChars) {
+  if (text.length <= budgetChars) {
+    return text;
+  }
+  if (budgetChars <= 0) {
+    return "";
+  }
+  const marker = TRUNCATION_MARKER.length <= budgetChars ? TRUNCATION_MARKER : TRUNCATION_MARKER.slice(0, budgetChars);
+  const keep = Math.max(0, budgetChars - marker.length);
+  return `${text.slice(0, keep)}${marker}`;
+}
+function canCarryContext(event, capabilities) {
+  if (event.event === "tool.before") {
+    return capabilities.contextAtToolBefore;
+  }
+  if (event.event === "tool.after") {
+    return capabilities.contextAtToolAfter;
+  }
+  if (event.event === "stop") {
+    return capabilities.contextAtStop;
+  }
+  return true;
+}
+function applyContextBudget(decision, budgetChars) {
+  if (decision.kind !== "context" || budgetChars === undefined) {
+    return decision;
+  }
+  const truncated = truncateContext(decision.text, budgetChars);
+  if (truncated === decision.text) {
+    return decision;
+  }
+  return { ...decision, text: truncated };
+}
+function degrade(decision, event, capabilities, options = {}) {
+  if (!capabilities.enforcesHooks && isEnforcing(decision)) {
+    return applyContextBudget({ kind: "context", text: `${ADVISORY_PREFIX}${describeDecision(decision)}` }, options.contextBudgetChars);
+  }
+  if (decision.kind === "ask") {
+    if (!capabilities.askSupportedOn.includes(event.event)) {
+      return {
+        kind: "deny",
+        reason: `${ESCALATION_PREFIX}${decision.reason}`,
+        userNote: decision.userNote,
+        rule: decision.rule
+      };
+    }
+    if (event.permissionMode !== undefined && NO_HUMAN_MODES.has(event.permissionMode)) {
+      return {
+        kind: "deny",
+        reason: `${NO_HUMAN_PREFIX}${decision.reason}`,
+        userNote: decision.userNote,
+        rule: decision.rule
+      };
+    }
+    return decision;
+  }
+  if (decision.kind === "rewriteInput" && !capabilities.toolInputRewrite) {
+    return {
+      kind: "ask",
+      reason: `Input rewrite unavailable on this provider — proposed input: ${JSON.stringify(decision.input)}. ${decision.reason}`,
+      rule: DEGRADE_RULES.rewriteUnavailable
+    };
+  }
+  if (decision.kind === "context") {
+    if (!canCarryContext(event, capabilities)) {
+      return { kind: "abstain" };
+    }
+    if (decision.env && !capabilities.sessionEnv) {
+      const { env: _droppedEnv, ...withoutEnv } = decision;
+      return applyContextBudget(withoutEnv, options.contextBudgetChars);
+    }
+    return applyContextBudget(decision, options.contextBudgetChars);
+  }
+  return decision;
+}
+
+// src/providers/claude/claude.capabilities.ts
+function claudeCapabilities() {
+  return {
+    enforcesHooks: true,
+    askSupportedOn: ["tool.before", "shell.before", "mcp.before", "read.before"],
+    sessionEnv: false,
+    nativeLoopCounter: false,
+    dedicatedShellEvent: false,
+    toolInputRewrite: true,
+    toolOutputRewrite: true,
+    contextAtToolBefore: true,
+    contextAtToolAfter: true,
+    contextAtStop: true,
+    sessionStartContextReliable: true,
+    toolOutputAtAfter: true,
+    usageInPayload: false,
+    effortSignal: true,
+    thoughtEvent: false
+  };
+}
+
+// src/providers/claude/claude.detect.ts
+var PASCAL_CASE_EVENT_NAME = /^[A-Z][a-zA-Z0-9]*$/;
+function detectClaude(raw) {
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+    return false;
+  }
+  const value = raw;
+  const eventName = value.hook_event_name;
+  if (typeof eventName !== "string" || !PASCAL_CASE_EVENT_NAME.test(eventName)) {
+    return false;
+  }
+  return typeof value.cwd === "string" || typeof value.transcript_path === "string";
+}
+
+// src/providers/claude/claude.inbound.ts
+var EVENT_KIND_BY_HOOK = {
+  SessionStart: "session.start",
+  SessionEnd: "session.end",
+  UserPromptSubmit: "prompt.submit",
+  PostToolUseFailure: "tool.failure",
+  SubagentStart: "subagent.start",
+  SubagentStop: "subagent.stop",
+  Stop: "stop",
+  PreCompact: "compact.before",
+  MessageDisplay: "response.after"
+};
+var MCP_TOOL_NAME = /^mcp__/;
+function asString(value) {
+  return typeof value === "string" ? value : undefined;
+}
+function asNumber2(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function asRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+function asStatus(value) {
+  return value === "completed" || value === "aborted" || value === "error" ? value : undefined;
+}
+function sessionKeyFor(raw) {
+  const seed = asString(raw.session_id) ?? "default";
+  return `claude-${sanitizeSegment(seed)}`;
+}
+function projectDirFor(raw) {
+  const envDir = process.env.CLAUDE_PROJECT_DIR;
+  if (envDir) {
+    return envDir;
+  }
+  const cwd = asString(raw.cwd);
+  if (cwd) {
+    return cwd;
+  }
+  return process.cwd();
+}
+function effortFor(raw) {
+  const effort = asRecord2(raw.effort);
+  const level = effort?.level;
+  return isEffortLevel(level) ? level : undefined;
+}
+function preToolUseKind(toolName) {
+  if (toolName === "Bash") {
+    return "shell.before";
+  }
+  if (toolName && MCP_TOOL_NAME.test(toolName)) {
+    return "mcp.before";
+  }
+  if (toolName === "Read") {
+    return "read.before";
+  }
+  return "tool.before";
+}
+function postToolUseKind(toolName) {
+  if (toolName === "Bash") {
+    return "shell.after";
+  }
+  if (toolName && MCP_TOOL_NAME.test(toolName)) {
+    return "mcp.after";
+  }
+  if (toolName === "Edit" || toolName === "Write") {
+    return "edit.after";
+  }
+  return "tool.after";
+}
+function claudeToEvent(raw) {
+  const hookEventName = asString(raw.hook_event_name);
+  if (!hookEventName) {
+    return null;
+  }
+  const toolName = asString(raw.tool_name);
+  const toolInput = asRecord2(raw.tool_input);
+  let eventKind;
+  if (hookEventName === "PreToolUse") {
+    eventKind = preToolUseKind(toolName);
+  } else if (hookEventName === "PostToolUse") {
+    eventKind = postToolUseKind(toolName);
+  } else {
+    eventKind = EVENT_KIND_BY_HOOK[hookEventName];
+  }
+  if (!eventKind) {
+    return null;
+  }
+  const event = {
+    provider: "claude",
+    event: eventKind,
+    sessionKey: sessionKeyFor(raw),
+    projectDir: projectDirFor(raw),
+    raw
+  };
+  const permissionMode = asString(raw.permission_mode);
+  if (permissionMode) {
+    event.permissionMode = permissionMode;
+  }
+  const isSpawnEvent = eventKind === "subagent.start" || eventKind === "subagent.stop";
+  const model = isSpawnEvent ? undefined : asString(raw.model);
+  if (model) {
+    event.model = model;
+  }
+  const effort = effortFor(raw);
+  if (effort) {
+    event.effort = effort;
+  }
+  const contextUsagePercent = asNumber2(raw.context_usage_percent);
+  if (contextUsagePercent !== undefined) {
+    event.contextUsagePercent = contextUsagePercent;
+  }
+  const transcriptPath = asString(raw.transcript_path);
+  if (transcriptPath) {
+    event.transcriptPath = transcriptPath;
+  }
+  if (!isSpawnEvent) {
+    const callerAgentType = asString(raw.agent_type);
+    if (callerAgentType) {
+      event.subagentType = callerAgentType;
+    }
+  }
+  switch (eventKind) {
+    case "prompt.submit": {
+      const text = asString(raw.prompt);
+      if (text !== undefined) {
+        event.text = text;
+      }
+      break;
+    }
+    case "response.after": {
+      const text = asString(raw.text);
+      if (text !== undefined) {
+        event.text = text;
+      }
+      break;
+    }
+    case "shell.before":
+    case "shell.after": {
+      const command = toolInput ? asString(toolInput.command) : undefined;
+      if (command !== undefined) {
+        event.command = command;
+      }
+      break;
+    }
+    case "mcp.before":
+    case "mcp.after": {
+      if (toolName) {
+        event.toolName = toolName;
+      }
+      if (toolInput) {
+        event.toolInput = toolInput;
+      }
+      break;
+    }
+    case "read.before": {
+      const filePath = toolInput ? asString(toolInput.file_path) : undefined;
+      if (filePath !== undefined) {
+        event.filePath = filePath;
+      }
+      break;
+    }
+    case "edit.after": {
+      if (toolName) {
+        event.toolName = toolName;
+      }
+      const filePath = toolInput ? asString(toolInput.file_path) : undefined;
+      if (filePath !== undefined) {
+        event.filePath = filePath;
+      }
+      break;
+    }
+    case "tool.before":
+    case "tool.after":
+    case "tool.failure": {
+      if (toolName) {
+        event.toolName = toolName;
+      }
+      const toolOutput = raw.tool_response;
+      if (toolOutput !== undefined && toolOutput !== null) {
+        event.toolOutput = typeof toolOutput === "string" ? toolOutput : JSON.stringify(toolOutput);
+      }
+      if (toolInput) {
+        event.toolInput = toolInput;
+      }
+      const filePath = toolInput ? asString(toolInput.file_path) : undefined;
+      if (filePath !== undefined) {
+        event.filePath = filePath;
+      }
+      const spawnSubagentType = toolInput ? asString(toolInput.subagent_type) : undefined;
+      if (spawnSubagentType) {
+        event.spawnSubagentType = spawnSubagentType;
+      }
+      const spawnModel = toolInput ? asString(toolInput.model) : undefined;
+      if (spawnModel) {
+        event.spawnModel = spawnModel;
+      }
+      break;
+    }
+    case "subagent.start":
+    case "subagent.stop": {
+      const spawnSubagentType = asString(raw.agent_type) ?? asString(raw.subagent_type) ?? (toolInput ? asString(toolInput.subagent_type) : undefined);
+      if (spawnSubagentType) {
+        event.spawnSubagentType = spawnSubagentType;
+      }
+      const spawnModel = (toolInput ? asString(toolInput.model) : undefined) ?? asString(raw.model);
+      if (spawnModel) {
+        event.spawnModel = spawnModel;
+      }
+      break;
+    }
+    case "stop": {
+      const status = asStatus(raw.status);
+      if (status) {
+        event.status = status;
+      }
+      break;
+    }
+    default:
+      break;
+  }
+  return event;
+}
+
+// src/providers/claude/claude.outbound.ts
+var HOOK_EVENT_NAME_BY_KIND = {
+  "session.start": "SessionStart",
+  "session.end": "SessionEnd",
+  "prompt.submit": "UserPromptSubmit",
+  "tool.before": "PreToolUse",
+  "tool.after": "PostToolUse",
+  "tool.failure": "PostToolUseFailure",
+  "shell.before": "PreToolUse",
+  "shell.after": "PostToolUse",
+  "mcp.before": "PreToolUse",
+  "mcp.after": "PostToolUse",
+  "read.before": "PreToolUse",
+  "edit.after": "PostToolUse",
+  "subagent.start": "SubagentStart",
+  "subagent.stop": "SubagentStop",
+  stop: "Stop",
+  "compact.before": "PreCompact",
+  "response.after": "MessageDisplay",
+  "thought.after": "MessageDisplay"
+};
+function renderPermission(permissionDecision, hookEventName, reason) {
+  const hookSpecificOutput = { hookEventName, permissionDecision };
+  if (reason !== undefined) {
+    hookSpecificOutput.permissionDecisionReason = reason;
+  }
+  return JSON.stringify({ hookSpecificOutput });
+}
+function claudeRender(decision, event) {
+  const hookEventName = HOOK_EVENT_NAME_BY_KIND[event.event];
+  switch (decision.kind) {
+    case "abstain":
+      return { stdout: null, exitCode: 0 };
+    case "allow":
+      return { stdout: renderPermission("allow", hookEventName, undefined), exitCode: 0 };
+    case "deny":
+      return { stdout: renderPermission("deny", hookEventName, decision.reason), exitCode: 0 };
+    case "ask":
+      return { stdout: renderPermission("ask", hookEventName, decision.reason), exitCode: 0 };
+    case "context":
+      return {
+        stdout: JSON.stringify({ hookSpecificOutput: { hookEventName, additionalContext: decision.text } }),
+        exitCode: 0
+      };
+    case "continue":
+      return { stdout: JSON.stringify({ decision: "block", reason: decision.text }), exitCode: 0 };
+    case "rewriteInput":
+      return {
+        stdout: JSON.stringify({ hookSpecificOutput: { hookEventName, updatedInput: decision.input } }),
+        exitCode: 0
+      };
+    default: {
+      const exhaustive = decision;
+      throw new Error(`unreachable decision kind: ${JSON.stringify(exhaustive)}`);
+    }
+  }
+}
+
+// src/providers/claude/claude.policy-defaults.ts
+function claudePolicyDefaults() {
+  return {
+    blockedPatterns: [],
+    minEffort: null,
+    untrustedTools: ["WebFetch", "WebSearch"]
+  };
+}
+
+// src/providers/claude/index.ts
+var claudeProvider = {
+  name: "claude",
+  detect: detectClaude,
+  capabilities: claudeCapabilities,
+  policyDefaults: claudePolicyDefaults,
+  toEvent: claudeToEvent,
+  render: claudeRender,
+  wiring: claudeWiring
+};
+
+// src/providers/cursor/cursor.capabilities.ts
+function cursorCapabilities() {
+  return {
+    enforcesHooks: true,
+    askSupportedOn: ["shell.before", "mcp.before"],
+    sessionEnv: true,
+    nativeLoopCounter: true,
+    dedicatedShellEvent: true,
+    toolInputRewrite: true,
+    toolOutputRewrite: true,
+    contextAtToolBefore: false,
+    contextAtToolAfter: true,
+    contextAtStop: false,
+    sessionStartContextReliable: false,
+    toolOutputAtAfter: true,
+    usageInPayload: true,
+    effortSignal: false,
+    thoughtEvent: true
+  };
+}
+
+// src/providers/cursor/cursor.detect.ts
+var CAMEL_CASE_EVENT_NAME = /^[a-z][a-zA-Z0-9]*$/;
+function detectCursor(raw) {
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+    return false;
+  }
+  const value = raw;
+  const eventName = value.hook_event_name;
+  if (typeof eventName !== "string" || !CAMEL_CASE_EVENT_NAME.test(eventName)) {
+    return false;
+  }
+  return Array.isArray(value.workspace_roots);
+}
+
+// src/providers/cursor/cursor.inbound.ts
+var EVENT_KIND_BY_HOOK2 = {
+  sessionStart: "session.start",
+  sessionEnd: "session.end",
+  beforeSubmitPrompt: "prompt.submit",
+  preToolUse: "tool.before",
+  postToolUse: "tool.after",
+  postToolUseFailure: "tool.failure",
+  beforeShellExecution: "shell.before",
+  afterShellExecution: "shell.after",
+  beforeMCPExecution: "mcp.before",
+  afterMCPExecution: "mcp.after",
+  beforeReadFile: "read.before",
+  afterFileEdit: "edit.after",
+  subagentStart: "subagent.start",
+  subagentStop: "subagent.stop",
+  stop: "stop",
+  preCompact: "compact.before",
+  afterAgentResponse: "response.after",
+  afterAgentThought: "thought.after"
+};
+function asString2(value) {
+  return typeof value === "string" ? value : undefined;
+}
+function asNumber3(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function asRecord3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+function asStatus2(value) {
+  return value === "completed" || value === "aborted" || value === "error" ? value : undefined;
+}
+function sessionKeyFor2(raw) {
+  const seed = asString2(raw.conversation_id) || asString2(raw.session_id) || "default";
+  return `cursor-${sanitizeSegment(seed)}`;
+}
+function projectDirFor2(raw) {
+  const envDir = process.env.CURSOR_PROJECT_DIR;
+  if (envDir) {
+    return envDir;
+  }
+  const roots = raw.workspace_roots;
+  if (Array.isArray(roots)) {
+    const first = asString2(roots[0]);
+    if (first) {
+      return first;
+    }
+  }
+  return process.cwd();
+}
+function cursorToEvent(raw) {
+  const hookEventName = asString2(raw.hook_event_name);
+  const eventKind = hookEventName ? EVENT_KIND_BY_HOOK2[hookEventName] : undefined;
+  if (!eventKind) {
+    return null;
+  }
+  const event = {
+    provider: "cursor",
+    event: eventKind,
+    sessionKey: sessionKeyFor2(raw),
+    projectDir: projectDirFor2(raw),
+    raw
+  };
+  const model = asString2(raw.model);
+  if (model) {
+    event.model = model;
+  }
+  const contextUsagePercent = asNumber3(raw.context_usage_percent);
+  if (contextUsagePercent !== undefined) {
+    event.contextUsagePercent = contextUsagePercent;
+  }
+  switch (eventKind) {
+    case "prompt.submit": {
+      const text = asString2(raw.prompt);
+      if (text !== undefined) {
+        event.text = text;
+      }
+      break;
+    }
+    case "response.after": {
+      const text = asString2(raw.text);
+      if (text !== undefined) {
+        event.text = text;
+      }
+      break;
+    }
+    case "thought.after": {
+      const text = asString2(raw.thought) ?? asString2(raw.text);
+      if (text !== undefined) {
+        event.text = text;
+      }
+      break;
+    }
+    case "tool.before":
+    case "tool.after":
+    case "tool.failure": {
+      const toolName = asString2(raw.tool_name);
+      if (toolName) {
+        event.toolName = toolName;
+      }
+      const toolInput = asRecord3(raw.tool_input);
+      if (toolInput) {
+        event.toolInput = toolInput;
+      }
+      const subagentType = asString2(raw.subagent_type);
+      if (subagentType) {
+        event.subagentType = subagentType;
+      }
+      const toolSpawnModel = toolInput ? asString2(toolInput.model) : undefined;
+      if (toolSpawnModel) {
+        event.spawnModel = toolSpawnModel;
+      }
+      const toolSpawnType = toolInput ? asString2(toolInput.subagent_type) : undefined;
+      if (toolSpawnType) {
+        event.spawnSubagentType = toolSpawnType;
+      }
+      break;
+    }
+    case "shell.before":
+    case "shell.after": {
+      const command = asString2(raw.command);
+      if (command !== undefined) {
+        event.command = command;
+      }
+      const output = asString2(raw.output);
+      if (output !== undefined) {
+        event.toolOutput = output;
+      }
+      break;
+    }
+    case "mcp.before":
+    case "mcp.after": {
+      const resultJson = asString2(raw.result_json);
+      if (resultJson !== undefined) {
+        event.toolOutput = resultJson;
+      }
+      const toolName = asString2(raw.tool_name);
+      if (toolName) {
+        event.toolName = toolName;
+      }
+      const toolInput = asRecord3(raw.tool_input);
+      if (toolInput) {
+        event.toolInput = toolInput;
+      }
+      const command = asString2(raw.command);
+      if (command !== undefined) {
+        event.command = command;
+      }
+      break;
+    }
+    case "read.before":
+    case "edit.after": {
+      const filePath = asString2(raw.file_path);
+      if (filePath !== undefined) {
+        event.filePath = filePath;
+      }
+      break;
+    }
+    case "subagent.start":
+    case "subagent.stop": {
+      const spawnSubagentType = asString2(raw.subagent_type);
+      if (spawnSubagentType) {
+        event.spawnSubagentType = spawnSubagentType;
+      }
+      const spawnModel = asString2(raw.subagent_model);
+      if (spawnModel) {
+        event.spawnModel = spawnModel;
+      }
+      break;
+    }
+    case "stop": {
+      const status = asStatus2(raw.status);
+      if (status) {
+        event.status = status;
+      }
+      const loopCount = asNumber3(raw.loop_count);
+      if (loopCount !== undefined) {
+        event.loopCount = loopCount;
+      }
+      break;
+    }
+    default:
+      break;
+  }
+  return event;
+}
+
+// src/providers/cursor/cursor.outbound.ts
+function renderDenyOrAsk(permission, decision) {
+  const body = { permission };
+  if (decision.userNote !== undefined) {
+    body.user_message = decision.userNote;
+  }
+  body.agent_message = decision.reason;
+  return JSON.stringify(body);
+}
+function cursorRender(decision, _event) {
+  switch (decision.kind) {
+    case "abstain":
+      return { stdout: "{}", exitCode: 0 };
+    case "allow":
+      return { stdout: JSON.stringify({ permission: "allow" }), exitCode: 0 };
+    case "deny":
+      return { stdout: renderDenyOrAsk("deny", decision), exitCode: 0 };
+    case "ask":
+      return { stdout: renderDenyOrAsk("ask", decision), exitCode: 0 };
+    case "context": {
+      const body = {};
+      if (decision.env !== undefined) {
+        body.env = decision.env;
+      }
+      body.additional_context = decision.text;
+      return { stdout: JSON.stringify(body), exitCode: 0 };
+    }
+    case "continue":
+      return { stdout: JSON.stringify({ followup_message: decision.text }), exitCode: 0 };
+    case "rewriteInput":
+      return { stdout: JSON.stringify({ updated_input: decision.input }), exitCode: 0 };
+    default: {
+      const exhaustive = decision;
+      throw new Error(`unreachable decision kind: ${JSON.stringify(exhaustive)}`);
+    }
+  }
+}
+
+// src/providers/cursor/cursor.policy-defaults.ts
+function cursorPolicyDefaults() {
+  return {
+    blockedPatterns: ["-fast(?:$|[^a-z0-9])", "/fast(?:$|[^a-z0-9])", "composer-2\\.5-fast"],
+    minEffort: null,
+    untrustedTools: ["Fetch", "WebSearch"]
+  };
+}
+
+// src/providers/cursor/index.ts
+var cursorProvider = {
+  name: "cursor",
+  detect: detectCursor,
+  capabilities: cursorCapabilities,
+  policyDefaults: cursorPolicyDefaults,
+  toEvent: cursorToEvent,
+  render: cursorRender,
+  wiring: cursorWiring
+};
+
+// src/providers/provider.registry.ts
+var providers = [cursorProvider, claudeProvider];
+function resolveFromRegistry(raw, registry) {
+  const matched = registry.filter((provider) => provider.detect(raw));
+  if (matched.length === 0) {
+    return { provider: null, ambiguous: false, matchedNames: [] };
+  }
+  return {
+    provider: matched[0] ?? null,
+    ambiguous: matched.length > 1,
+    matchedNames: matched.map((provider) => provider.name)
+  };
+}
+export { renderClaudeLessonsView, readClaudeUsage, renderCursorLessonsView, degrade, providers, resolveFromRegistry };