projectinator 0.3.1 → 0.4.0

package/src/cost.ts

@@ -1,43 +0,0 @@
-// Cost estimation. Pure math over a token estimate + a model's price block.
-
-import type { Model, TokenEstimate } from "./types.js";
-
-const PER_MILLION = 1_000_000;
-
-/** Resolve the applicable input/output/cache rates, honoring volume tiers.
- *  Highest matching `inputTokensAbove` threshold wins (Pi semantics). */
-function ratesFor(model: Model, inputTokens: number) {
-  const base = model.cost;
-  let rate = { input: base.input, output: base.output, cacheRead: base.cacheRead ?? base.input };
-  for (const tier of base.tiers ?? []) {
-    if (inputTokens > tier.inputTokensAbove) {
-      rate = {
-        input: tier.input,
-        output: tier.output,
-        cacheRead: tier.cacheRead ?? tier.input,
-      };
-    }
-  }
-  return rate;
-}
-
-/** Estimate USD cost for one task on a given model.
- *  A fraction of input can be served from cache at the cheaper cacheRead rate.
- *  Kept to 4 decimals, not cents: a backlog of sub-cent tasks would otherwise
- *  estimate to $0.00 and under-reserve budget in the parallel scheduler. */
-export function estimateCost(est: TokenEstimate, model: Model): number {
-  const cachedFraction = clamp01(est.cachedInputFraction ?? 0);
-  const rate = ratesFor(model, est.input);
-
-  const freshInput = est.input * (1 - cachedFraction);
-  const cachedInput = est.input * cachedFraction;
-
-  const inputCost = (freshInput / PER_MILLION) * rate.input + (cachedInput / PER_MILLION) * rate.cacheRead;
-  const outputCost = (est.output / PER_MILLION) * rate.output;
-
-  return Math.round((inputCost + outputCost) * 10_000) / 10_000;
-}
-
-function clamp01(n: number): number {
-  return Math.max(0, Math.min(1, n));
-}

package/src/council.ts

@@ -1,175 +0,0 @@
-// Council planning (opt-in "deep plan"). Three perspectives propose epics from
-// different lenses in parallel, then a synthesizer merges them into one ordered
-// epic list. The user approves the epics; expansion into tasks happens after,
-// via the normal decomposer seeded with these epics.
-
-import {
-  createAgentSession,
-  defineTool,
-  type AgentSession,
-} from "@earendil-works/pi-coding-agent";
-import { Type, type Static } from "typebox";
-import type { Backend, Provider } from "./types.js";
-import { findEntry } from "./registry.js";
-import { piRuntime, resolvePiModel } from "./executor.js"
-import { addSessionCost } from "./session-cost.js";
-
-export interface Epic {
-  name: string;
-  rationale: string;
-}
-
-const EpicsSchema = Type.Object(
-  {
-    epics: Type.Array(
-      Type.Object(
-        { name: Type.String(), rationale: Type.String({ description: "one line: why this epic exists" }) },
-        { additionalProperties: true },
-      ),
-    ),
-  },
-  { additionalProperties: true },
-);
-type EpicsRaw = Static<typeof EpicsSchema>;
-
-function buildEpicsTool(toolName: string) {
-  let captured: EpicsRaw | undefined;
-  const tool = defineTool({
-    name: toolName,
-    label: "Submit Epics",
-    description: "Submit the epic list. Call exactly once.",
-    parameters: EpicsSchema,
-    execute: async (_id, params) => {
-      captured = params as EpicsRaw;
-      return { content: [{ type: "text", text: `Got ${params.epics.length} epics.` }], details: {} };
-    },
-  });
-  return { tool, get: () => captured };
-}
-
-function lastAssistantText(session: AgentSession): string {
-  const msgs = session.messages as Array<{ role?: string; content?: unknown }>;
-  for (let i = msgs.length - 1; i >= 0; i--) {
-    const m = msgs[i];
-    if (m?.role !== "assistant") continue;
-    const c = m.content;
-    if (typeof c === "string") return c;
-    if (Array.isArray(c)) return c.map((p: unknown) => (p && typeof p === "object" && "text" in p ? String((p as { text: unknown }).text) : "")).join("");
-  }
-  return "";
-}
-
-interface Ctx {
-  backend: Backend;
-  modelOverride?: { provider: Provider; model: string };
-}
-
-async function runEpicAgent(idea: string, system: string, toolName: string, ctx: Ctx): Promise<Epic[]> {
-  const runtime = await piRuntime();
-  const { entry } = findEntry("plan", "mid");
-  const pick = ctx.modelOverride ?? entry.byBackend[ctx.backend];
-  try {
-    const model = resolvePiModel(runtime, pick.provider, pick.model);
-    const { tool, get } = buildEpicsTool(toolName);
-    const { session } = await createAgentSession({
-      model,
-      modelRuntime: runtime,
-      thinkingLevel: "low",
-      noTools: "all",
-      customTools: [tool],
-      tools: [toolName],
-    });
-    try {
-      await session.prompt(`${system}\n\n--- REQUEST ---\n${idea}`);
-      let raw = get();
-      if (!raw) { await session.prompt(`Call ${toolName} now.`); raw = get(); }
-      addSessionCost(session.getSessionStats().cost);
-      return (raw?.epics ?? [])
-        .map((e) => ({ name: String(e.name ?? "").trim(), rationale: String(e.rationale ?? "").trim() }))
-        .filter((e) => e.name);
-    } finally {
-      session.dispose();
-    }
-  } catch {
-    return [];
-  }
-}
-
-const LENSES: { key: string; system: string }[] = [
-  {
-    key: "architect",
-    system:
-      "You are the ARCHITECT on a planning council. Propose the EPICS (big areas of work) for this build " +
-      "from a TECHNICAL structure lens — components, data, integration, scaffolding. 3-6 epics, each a short " +
-      "name + one-line rationale. Call submit_epics_architect once.",
-  },
-  {
-    key: "product",
-    system:
-      "You are the PRODUCT lead on a planning council. Propose the EPICS from a USER-VALUE lens — the features " +
-      "and flows a user needs, in priority order. 3-6 epics, each a short name + one-line rationale. Call " +
-      "submit_epics_product once.",
-  },
-  {
-    key: "risk",
-    system:
-      "You are the RISK/QA lead on a planning council. Propose the EPICS from a WHAT-COULD-GO-WRONG lens — " +
-      "validation, edge cases, error/empty states, testing, and anything easy to forget. 3-6 epics, each a " +
-      "short name + one-line rationale. Call submit_epics_risk once.",
-  },
-];
-
-const SYNTH_SYSTEM = [
-  "You are the PROJECT MANAGER chairing a planning council. Three leads proposed epics from different lenses",
-  "(architect, product, risk). Merge them into ONE clean, ordered epic list for the build: dedupe overlaps,",
-  "keep what matters, drop noise, and order them the way the work should proceed. Aim for 3-7 epics. Each epic:",
-  "a short name + a one-line rationale that folds in the strongest point(s) from the leads. Call submit_epics once.",
-].join("\n");
-
-export interface CouncilResult {
-  epics: Epic[];
-  proposals: { lens: string; epics: Epic[] }[];
-}
-
-/** Run the council: 3 lenses in parallel, then synthesize. Falls back to a single
- *  lens's epics if synthesis fails; empty only if everything fails. */
-export async function councilEpics(idea: string, ctx: Ctx): Promise<CouncilResult> {
-  const proposalsRaw = await Promise.all(
-    LENSES.map((l) => runEpicAgent(idea, l.system, `submit_epics_${l.key}`, ctx).then((epics) => ({ lens: l.key, epics }))),
-  );
-  const proposals = proposalsRaw.filter((p) => p.epics.length);
-  if (!proposals.length) return { epics: [], proposals: [] };
-
-  // Synthesize.
-  const runtime = await piRuntime();
-  const { entry } = findEntry("plan", "mid");
-  const pick = ctx.modelOverride ?? entry.byBackend[ctx.backend];
-  try {
-    const model = resolvePiModel(runtime, pick.provider, pick.model);
-    const { tool, get } = buildEpicsTool("submit_epics");
-    const { session } = await createAgentSession({
-      model, modelRuntime: runtime, thinkingLevel: "low",
-      noTools: "all", customTools: [tool], tools: ["submit_epics"],
-    });
-    try {
-      const block = proposals
-        .map((p) => `### ${p.lens}\n${p.epics.map((e) => `- ${e.name}: ${e.rationale}`).join("\n")}`)
-        .join("\n\n");
-      await session.prompt(`${SYNTH_SYSTEM}\n\n--- REQUEST ---\n${idea}\n\n--- LEAD PROPOSALS ---\n${block}`);
-      let raw = get();
-      if (!raw) { await session.prompt("Call submit_epics now."); raw = get(); }
-      addSessionCost(session.getSessionStats().cost);
-      const epics = (raw?.epics ?? [])
-        .map((e) => ({ name: String(e.name ?? "").trim(), rationale: String(e.rationale ?? "").trim() }))
-        .filter((e) => e.name);
-      // Fall back to the largest single proposal if synthesis produced nothing.
-      const best = proposals.slice().sort((a, b) => b.epics.length - a.epics.length)[0]!.epics;
-      return { epics: epics.length ? epics : best, proposals };
-    } finally {
-      session.dispose();
-    }
-  } catch {
-    const best = proposals.slice().sort((a, b) => b.epics.length - a.epics.length)[0]!.epics;
-    return { epics: best, proposals };
-  }
-}

package/src/demo.ts

@@ -1,106 +0,0 @@
-// Phase 1 demo — proves the brain before wiring any agents.
-// Feeds a fake "landing page + contact form" backlog through the router and prints
-// backend, model, and estimated cost per task, plus the total.
-//
-// Run: npm run demo            (cost-first / web backend)
-//      npm run demo -- api      (force API backend)
-//      npm run demo -- ask      (interactive-style; here stubbed to demonstrate)
-
-import { fileURLToPath } from "node:url";
-import { dirname, join } from "node:path";
-import type { RoutingPolicy, Task } from "./types.js";
-import { DEFAULT_POLICY, routeBacklog } from "./router.js";
-import { loadRegistry, OVERRIDES_FILENAME } from "./registry-store.js";
-
-const BACKLOG: Task[] = [
-  {
-    id: "T-01", epic: "E-1", story: "S-1", title: "Break brief into backlog",
-    capability: "plan", difficulty: "medium",
-    estTokens: { input: 10_000, output: 5_000 },
-  },
-  {
-    id: "T-02", epic: "E-1", story: "S-2", title: "Design hero + layout system",
-    capability: "design", difficulty: "high",
-    estTokens: { input: 20_000, output: 15_000 },
-  },
-  {
-    id: "T-03", epic: "E-2", story: "S-3", title: "Build page + contact form",
-    capability: "code", difficulty: "high", dependsOn: ["T-02"],
-    estTokens: { input: 400_000, output: 60_000, cachedInputFraction: 0.6 },
-  },
-  {
-    id: "T-04", epic: "E-2", story: "S-4", title: "Wire form handler",
-    capability: "code", difficulty: "low", dependsOn: ["T-03"],
-    estTokens: { input: 30_000, output: 8_000, cachedInputFraction: 0.5 },
-  },
-  {
-    id: "T-05", epic: "E-3", story: "S-5", title: "Review + test the build",
-    capability: "test", difficulty: "trivial", dependsOn: ["T-03", "T-04"],
-    estTokens: { input: 80_000, output: 15_000 },
-  },
-  {
-    id: "T-06", epic: "E-3", story: "S-6", title: "Run it, drive the CI/preview",
-    capability: "ops", difficulty: "high", dependsOn: ["T-04"],
-    estTokens: { input: 100_000, output: 20_000, cachedInputFraction: 0.4 },
-  },
-];
-
-const arg = process.argv[2];
-const policy: RoutingPolicy = { ...DEFAULT_POLICY };
-if (arg === "api") policy.backendMode = "api";
-if (arg === "web") policy.backendMode = "web";
-
-// For "ask" mode we'd wire real prompts; here we stub a chooser so the demo runs headless.
-const prompts =
-  arg === "ask"
-    ? {
-        chooseBackend: () => "api" as const,
-        chooseModel: (_t: Task, _e: unknown, _b: unknown) => undefined, // accept defaults
-      }
-    : undefined;
-if (arg === "ask") policy.backendMode = "ask";
-
-// Load the effective registry (seed + any Scout overrides), so applied Scout
-// changes are reflected here.
-const projectRoot = dirname(dirname(fileURLToPath(import.meta.url)));
-const registry = loadRegistry(join(projectRoot, OVERRIDES_FILENAME));
-
-const decisions = routeBacklog(BACKLOG, { policy, registry, prompts });
-
-const pad = (s: string, n: number) => s.padEnd(n);
-const money = (n: number) => `$${n.toFixed(2)}`;
-
-console.log(`\n  Projectinator — routing plan   [backendMode=${policy.backendMode}, cap=${money(policy.budgetCapUSD)}]\n`);
-console.log(
-  "  " +
-    pad("TASK", 7) + pad("CAPABILITY", 11) + pad("DIFF", 9) +
-    pad("BACKEND", 9) + pad("MODEL", 20) + pad("TIER", 6) + pad("COST", 9) + "RUNNING",
-);
-console.log("  " + "-".repeat(78));
-
-for (const d of decisions) {
-  const task = BACKLOG.find((t) => t.id === d.taskId)!;
-  const flag = d.overCap ? "  ⚠ OVER CAP" : "";
-  console.log(
-    "  " +
-      pad(d.taskId, 7) +
-      pad(task.capability, 11) +
-      pad(task.difficulty, 9) +
-      pad(d.backend, 9) +
-      pad(d.model.name, 20) +
-      pad(d.tier, 6) +
-      pad(money(d.cost), 9) +
-      money(d.runningTotal) +
-      flag,
-  );
-}
-
-const total = decisions.at(-1)?.runningTotal ?? 0;
-console.log("  " + "-".repeat(78));
-console.log(`  TOTAL ESTIMATED: ${money(total)}\n`);
-
-console.log("  Decision trail for T-03 (the developer task):");
-for (const r of decisions.find((d) => d.taskId === "T-03")!.reasons) {
-  console.log("    · " + r);
-}
-console.log("");

package/src/estimate.ts

@@ -1,111 +0,0 @@
-// Token estimation lives in CODE, not in the model.
-// The Phase 2 live run proved models estimate their own token use terribly
-// (a "high" single-file task used ~1.5k output, not the 12k a model guessed).
-// So the PM only tags capability + difficulty; we map that to a token budget here.
-//
-// CALIBRATION (2026-07-15) — retuned against real getSessionStats from live runs:
-//   Phase 2 dev (code, single-file): output ~1.5k, input almost entirely cached
-//     (fresh 4 of ~3.3k tokens).
-//   Phase 4 mini: design/low, code/low ~ $0.03-0.04 each; test/trivial ~ $0.02.
-// Takeaways baked in below:
-//   - a "task" is ONE atomic unit (a file / component / spec), not a whole feature,
-//     so outputs are small — and output dominates cost (priced ~5-6x input).
-//   - Pi caches context aggressively, so most input bills at the cheap cacheRead rate.
-// These stay heuristic; wire measured actuals back in for self-calibration later.
-
-import type { Capability, Difficulty, TokenEstimate } from "./types.js";
-import { calibratedTokens, allSamples } from "./calibration.js";
-
-type Bucket = { input: number; output: number };
-
-const BUCKETS: Record<Capability, Record<Difficulty, Bucket>> = {
-  plan: {
-    trivial: { input: 2_000, output: 800 },
-    low: { input: 4_000, output: 1_500 },
-    medium: { input: 8_000, output: 3_000 },
-    high: { input: 12_000, output: 5_000 },
-  },
-  design: {
-    trivial: { input: 4_000, output: 2_000 },
-    low: { input: 6_000, output: 3_500 },
-    medium: { input: 10_000, output: 6_000 },
-    high: { input: 15_000, output: 9_000 },
-  },
-  code: {
-    trivial: { input: 6_000, output: 1_500 },
-    low: { input: 10_000, output: 3_000 },
-    medium: { input: 25_000, output: 7_000 },
-    high: { input: 60_000, output: 14_000 },
-  },
-  // Review reads the same tree the tester does but never runs it — shorter output.
-  review: {
-    trivial: { input: 15_000, output: 800 },
-    low: { input: 25_000, output: 1_500 },
-    medium: { input: 50_000, output: 3_000 },
-    high: { input: 80_000, output: 5_000 },
-  },
-  test: {
-    trivial: { input: 15_000, output: 1_200 },
-    low: { input: 25_000, output: 2_500 },
-    medium: { input: 50_000, output: 5_000 },
-    high: { input: 80_000, output: 9_000 },
-  },
-  ops: {
-    trivial: { input: 10_000, output: 2_000 },
-    low: { input: 20_000, output: 4_000 },
-    medium: { input: 40_000, output: 7_000 },
-    high: { input: 70_000, output: 12_000 },
-  },
-};
-
-// Pi auto-caches system prompt + context aggressively (live run: fresh input 4 tokens
-// of ~3.3k). Real cached share is often 80-99%; 0.55 is a conservative planning value.
-const DEFAULT_CACHED_INPUT_FRACTION = 0.55;
-
-export function estimateTokens(capability: Capability, difficulty: Difficulty): TokenEstimate {
-  // Prefer the learned average once we have enough real samples; else the static bucket.
-  const learned = calibratedTokens(capability, difficulty);
-  if (learned) return learned;
-  const b = BUCKETS[capability][difficulty];
-  return { input: b.input, output: b.output, cachedInputFraction: DEFAULT_CACHED_INPUT_FRACTION };
-}
-
-/** The static baseline (pre-calibration) token budget for a bucket. */
-export function baselineTokens(capability: Capability, difficulty: Difficulty): Bucket {
-  return BUCKETS[capability][difficulty];
-}
-
-export interface AccuracyRow {
-  capability: Capability;
-  difficulty: Difficulty;
-  baseOutput: number;
-  actualOutput: number;
-  baseInput: number;
-  actualInput: number;
-  n: number;
-  active: boolean; // true once calibration overrides the baseline (enough samples)
-}
-
-/** Baseline vs measured tokens for every bucket that has real samples. */
-export function estimateAccuracy(): AccuracyRow[] {
-  const samples = allSamples();
-  const rows: AccuracyRow[] = [];
-  for (const cap of Object.keys(BUCKETS) as Capability[]) {
-    for (const diff of Object.keys(BUCKETS[cap]) as Difficulty[]) {
-      const s = samples[`${cap}/${diff}`];
-      if (!s) continue;
-      const b = BUCKETS[cap][diff];
-      rows.push({
-        capability: cap,
-        difficulty: diff,
-        baseOutput: b.output,
-        actualOutput: Math.round(s.output),
-        baseInput: b.input,
-        actualInput: Math.round(s.input),
-        n: s.n,
-        active: !!calibratedTokens(cap, diff),
-      });
-    }
-  }
-  return rows;
-}

package/src/executor.ts

@@ -1,169 +0,0 @@
-// Phase 2 — the Executor. Runs ONE task on a real Pi agent session with the model
-// the router chose. Writes real files to a workspace dir, then reads back Pi's own
-// token usage + cost so we can compare estimated vs actual.
-//
-// Constructing a session and resolving models is offline + free. Only session.prompt()
-// hits the provider API and spends money — that path is guarded by the caller.
-
-import {
-  ModelRuntime,
-  createAgentSession,
-  type AgentSession,
-  type AgentSessionEvent,
-} from "@earendil-works/pi-coding-agent";
-import { readdirSync, statSync } from "node:fs";
-import { join, relative } from "node:path";
-import type { Provider, RouteDecision, Task } from "./types.js";
-import { estimateCost } from "./cost.js";
-import { getModel } from "./models.js";
-import { addSessionCost } from "./session-cost.js";
-
-/** Pi's own Model type, derived so we don't depend on a deep sub-path import. */
-export type PiModel = NonNullable<ReturnType<ModelRuntime["getModel"]>>;
-
-/** Pi's model/auth runtime: built-in catalog + env keys / ~/.pi/agent/auth.json.
- *  Created per call on purpose — a key added in Settings must apply to the next session. */
-export function piRuntime(): Promise<ModelRuntime> {
-  return ModelRuntime.create();
-}
-
-/** Resolve a Projectinator (provider, modelId) to Pi's executable Model.
- *  Offline + free — reads Pi's built-in registry. Throws with a clear message
- *  if the id isn't one Pi knows (our ids are kept identical to Pi's on purpose). */
-export function resolvePiModel(
-  runtime: ModelRuntime,
-  provider: Provider,
-  modelId: string,
-): PiModel {
-  const m = runtime.getModel(provider, modelId);
-  if (!m) {
-    throw new Error(
-      `Pi has no model "${provider}/${modelId}". ` +
-        `Check src/models.ts uses Pi's exact built-in id.`,
-    );
-  }
-  return m;
-}
-
-export interface ExecuteOptions {
-  /** Directory the agent builds into (its cwd). */
-  workspace: string;
-  /** Extended-thinking level. Pi clamps to model capability. */
-  thinkingLevel?: "off" | "low" | "medium" | "high";
-  /** Optional progress hook — receives raw Pi session events. */
-  onEvent?: (event: AgentSessionEvent) => void;
-  /** Tools the agent may use. Default: the coding set. */
-  tools?: string[];
-}
-
-export interface ExecuteResult {
-  taskId: string;
-  provider: Provider;
-  modelId: string;
-  /** Files present in the workspace after the run (repo-relative). */
-  files: string[];
-  /** Pi's own measured usage for the run. */
-  actual: { input: number; output: number; cacheRead: number; cacheWrite: number; total: number };
-  /** Pi's own computed dollar cost. */
-  actualCost: number;
-  /** What we predicted before running, for calibration. */
-  estCost: number;
-  /** actualCost - estCost. Positive = we under-estimated. */
-  costDelta: number;
-}
-
-/** Build the Developer role's instruction for a single task. */
-export function buildDeveloperPrompt(task: Task): string {
-  return [
-    `You are the DEVELOPER on an autonomous build team. Complete exactly this task and nothing more.`,
-    ``,
-    `Task ${task.id}: ${task.title}`,
-    task.story ? `Story: ${task.story}` : ``,
-    ``,
-    `Rules:`,
-    `- Write real files into the current working directory using your file tools.`,
-    `- Keep it minimal and correct; no placeholders, no TODOs.`,
-    `- Do not explain at length. Build, then stop.`,
-  ]
-    .filter(Boolean)
-    .join("\n");
-}
-
-/**
- * Execute one task on a live Pi session. THIS SPENDS MONEY (session.prompt).
- * Caller is responsible for gating on a live flag + present API key.
- */
-export async function executeTask(
-  task: Task,
-  decision: RouteDecision,
-  opts: ExecuteOptions,
-): Promise<ExecuteResult> {
-  const runtime = await piRuntime();
-  const model = resolvePiModel(runtime, decision.provider, decision.model.id);
-
-  const { session } = await createAgentSession({
-    model,
-    cwd: opts.workspace,
-    modelRuntime: runtime,
-    thinkingLevel: opts.thinkingLevel ?? "medium",
-    tools: opts.tools ?? ["read", "write", "edit", "bash", "ls", "grep", "find"],
-  });
-
-  let unsubscribe: (() => void) | undefined;
-  if (opts.onEvent) unsubscribe = session.subscribe(opts.onEvent);
-
-  try {
-    await session.prompt(buildDeveloperPrompt(task));
-    const stats = session.getSessionStats();
-    addSessionCost(stats.cost);
-
-    const estCost = estimateCost(task.estTokens, getModel(decision.model.id));
-    const actualCost = round2(stats.cost);
-
-    return {
-      taskId: task.id,
-      provider: decision.provider,
-      modelId: decision.model.id,
-      files: listFiles(opts.workspace),
-      actual: {
-        input: stats.tokens.input,
-        output: stats.tokens.output,
-        cacheRead: stats.tokens.cacheRead,
-        cacheWrite: stats.tokens.cacheWrite,
-        total: stats.tokens.total,
-      },
-      actualCost,
-      estCost,
-      costDelta: round2(actualCost - estCost),
-    };
-  } finally {
-    unsubscribe?.();
-    session.dispose();
-  }
-}
-
-/** List files in a workspace, skipping Pi/session/VCS noise. */
-function listFiles(dir: string): string[] {
-  const out: string[] = [];
-  const skip = new Set([".pi", ".git", "node_modules"]);
-  const walk = (d: string) => {
-    let entries: string[];
-    try {
-      entries = readdirSync(d);
-    } catch {
-      return;
-    }
-    for (const name of entries) {
-      if (skip.has(name)) continue;
-      const full = join(d, name);
-      if (statSync(full).isDirectory()) walk(full);
-      else out.push(relative(dir, full));
-    }
-  };
-  walk(dir);
-  return out.sort();
-}
-
-function round2(n: number): number {
-  return Math.round(n * 100) / 100;
-}

package/src/git.ts

@@ -1,72 +0,0 @@
-// Git-per-build: init a repo in the build workspace and commit after each task,
-// so every build has history + diffs (and a foundation for undo). Best-effort —
-// if git isn't available or a command fails, builds carry on uninterrupted.
-
-import { spawnSync } from "node:child_process";
-import { existsSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-
-interface GitOut { ok: boolean; out: string; }
-
-function git(dir: string, args: string[]): GitOut {
-  try {
-    const r = spawnSync("git", args, { cwd: dir, encoding: "utf8" });
-    return { ok: r.status === 0, out: `${r.stdout ?? ""}${r.stderr ?? ""}`.trim() };
-  } catch {
-    return { ok: false, out: "" };
-  }
-}
-
-export function isRepo(dir: string): boolean {
-  return existsSync(join(dir, ".git"));
-}
-
-/** git init + a local identity + an initial commit. Idempotent. Returns success. */
-export function initRepo(dir: string): boolean {
-  if (isRepo(dir)) return true;
-  const gi = join(dir, ".gitignore");
-  if (!existsSync(gi)) writeFileSync(gi, ".deploy/\nbuild-state.json\nnode_modules/\n");
-  if (!git(dir, ["init"]).ok) return false;
-  // Local identity so commits work even when the user has no global git config.
-  git(dir, ["config", "user.email", "bot@projectinator.local"]);
-  git(dir, ["config", "user.name", "Projectinator"]);
-  git(dir, ["add", "-A"]);
-  git(dir, ["commit", "-m", "chore: initial workspace", "--allow-empty"]);
-  return true;
-}
-
-/** Commit whatever a task produced. Returns the short hash, or null on failure. */
-export function commitTask(dir: string, taskId: string, title: string): string | null {
-  if (!isRepo(dir)) return null;
-  git(dir, ["add", "-A"]);
-  const msg = `${taskId}: ${title}`.replace(/\s+/g, " ").slice(0, 72);
-  const c = git(dir, ["commit", "-m", msg, "--allow-empty"]);
-  if (!c.ok) return null;
-  const h = git(dir, ["rev-parse", "--short", "HEAD"]);
-  return h.ok ? h.out : null;
-}
-
-/** Hard-reset one commit back (undo the last task's file changes). Returns the
- *  reverted task id parsed from the commit message. Refuses to undo past the
- *  initial commit. */
-export function undoLastCommit(dir: string): { ok: boolean; taskId?: string } {
-  if (!isRepo(dir)) return { ok: false };
-  const commits = history(dir);
-  if (commits.length <= 1) return { ok: false }; // nothing but the initial commit
-  const taskId = (commits[0]?.msg.split(":")[0] ?? "").trim() || undefined;
-  const r = git(dir, ["reset", "--hard", "HEAD~1"]);
-  return { ok: r.ok, taskId };
-}
-
-export interface Commit { hash: string; msg: string; }
-
-/** Commit log, newest first. */
-export function history(dir: string): Commit[] {
-  if (!isRepo(dir)) return [];
-  const r = git(dir, ["log", "--oneline", "--no-decorate", "--no-color"]);
-  if (!r.ok || !r.out) return [];
-  return r.out.split("\n").filter(Boolean).map((line) => {
-    const i = line.indexOf(" ");
-    return i < 0 ? { hash: line, msg: "" } : { hash: line.slice(0, i), msg: line.slice(i + 1) };
-  });
-}