codealmanac 0.2.5 → 0.2.7

package/dist/chunk-WL4UE7Q6.js

@@ -0,0 +1,1386 @@
+#!/usr/bin/env node
+import {
+  parseFrontmatter,
+  runIndexer
+} from "./chunk-BFIG2CXM.js";
+import {
+  checkClaudeAuth,
+  resolveClaudeExecutable
+} from "./chunk-FUBE6KCO.js";
+import {
+  getRepoAlmanacDir
+} from "./chunk-IZT6RBHS.js";
+
+// src/process/ids.ts
+import { randomBytes } from "crypto";
+function createRunId(now = /* @__PURE__ */ new Date()) {
+  const stamp = now.toISOString().replace(/\D/g, "").slice(0, 14);
+  const suffix = randomBytes(4).toString("hex");
+  return `run_${stamp}_${suffix}`;
+}
+
+// src/process/background.ts
+import { spawn as spawn2 } from "child_process";
+
+// src/process/logs.ts
+import { mkdir, writeFile, appendFile } from "fs/promises";
+import { dirname } from "path";
+async function initializeRunLog(path) {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, "", "utf8");
+}
+async function appendRunEvent(path, event, now = /* @__PURE__ */ new Date()) {
+  const entry = {
+    timestamp: now.toISOString(),
+    event
+  };
+  await appendFile(path, `${JSON.stringify(entry)}
+`, "utf8");
+}
+
+// src/process/manager.ts
+import { join as join3 } from "path";
+
+// src/harness/providers/claude.ts
+import {
+  query
+} from "@anthropic-ai/claude-agent-sdk";
+
+// src/harness/providers/metadata.ts
+var BASE_CAPABILITIES = {
+  nonInteractive: true,
+  streaming: true,
+  modelOverride: true,
+  modelOptions: false,
+  fileRead: true,
+  fileWrite: true,
+  shell: true
+};
+var HARNESS_PROVIDER_METADATA = {
+  claude: {
+    id: "claude",
+    displayName: "Claude",
+    defaultModel: "claude-sonnet-4-6",
+    capabilities: {
+      ...BASE_CAPABILITIES,
+      reasoningEffort: false,
+      sessionPersistence: true,
+      threadResume: true,
+      interrupt: true,
+      mcp: true,
+      skills: true,
+      usage: true,
+      cost: true,
+      contextUsage: false,
+      structuredOutput: false,
+      subagents: {
+        supported: true,
+        programmaticPerRun: true,
+        enforcedToolScopes: true
+      },
+      policy: {
+        sandbox: true,
+        strictToolAllowlist: true,
+        commandApproval: true,
+        toolHook: true
+      }
+    }
+  },
+  codex: {
+    id: "codex",
+    displayName: "Codex",
+    defaultModel: null,
+    capabilities: {
+      ...BASE_CAPABILITIES,
+      modelOptions: true,
+      reasoningEffort: false,
+      sessionPersistence: false,
+      threadResume: false,
+      interrupt: false,
+      mcp: false,
+      skills: false,
+      usage: true,
+      cost: false,
+      contextUsage: false,
+      structuredOutput: true,
+      subagents: {
+        supported: false,
+        programmaticPerRun: false,
+        enforcedToolScopes: false
+      },
+      policy: {
+        sandbox: true,
+        strictToolAllowlist: false,
+        commandApproval: false,
+        toolHook: false
+      }
+    }
+  },
+  cursor: {
+    id: "cursor",
+    displayName: "Cursor",
+    defaultModel: null,
+    capabilities: {
+      nonInteractive: false,
+      streaming: false,
+      modelOverride: false,
+      modelOptions: false,
+      fileRead: false,
+      fileWrite: false,
+      shell: false,
+      reasoningEffort: false,
+      sessionPersistence: false,
+      threadResume: false,
+      interrupt: false,
+      mcp: false,
+      skills: false,
+      usage: false,
+      cost: false,
+      contextUsage: false,
+      structuredOutput: false,
+      subagents: {
+        supported: false,
+        programmaticPerRun: false,
+        enforcedToolScopes: false
+      },
+      policy: {
+        sandbox: false,
+        strictToolAllowlist: false,
+        commandApproval: false,
+        toolHook: false
+      }
+    }
+  }
+};
+
+// src/harness/providers/claude.ts
+function createClaudeHarnessProvider(deps = {}) {
+  const queryFn = deps.query ?? query;
+  const checkAuthFn = deps.checkAuth ?? (() => checkClaudeAuth());
+  const resolveExecutable = deps.resolveExecutable ?? resolveClaudeExecutable;
+  const metadata = HARNESS_PROVIDER_METADATA.claude;
+  return {
+    metadata,
+    checkStatus: async () => {
+      let auth = { loggedIn: false };
+      try {
+        auth = await checkAuthFn();
+      } catch {
+        auth = { loggedIn: false };
+      }
+      const hasApiKey = process.env.ANTHROPIC_API_KEY !== void 0 && process.env.ANTHROPIC_API_KEY.length > 0;
+      const installed = resolveExecutable() !== void 0;
+      const authenticated = auth.loggedIn || hasApiKey;
+      const detail = authenticated ? auth.email ?? (hasApiKey ? "ANTHROPIC_API_KEY set" : "logged in") : installed ? "not logged in" : "claude not found on PATH";
+      return { id: metadata.id, installed, authenticated, detail };
+    },
+    run: async (spec, hooks) => runClaudeHarness(spec, hooks, queryFn, resolveExecutable)
+  };
+}
+var claudeHarnessProvider = createClaudeHarnessProvider();
+async function runClaudeHarness(spec, hooks, queryFn, resolveExecutable) {
+  const options = buildClaudeOptions(spec, resolveExecutable);
+  const stream = queryFn({
+    prompt: spec.prompt,
+    options
+  });
+  let costUsd;
+  let turns;
+  let result = "";
+  let providerSessionId;
+  let success = false;
+  let error;
+  let failure;
+  let usage;
+  try {
+    for await (const message of stream) {
+      providerSessionId = providerSessionId ?? getSessionId(message);
+      for (const event of toHarnessEvents(message)) {
+        await hooks?.onEvent?.(event);
+      }
+      if (message.type === "result") {
+        costUsd = message.total_cost_usd;
+        turns = message.num_turns;
+        usage = mapUsage(message.usage);
+        providerSessionId = providerSessionId ?? message.session_id;
+        if (message.subtype === "success") {
+          success = true;
+          result = message.result;
+        } else {
+          success = false;
+          error = message.errors.length > 0 ? message.errors.join("; ") : `agent error: ${message.subtype}`;
+          failure = classifyClaudeFailure(error, message.subtype);
+        }
+      }
+    }
+  } catch (err) {
+    success = false;
+    error = err instanceof Error ? err.message : String(err);
+    failure = classifyClaudeFailure(error);
+    await hooks?.onEvent?.({ type: "error", error, failure });
+  }
+  await hooks?.onEvent?.({
+    type: "done",
+    result,
+    providerSessionId,
+    costUsd,
+    turns,
+    usage,
+    error,
+    failure
+  });
+  return {
+    success,
+    result,
+    providerSessionId,
+    costUsd,
+    turns,
+    usage,
+    error,
+    failure
+  };
+}
+function classifyClaudeFailure(raw, subtype) {
+  if (raw.includes("Not logged in") || raw.includes("authentication")) {
+    return {
+      provider: "claude",
+      code: "claude.not_authenticated",
+      message: "Claude is not authenticated in this environment.",
+      fix: "Run `claude` and log in, or configure ANTHROPIC_API_KEY for this process.",
+      raw,
+      details: subtype !== void 0 ? { subtype } : void 0
+    };
+  }
+  if (subtype === "error_max_budget_usd") {
+    return {
+      provider: "claude",
+      code: "claude.max_budget_exceeded",
+      message: "Claude stopped because the run exceeded its maximum budget.",
+      fix: "Raise the budget for this run or use a cheaper model.",
+      raw,
+      details: { subtype }
+    };
+  }
+  return {
+    provider: "claude",
+    code: subtype !== void 0 ? `claude.${subtype}` : "claude.process_failed",
+    message: raw,
+    raw,
+    details: subtype !== void 0 ? { subtype } : void 0
+  };
+}
+function buildClaudeOptions(spec, resolveExecutable) {
+  const tools = toClaudeTools(spec.tools ?? []);
+  const agents = toClaudeAgents(spec.agents ?? {});
+  if (Object.keys(agents).length > 0 && !tools.includes("Agent")) {
+    tools.push("Agent");
+  }
+  const claudeExecutable = resolveExecutable();
+  return pruneUndefined({
+    systemPrompt: spec.systemPrompt,
+    cwd: spec.cwd,
+    model: spec.provider.model ?? HARNESS_PROVIDER_METADATA.claude.defaultModel ?? void 0,
+    effort: toClaudeEffort(spec.provider.effort),
+    tools,
+    allowedTools: tools,
+    agents,
+    mcpServers: spec.mcpServers,
+    maxTurns: spec.limits?.maxTurns ?? 100,
+    maxBudgetUsd: spec.limits?.maxCostUsd,
+    permissionMode: "dontAsk",
+    includePartialMessages: true,
+    env: {
+      ...process.env,
+      CODEALMANAC_INTERNAL_SESSION: "1"
+    },
+    ...claudeExecutable !== void 0 ? { pathToClaudeCodeExecutable: claudeExecutable } : {}
+  });
+}
+function toClaudeAgents(agents) {
+  const out = {};
+  for (const [name, agent] of Object.entries(agents)) {
+    out[name] = pruneUndefined({
+      description: agent.description,
+      prompt: agent.prompt,
+      tools: agent.tools !== void 0 ? toClaudeTools(agent.tools) : void 0,
+      model: agent.model,
+      maxTurns: agent.maxTurns,
+      mcpServers: agent.mcpServers,
+      skills: agent.skills
+    });
+  }
+  return out;
+}
+function toClaudeTools(tools) {
+  const out = /* @__PURE__ */ new Set();
+  for (const tool of tools) {
+    switch (tool.id) {
+      case "read":
+        out.add("Read");
+        break;
+      case "write":
+        out.add("Write");
+        break;
+      case "edit":
+        out.add("Edit");
+        break;
+      case "search":
+        out.add("Glob");
+        out.add("Grep");
+        break;
+      case "shell":
+        out.add("Bash");
+        break;
+      case "web":
+        out.add("WebSearch");
+        out.add("WebFetch");
+        break;
+      case "mcp":
+        break;
+    }
+  }
+  return [...out];
+}
+function toClaudeEffort(effort) {
+  if (effort === "low" || effort === "medium" || effort === "high" || effort === "max") {
+    return effort;
+  }
+  return void 0;
+}
+function toHarnessEvents(message) {
+  if (message.type === "stream_event") {
+    const text = getTextDelta(message.event);
+    return text !== void 0 ? [{ type: "text_delta", content: text }] : [];
+  }
+  if (message.type === "assistant") {
+    const content = message.message.content;
+    if (!Array.isArray(content)) return [];
+    const events = [];
+    for (const block of content) {
+      if (block.type === "text") {
+        events.push({ type: "text", content: block.text });
+        continue;
+      }
+      if (block.type === "tool_use") {
+        events.push({
+          type: "tool_use",
+          id: block.id,
+          tool: block.name,
+          input: stringifyInput(block.input)
+        });
+      }
+    }
+    return events;
+  }
+  if (message.type === "user") {
+    const content = message.message.content;
+    if (!Array.isArray(content)) return [];
+    return content.flatMap((block) => {
+      if (block.type !== "tool_result") return [];
+      return [
+        {
+          type: "tool_result",
+          id: block.tool_use_id,
+          content: block.content,
+          isError: block.is_error
+        }
+      ];
+    });
+  }
+  if (message.type === "tool_use_summary") {
+    return [{ type: "tool_summary", summary: message.summary }];
+  }
+  if (message.type === "result" && message.subtype !== "success") {
+    return message.errors.map((err) => ({ type: "error", error: err }));
+  }
+  return [];
+}
+function getTextDelta(event) {
+  if (event === null || typeof event !== "object") return void 0;
+  const raw = event;
+  return raw.type === "content_block_delta" && raw.delta?.type === "text_delta" && typeof raw.delta.text === "string" ? raw.delta.text : void 0;
+}
+function getSessionId(message) {
+  return "session_id" in message && typeof message.session_id === "string" ? message.session_id : void 0;
+}
+function stringifyInput(input) {
+  if (input === void 0) return void 0;
+  if (typeof input === "string") return input;
+  try {
+    return JSON.stringify(input);
+  } catch {
+    return String(input);
+  }
+}
+function mapUsage(value) {
+  if (value === null || typeof value !== "object") return void 0;
+  const usage = value;
+  const inputTokens = numberField(usage, "input_tokens");
+  const cachedInputTokens = numberField(usage, "cache_read_input_tokens");
+  const outputTokens = numberField(usage, "output_tokens");
+  return pruneUndefined({
+    inputTokens,
+    cachedInputTokens,
+    outputTokens,
+    totalTokens: inputTokens !== void 0 || outputTokens !== void 0 ? (inputTokens ?? 0) + (outputTokens ?? 0) : void 0
+  });
+}
+function numberField(record, field) {
+  const value = record[field];
+  return typeof value === "number" ? value : void 0;
+}
+function pruneUndefined(value) {
+  for (const key of Object.keys(value)) {
+    if (value[key] === void 0) {
+      delete value[key];
+    }
+  }
+  return value;
+}
+
+// src/harness/providers/codex.ts
+import { spawn, spawnSync } from "child_process";
+function createCodexHarnessProvider(deps = {}) {
+  const metadata = HARNESS_PROVIDER_METADATA.codex;
+  const commandExists = deps.commandExists ?? defaultCommandExists;
+  const runStatus = deps.runStatus ?? defaultRunStatus;
+  const runCli = deps.runCli ?? runCodexCli;
+  return {
+    metadata,
+    checkStatus: async () => {
+      if (!commandExists("codex")) {
+        return {
+          id: metadata.id,
+          installed: false,
+          authenticated: false,
+          detail: "codex not found on PATH"
+        };
+      }
+      const auth = await runStatus("codex", ["login", "status"]);
+      return {
+        id: metadata.id,
+        installed: true,
+        authenticated: auth.ok,
+        detail: auth.detail
+      };
+    },
+    run: async (spec, hooks) => {
+      if (spec.agents !== void 0 && Object.keys(spec.agents).length > 0) {
+        return {
+          success: false,
+          result: "",
+          error: "Codex exec adapter does not support per-run programmatic agents",
+          failure: {
+            provider: "codex",
+            code: "codex.unsupported_feature",
+            message: "Codex exec adapter does not support per-run programmatic agents.",
+            fix: "Run this operation with a provider that supports per-run subagents."
+          }
+        };
+      }
+      return runCli(buildCodexExecRequest(spec), hooks);
+    }
+  };
+}
+var codexHarnessProvider = createCodexHarnessProvider();
+function buildCodexExecRequest(spec) {
+  const unsupported = unsupportedCodexSpecFields(spec);
+  if (unsupported.length > 0) {
+    throw new Error(
+      `Codex exec adapter does not support: ${unsupported.join(", ")}`
+    );
+  }
+  const args = [
+    "exec",
+    "--json",
+    "--sandbox",
+    "workspace-write",
+    "--skip-git-repo-check",
+    "-C",
+    spec.cwd
+  ];
+  if (spec.provider.model !== void 0 && spec.provider.model.length > 0) {
+    args.push("--model", spec.provider.model);
+  }
+  if (spec.output?.schemaPath !== void 0) {
+    args.push("--output-schema", spec.output.schemaPath);
+  }
+  args.push(combineCodexPrompt(spec));
+  return {
+    command: "codex",
+    args,
+    cwd: spec.cwd,
+    env: {
+      ...process.env,
+      CODEALMANAC_INTERNAL_SESSION: "1"
+    }
+  };
+}
+function unsupportedCodexSpecFields(spec) {
+  const unsupported = [];
+  if (spec.provider.effort !== void 0) unsupported.push("provider.effort");
+  if (spec.skills !== void 0 && spec.skills.length > 0) unsupported.push("skills");
+  if (spec.mcpServers !== void 0 && Object.keys(spec.mcpServers).length > 0) {
+    unsupported.push("mcpServers");
+  }
+  if (spec.limits?.maxCostUsd !== void 0) unsupported.push("limits.maxCostUsd");
+  return unsupported;
+}
+function combineCodexPrompt(spec) {
+  const blocks = [spec.systemPrompt, spec.prompt].filter(
+    (block) => block !== void 0 && block.trim().length > 0
+  );
+  return blocks.join("\n\n---\n\n");
+}
+function runCodexCli(request, hooks) {
+  return new Promise((resolve) => {
+    const child = spawn(request.command, request.args, {
+      cwd: request.cwd,
+      env: request.env,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdoutBuf = "";
+    let stderr = "";
+    const state = {
+      success: false,
+      result: ""
+    };
+    const eventWrites = [];
+    const observe = (msg) => {
+      eventWrites.push(applyCodexJsonlEvent(state, msg, hooks));
+    };
+    const flushLines = () => {
+      let idx = stdoutBuf.indexOf("\n");
+      while (idx !== -1) {
+        const rawLine = stdoutBuf.slice(0, idx);
+        stdoutBuf = stdoutBuf.slice(idx + 1);
+        const line = rawLine.trim();
+        if (line.length > 0) {
+          try {
+            observe(JSON.parse(line));
+          } catch {
+          }
+        }
+        idx = stdoutBuf.indexOf("\n");
+      }
+    };
+    child.stdout.on("data", (chunk) => {
+      stdoutBuf += chunk.toString("utf8");
+      flushLines();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+    });
+    child.on("error", (err) => {
+      resolve({
+        success: false,
+        result: state.result,
+        providerSessionId: state.providerSessionId,
+        turns: state.turns,
+        usage: state.usage,
+        error: err.code === "ENOENT" ? `${request.command} not found on PATH` : err.message
+      });
+    });
+    child.on("close", async (code) => {
+      flushLines();
+      if (stdoutBuf.trim().length > 0) {
+        try {
+          observe(JSON.parse(stdoutBuf.trim()));
+        } catch {
+        }
+      }
+      await Promise.allSettled(eventWrites);
+      if (code === 0 && state.success) {
+        resolve(toHarnessResult(state));
+        return;
+      }
+      const firstStderr = stderr.trim().split("\n")[0];
+      const fallbackError = firstStderr !== void 0 && firstStderr.length > 0 ? firstStderr : `${request.command} exited ${code ?? 1}`;
+      const failure = state.failure ?? classifyCodexFailure(fallbackError);
+      resolve({
+        ...toHarnessResult(state),
+        success: false,
+        error: state.error ?? failure.message,
+        failure
+      });
+    });
+  });
+}
+async function applyCodexJsonlEvent(state, input, hooks) {
+  const msg = unwrapCodexJsonlEvent(input);
+  const sessionId = stringField(msg, "session_id") ?? stringField(msg, "thread_id");
+  if (state.providerSessionId === void 0 && sessionId !== void 0) {
+    state.providerSessionId = sessionId;
+  }
+  if (msg.type === "item.completed") {
+    const item = objectField(msg, "item");
+    if (item?.type === "agent_message") {
+      const text = stringField(item, "text");
+      if (text !== void 0) {
+        state.result = text;
+        await hooks?.onEvent?.({ type: "text", content: text });
+      }
+    }
+    if (item?.type === "tool_call") {
+      await emitToolUse(item, hooks);
+    }
+    return;
+  }
+  if (msg.type === "turn.completed") {
+    state.success = true;
+    state.turns = 1;
+    state.usage = parseCodexUsage(msg.usage);
+    await hooks?.onEvent?.({
+      type: "done",
+      result: state.result,
+      providerSessionId: state.providerSessionId,
+      turns: state.turns,
+      usage: state.usage
+    });
+    return;
+  }
+  if (msg.type === "turn.failed" || msg.type === "error") {
+    state.success = false;
+    const raw = stringField(msg, "message") ?? stringField(msg, "error") ?? "codex turn failed";
+    const failure = classifyCodexFailure(raw);
+    state.error = failure.message;
+    state.failure = failure;
+    await hooks?.onEvent?.({
+      type: "error",
+      error: state.error,
+      failure
+    });
+  }
+}
+function toHarnessResult(state) {
+  return {
+    success: state.success,
+    result: state.result,
+    providerSessionId: state.providerSessionId,
+    turns: state.turns,
+    usage: state.usage,
+    error: state.error,
+    failure: state.failure
+  };
+}
+function unwrapCodexJsonlEvent(input) {
+  const msg = objectField(input, "msg");
+  return msg ?? input;
+}
+function classifyCodexFailure(raw) {
+  const detail = extractJsonDetail(raw);
+  const text = detail ?? raw;
+  const statusCode = extractStatusCode(raw);
+  const model = matchFirst(text, /The '([^']+)' model requires a newer version of Codex/) ?? matchFirst(text, /The '([^']+)' model is not supported/);
+  if (text.includes("requires a newer version of Codex") && model !== void 0) {
+    return {
+      provider: "codex",
+      code: "codex.model_requires_newer_cli",
+      message: `Codex model ${model} requires a newer Codex CLI.`,
+      fix: "Upgrade Codex, or run with --using codex/<supported-model>.",
+      raw,
+      details: codexFailureDetails({ model, statusCode })
+    };
+  }
+  if (text.includes("model is not supported") && model !== void 0) {
+    return {
+      provider: "codex",
+      code: "codex.model_unavailable",
+      message: `Codex model ${model} is not available for this account.`,
+      fix: "Choose a supported model with --using codex/<model>, or update the configured Codex model.",
+      raw,
+      details: codexFailureDetails({ model, statusCode })
+    };
+  }
+  if (text.includes("401 Unauthorized") || text.includes("Unauthorized")) {
+    return {
+      provider: "codex",
+      code: "codex.not_authenticated",
+      message: "Codex is not authenticated in this environment.",
+      fix: "Run `codex login` in the same environment, or make the existing Codex auth available to this process.",
+      raw,
+      details: codexFailureDetails({ statusCode: statusCode ?? 401 })
+    };
+  }
+  if (text.includes("not found on PATH")) {
+    return {
+      provider: "codex",
+      code: "codex.not_installed",
+      message: "Codex was not found on PATH.",
+      fix: "Install Codex or update PATH so the `codex` command is available.",
+      raw
+    };
+  }
+  return {
+    provider: "codex",
+    code: "codex.process_failed",
+    message: text,
+    raw,
+    details: codexFailureDetails({ statusCode })
+  };
+}
+function codexFailureDetails(details) {
+  const pruned = pruneUndefined2(details);
+  return Object.keys(pruned).length > 0 ? pruned : void 0;
+}
+function extractJsonDetail(raw) {
+  const start = raw.indexOf("{");
+  const end = raw.lastIndexOf("}");
+  if (start === -1 || end <= start) return void 0;
+  try {
+    const parsed = JSON.parse(raw.slice(start, end + 1));
+    if (parsed !== null && typeof parsed === "object") {
+      const detail = parsed.detail;
+      return typeof detail === "string" && detail.length > 0 ? detail : void 0;
+    }
+  } catch {
+    return void 0;
+  }
+  return void 0;
+}
+function extractStatusCode(raw) {
+  const match = raw.match(/status\s+(\d{3})|(\d{3})\s+(?:Bad Request|Unauthorized)/);
+  if (match === null) return void 0;
+  const value = match[1] ?? match[2];
+  return value !== void 0 ? Number.parseInt(value, 10) : void 0;
+}
+function matchFirst(text, pattern) {
+  const match = text.match(pattern);
+  return match?.[1];
+}
+async function emitToolUse(item, hooks) {
+  const tool = stringField(item, "name") ?? stringField(item, "tool_name");
+  if (tool === void 0) return;
+  await hooks?.onEvent?.({
+    type: "tool_use",
+    id: stringField(item, "id"),
+    tool,
+    input: stringifyInput2(item.input ?? item.arguments)
+  });
+}
+function parseCodexUsage(value) {
+  if (value === null || typeof value !== "object") return void 0;
+  const obj = value;
+  const inputTokens = numberField2(obj, "input_tokens") ?? numberField2(obj, "inputTokens");
+  const cachedInputTokens = numberField2(obj, "cached_input_tokens") ?? numberField2(obj, "cachedInputTokens") ?? numberField2(obj, "cacheReadTokens");
+  const outputTokens = numberField2(obj, "output_tokens") ?? numberField2(obj, "outputTokens");
+  const reasoningOutputTokens = numberField2(obj, "reasoning_output_tokens") ?? numberField2(obj, "reasoningOutputTokens");
+  return pruneUndefined2({
+    inputTokens,
+    cachedInputTokens,
+    outputTokens,
+    reasoningOutputTokens,
+    totalTokens: inputTokens !== void 0 || outputTokens !== void 0 ? (inputTokens ?? 0) + (outputTokens ?? 0) : void 0
+  });
+}
+function objectField(record, field) {
+  const value = record[field];
+  return value !== null && typeof value === "object" ? value : void 0;
+}
+function stringField(record, field) {
+  const value = record[field];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function numberField2(record, field) {
+  const value = record[field];
+  return typeof value === "number" ? value : void 0;
+}
+function stringifyInput2(input) {
+  if (input === void 0) return void 0;
+  if (typeof input === "string") return input;
+  try {
+    return JSON.stringify(input);
+  } catch {
+    return String(input);
+  }
+}
+function pruneUndefined2(value) {
+  for (const key of Object.keys(value)) {
+    if (value[key] === void 0) {
+      delete value[key];
+    }
+  }
+  return value;
+}
+function defaultCommandExists(command) {
+  const result = spawnSync("sh", ["-lc", `command -v ${command}`], {
+    encoding: "utf8"
+  });
+  return result.status === 0 && result.stdout.trim().length > 0;
+}
+function defaultRunStatus(command, args) {
+  return new Promise((resolve) => {
+    let child;
+    let stdout = "";
+    let stderr = "";
+    try {
+      child = spawn(command, args, { stdio: ["ignore", "pipe", "pipe"] });
+    } catch (err) {
+      resolve({
+        ok: false,
+        detail: err instanceof Error ? err.message : String(err)
+      });
+      return;
+    }
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+    });
+    child.on("error", (err) => {
+      resolve({ ok: false, detail: err.message });
+    });
+    child.on("close", (code) => {
+      const text = `${stdout}
+${stderr}`.trim();
+      resolve({
+        ok: code === 0,
+        detail: text.split("\n").find((line) => line.trim().length > 0)?.trim() ?? (code === 0 ? "ready" : `${command} exited ${code ?? 1}`)
+      });
+    });
+  });
+}
+
+// src/harness/providers/not-implemented.ts
+function createNotImplementedProvider(metadata) {
+  return {
+    metadata,
+    checkStatus: async () => ({
+      id: metadata.id,
+      installed: false,
+      authenticated: false,
+      detail: `${metadata.displayName} harness adapter is not implemented yet`
+    }),
+    run: async (spec) => ({
+      success: false,
+      result: "",
+      error: `${metadata.displayName} harness adapter is not implemented yet for ${spec.metadata?.operation ?? "unknown"} runs`
+    })
+  };
+}
+
+// src/harness/providers/cursor.ts
+var cursorHarnessProvider = createNotImplementedProvider(
+  HARNESS_PROVIDER_METADATA.cursor
+);
+
+// src/harness/providers/index.ts
+var HARNESS_PROVIDERS = {
+  claude: claudeHarnessProvider,
+  codex: codexHarnessProvider,
+  cursor: cursorHarnessProvider
+};
+function getHarnessProvider(id) {
+  return HARNESS_PROVIDERS[id];
+}
+
+// src/process/records.ts
+import { existsSync } from "fs";
+import { mkdir as mkdir2, readFile, readdir, rename, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname2, join } from "path";
+function runsDir(repoRoot) {
+  return join(getRepoAlmanacDir(repoRoot), "runs");
+}
+function runRecordPath(repoRoot, runId) {
+  return join(runsDir(repoRoot), `${runId}.json`);
+}
+function runLogPath(repoRoot, runId) {
+  return join(runsDir(repoRoot), `${runId}.jsonl`);
+}
+function runCancelPath(repoRoot, runId) {
+  return join(runsDir(repoRoot), `${runId}.cancel`);
+}
+async function markRunCancelled(repoRoot, runId) {
+  const path = runCancelPath(repoRoot, runId);
+  await mkdir2(dirname2(path), { recursive: true });
+  await writeFile2(path, "cancelled\n", "utf8");
+}
+function isRunCancellationRequested(repoRoot, runId) {
+  return existsSync(runCancelPath(repoRoot, runId));
+}
+async function writeRunRecord(path, record) {
+  await mkdir2(dirname2(path), { recursive: true });
+  const tmp = `${path}.tmp-${process.pid}`;
+  await writeFile2(tmp, `${JSON.stringify(record, null, 2)}
+`, "utf8");
+  await rename(tmp, path);
+}
+function buildStartedRunRecord(args) {
+  return {
+    version: 1,
+    id: args.runId,
+    operation: args.spec.metadata?.operation ?? "absorb",
+    status: "running",
+    repoRoot: args.repoRoot,
+    pid: args.pid ?? process.pid,
+    provider: args.spec.provider.id,
+    model: args.spec.provider.model,
+    startedAt: args.startedAt.toISOString(),
+    logPath: runLogPath(args.repoRoot, args.runId),
+    targetKind: args.spec.metadata?.targetKind,
+    targetPaths: args.spec.metadata?.targetPaths
+  };
+}
+function buildQueuedRunRecord(args) {
+  return {
+    ...buildStartedRunRecord({
+      runId: args.runId,
+      repoRoot: args.repoRoot,
+      spec: args.spec,
+      startedAt: args.queuedAt,
+      pid: 0
+    }),
+    status: "queued"
+  };
+}
+function finishRunRecord(args) {
+  const started = Date.parse(args.record.startedAt);
+  const finished = args.finishedAt.getTime();
+  return {
+    ...args.record,
+    status: args.status,
+    providerSessionId: args.providerSessionId ?? args.record.providerSessionId,
+    finishedAt: args.finishedAt.toISOString(),
+    durationMs: Number.isFinite(started) ? Math.max(0, finished - started) : void 0,
+    summary: args.summary,
+    error: args.error,
+    failure: args.failure
+  };
+}
+async function readRunRecord(path) {
+  try {
+    const parsed = JSON.parse(await readFile(path, "utf8"));
+    return isRunRecord(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+async function listRunRecords(repoRoot) {
+  const dir = runsDir(repoRoot);
+  if (!existsSync(dir)) return [];
+  let entries;
+  try {
+    entries = await readdir(dir);
+  } catch {
+    return [];
+  }
+  const records = [];
+  for (const entry of entries) {
+    if (!entry.startsWith("run_") || !entry.endsWith(".json")) continue;
+    const record = await readRunRecord(join(dir, entry));
+    if (record !== null) records.push(record);
+  }
+  return records.sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+}
+function toRunView(args) {
+  const started = Date.parse(args.record.startedAt);
+  const finished = args.record.finishedAt !== void 0 ? Date.parse(args.record.finishedAt) : void 0;
+  const elapsedMs = args.record.durationMs ?? (Number.isFinite(started) ? Math.max(0, (finished ?? args.now.getTime()) - started) : 0);
+  const displayStatus = args.record.status === "running" && !args.isPidAlive(args.record.pid) ? "stale" : args.record.status;
+  return {
+    ...args.record,
+    displayStatus,
+    elapsedMs,
+    error: displayStatus === "stale" ? "process ended without a final status" : args.record.error
+  };
+}
+function isRunRecord(value) {
+  if (value === null || typeof value !== "object") return false;
+  const v = value;
+  return v.version === 1 && typeof v.id === "string" && v.id.startsWith("run_") && (v.operation === "build" || v.operation === "absorb" || v.operation === "garden") && (v.status === "queued" || v.status === "running" || v.status === "done" || v.status === "failed" || v.status === "cancelled") && typeof v.repoRoot === "string" && typeof v.pid === "number" && (v.provider === "claude" || v.provider === "codex" || v.provider === "cursor") && typeof v.startedAt === "string" && typeof v.logPath === "string";
+}
+
+// src/process/snapshots.ts
+import { createHash } from "crypto";
+import { existsSync as existsSync2, statSync } from "fs";
+import { readFile as readFile2, readdir as readdir2 } from "fs/promises";
+import { join as join2 } from "path";
+async function snapshotPages(pagesDir) {
+  const out = /* @__PURE__ */ new Map();
+  if (!existsSync2(pagesDir)) return out;
+  let entries;
+  try {
+    entries = await readdir2(pagesDir);
+  } catch {
+    return out;
+  }
+  for (const entry of entries) {
+    if (!entry.endsWith(".md")) continue;
+    const slug = entry.slice(0, -3);
+    const full = join2(pagesDir, entry);
+    try {
+      const st = statSync(full);
+      if (!st.isFile()) continue;
+      const content = await readFile2(full, "utf8");
+      out.set(slug, {
+        slug,
+        hash: createHash("sha256").update(content).digest("hex"),
+        archived: parseFrontmatter(content).archived_at !== null
+      });
+    } catch {
+      continue;
+    }
+  }
+  return out;
+}
+function diffPageSnapshots(before, after) {
+  let created = 0;
+  let updated = 0;
+  let archived = 0;
+  let deleted = 0;
+  for (const [slug, entry] of after) {
+    const prev = before.get(slug);
+    if (prev === void 0) {
+      created += 1;
+      continue;
+    }
+    if (prev.hash === entry.hash) continue;
+    if (!prev.archived && entry.archived) {
+      archived += 1;
+    } else {
+      updated += 1;
+    }
+  }
+  for (const slug of before.keys()) {
+    if (!after.has(slug)) deleted += 1;
+  }
+  return { created, updated, archived, deleted };
+}
+function isNoopPageDelta(delta) {
+  return delta.created === 0 && delta.updated === 0 && delta.archived === 0 && delta.deleted === 0;
+}
+
+// src/process/manager.ts
+async function startForegroundProcess(options) {
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  const runId = options.runId ?? createRunId(now());
+  const startedAt = now();
+  const recordPath = runRecordPath(options.repoRoot, runId);
+  const started = buildStartedRunRecord({
+    runId,
+    repoRoot: options.repoRoot,
+    spec: options.spec,
+    startedAt,
+    pid: options.pid
+  });
+  const preStart = await cancelledRecordIfRequested({
+    recordPath,
+    repoRoot: options.repoRoot,
+    runId,
+    fallback: started,
+    finishedAt: now()
+  });
+  if (preStart !== null) {
+    return {
+      runId,
+      record: preStart,
+      result: {
+        success: false,
+        result: "",
+        error: "run cancelled before start"
+      }
+    };
+  }
+  await writeRunRecord(recordPath, started);
+  await initializeRunLog(started.logPath);
+  const afterStart = await cancelledRecordIfRequested({
+    recordPath,
+    repoRoot: options.repoRoot,
+    runId,
+    fallback: started,
+    finishedAt: now()
+  });
+  if (afterStart !== null) {
+    return {
+      runId,
+      record: afterStart,
+      result: {
+        success: false,
+        result: "",
+        error: "run cancelled before start"
+      }
+    };
+  }
+  const harnessRun = options.harnessRun ?? ((spec, hooks) => getHarnessProvider(spec.provider.id).run(spec, hooks));
+  const eventWrites = [];
+  let result;
+  let finalRecord;
+  try {
+    const pagesDir = join3(options.repoRoot, ".almanac", "pages");
+    const before = await snapshotPages(pagesDir);
+    try {
+      result = await harnessRun(options.spec, {
+        onEvent: eventLogger(started.logPath, now, eventWrites, options.onEvent)
+      });
+    } catch (err) {
+      result = {
+        success: false,
+        result: "",
+        error: err instanceof Error ? err.message : String(err)
+      };
+      await appendRunEvent(started.logPath, {
+        type: "error",
+        error: result.error ?? "unknown error"
+      }, now());
+    }
+    await Promise.allSettled(eventWrites);
+    const after = await snapshotPages(pagesDir);
+    const delta = diffPageSnapshots(before, after);
+    if (result.success) {
+      await runIndexer({ repoRoot: options.repoRoot });
+    }
+    const summary = {
+      created: delta.created,
+      updated: delta.updated,
+      archived: delta.archived,
+      costUsd: result.costUsd,
+      turns: result.turns,
+      usage: result.usage
+    };
+    finalRecord = await finishUnlessCancelled({
+      recordPath,
+      fallback: started,
+      status: result.success ? "done" : "failed",
+      finishedAt: now(),
+      providerSessionId: result.providerSessionId,
+      summary,
+      error: result.error,
+      failure: result.failure
+    });
+  } catch (err) {
+    result = {
+      success: false,
+      result: "",
+      error: err instanceof Error ? err.message : String(err)
+    };
+    try {
+      await appendRunEvent(started.logPath, {
+        type: "error",
+        error: result.error ?? "unknown error"
+      }, now());
+    } catch {
+    }
+    await Promise.allSettled(eventWrites);
+    finalRecord = await finishUnlessCancelled({
+      recordPath,
+      fallback: started,
+      status: "failed",
+      finishedAt: now(),
+      error: result.error,
+      failure: result.failure
+    });
+  }
+  if (finalRecord.status === "cancelled" && result.success) {
+    result = {
+      success: false,
+      result: "",
+      error: "run cancelled before final status"
+    };
+  }
+  return { runId, record: finalRecord, result };
+}
+async function finishUnlessCancelled(args) {
+  const current = await readRunRecord(args.recordPath);
+  if (current?.status === "cancelled" || isRunCancellationRequested(args.fallback.repoRoot, args.fallback.id)) {
+    return finishCancelled({
+      recordPath: args.recordPath,
+      fallback: current ?? args.fallback,
+      finishedAt: args.finishedAt
+    });
+  }
+  const base = current ?? args.fallback;
+  const finished = finishRunRecord({
+    record: base,
+    status: args.status,
+    finishedAt: args.finishedAt,
+    providerSessionId: args.providerSessionId,
+    summary: args.summary,
+    error: args.error,
+    failure: args.failure
+  });
+  await writeRunRecord(args.recordPath, finished);
+  return finished;
+}
+async function cancelledRecordIfRequested(args) {
+  const current = await readRunRecord(args.recordPath);
+  if (current?.status !== "cancelled" && !isRunCancellationRequested(args.repoRoot, args.runId)) {
+    return null;
+  }
+  return finishCancelled({
+    recordPath: args.recordPath,
+    fallback: current ?? args.fallback,
+    finishedAt: args.finishedAt
+  });
+}
+async function finishCancelled(args) {
+  const cancelled = args.fallback.status === "cancelled" ? args.fallback : finishRunRecord({
+    record: args.fallback,
+    status: "cancelled",
+    finishedAt: args.finishedAt
+  });
+  await writeRunRecord(args.recordPath, cancelled);
+  return cancelled;
+}
+function eventLogger(path, now, writes, observer) {
+  return (event) => {
+    writes.push(appendRunEvent(path, event, now()));
+    if (observer !== void 0) {
+      writes.push(Promise.resolve(observer(event)));
+    }
+  };
+}
+
+// src/process/spec.ts
+import { mkdir as mkdir3, readFile as readFile3, rename as rename2, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname3, join as join4 } from "path";
+function runSpecPath(repoRoot, runId) {
+  return join4(runsDir(repoRoot), `${runId}.spec.json`);
+}
+async function writeRunSpec(repoRoot, runId, spec) {
+  const path = runSpecPath(repoRoot, runId);
+  await mkdir3(dirname3(path), { recursive: true });
+  const tmp = `${path}.tmp-${process.pid}`;
+  await writeFile3(tmp, `${JSON.stringify(spec, null, 2)}
+`, "utf8");
+  await rename2(tmp, path);
+}
+async function readRunSpec(repoRoot, runId) {
+  const parsed = JSON.parse(
+    await readFile3(runSpecPath(repoRoot, runId), "utf8")
+  );
+  if (!isAgentRunSpec(parsed)) {
+    throw new Error(`invalid run spec for ${runId}`);
+  }
+  return parsed;
+}
+function isAgentRunSpec(value) {
+  if (value === null || typeof value !== "object") return false;
+  const spec = value;
+  return spec.provider !== void 0 && typeof spec.provider === "object" && spec.provider !== null && isProviderId(spec.provider.id) && typeof spec.cwd === "string" && typeof spec.prompt === "string" && (spec.metadata === void 0 || typeof spec.metadata === "object" && spec.metadata !== null && (spec.metadata.operation === void 0 || isOperationKind(spec.metadata.operation)));
+}
+function isProviderId(value) {
+  return value === "claude" || value === "codex" || value === "cursor";
+}
+function isOperationKind(value) {
+  return value === "build" || value === "absorb" || value === "garden";
+}
+
+// src/process/background.ts
+async function startBackgroundProcess(options) {
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  const runId = options.runId ?? createRunId(now());
+  await writeRunSpec(options.repoRoot, runId, options.spec);
+  const recordPath = runRecordPath(options.repoRoot, runId);
+  const queued = buildQueuedRunRecord({
+    runId,
+    repoRoot: options.repoRoot,
+    spec: options.spec,
+    queuedAt: now()
+  });
+  await writeRunRecord(recordPath, queued);
+  await initializeRunLog(queued.logPath);
+  const entrypoint = options.entrypoint ?? process.argv[1];
+  if (entrypoint === void 0 || entrypoint.length === 0) {
+    const error = "cannot start background process without an entrypoint";
+    await writeRunRecord(
+      recordPath,
+      finishRunRecord({
+        record: queued,
+        status: "failed",
+        finishedAt: now(),
+        error
+      })
+    );
+    throw new Error(error);
+  }
+  const spawnFn = options.spawnBackground ?? defaultSpawnBackground;
+  let child;
+  try {
+    child = spawnFn({
+      command: process.execPath,
+      args: [entrypoint, "__run-job", runId],
+      cwd: options.repoRoot,
+      env: {
+        ...process.env,
+        CODEALMANAC_INTERNAL_SESSION: "1"
+      }
+    });
+  } catch (err) {
+    await writeRunRecord(
+      recordPath,
+      finishRunRecord({
+        record: queued,
+        status: "failed",
+        finishedAt: now(),
+        error: err instanceof Error ? err.message : String(err)
+      })
+    );
+    throw err;
+  }
+  child.unref?.();
+  const childPid = child.pid ?? 0;
+  return { runId, record: queued, childPid };
+}
+async function runBackgroundChild(options) {
+  const existing = await readRunRecord(runRecordPath(options.repoRoot, options.runId));
+  if (existing?.status === "cancelled") {
+    return {
+      runId: options.runId,
+      record: existing,
+      result: {
+        success: false,
+        result: "",
+        error: "run cancelled before start"
+      }
+    };
+  }
+  const spec = await readRunSpec(options.repoRoot, options.runId);
+  return startForegroundProcess({
+    repoRoot: options.repoRoot,
+    spec,
+    runId: options.runId,
+    now: options.now,
+    pid: options.pid,
+    onEvent: options.onEvent,
+    harnessRun: options.harnessRun
+  });
+}
+function defaultSpawnBackground(args) {
+  return spawn2(args.command, args.args, {
+    cwd: args.cwd,
+    env: args.env,
+    detached: true,
+    stdio: "ignore"
+  });
+}
+
+export {
+  createRunId,
+  initializeRunLog,
+  appendRunEvent,
+  runsDir,
+  runRecordPath,
+  runLogPath,
+  runCancelPath,
+  markRunCancelled,
+  isRunCancellationRequested,
+  writeRunRecord,
+  buildStartedRunRecord,
+  buildQueuedRunRecord,
+  finishRunRecord,
+  readRunRecord,
+  listRunRecords,
+  toRunView,
+  isRunRecord,
+  snapshotPages,
+  diffPageSnapshots,
+  isNoopPageDelta,
+  startForegroundProcess,
+  runSpecPath,
+  writeRunSpec,
+  readRunSpec,
+  startBackgroundProcess,
+  runBackgroundChild
+};
+//# sourceMappingURL=chunk-WL4UE7Q6.js.map