projectinator 0.3.1 → 0.4.0

package/src/orchestrator.ts

@@ -1,310 +0,0 @@
-// Phase 4 — the Orchestrator. Runs a whole backlog end to end.
-//
-// - Topologically orders tasks by dependsOn (respects design->code->test->deploy).
-// - Threads handoff context: a task sees the final output of its dependencies.
-// - Runs a Tester -> Developer feedback loop, bounded by maxFeedbackRounds.
-// - Tracks cost and halts on the budget cap.
-//
-// The executor is INJECTED (RoleExecutor), so this entire control flow is testable
-// offline with a fake — no model, no spend. The real Pi executor lives in roles.ts.
-
-import {
-  TaskLimitError,
-  type RegistryEntry,
-  type RoleExecutor,
-  type RoutingPolicy,
-  type Task,
-  type TaskOutcome,
-} from "./types.js";
-import { route } from "./router.js";
-import { REGISTRY } from "./registry.js";
-
-/** Order tasks so every task comes after its dependencies. Throws on a cycle. */
-export function toposort(tasks: Task[]): Task[] {
-  const byId = new Map(tasks.map((t) => [t.id, t]));
-  const state = new Map<string, "visiting" | "done">();
-  const out: Task[] = [];
-
-  const visit = (t: Task, trail: string[]) => {
-    const s = state.get(t.id);
-    if (s === "done") return;
-    if (s === "visiting") {
-      throw new Error(`Dependency cycle: ${[...trail, t.id].join(" -> ")}`);
-    }
-    state.set(t.id, "visiting");
-    for (const dep of t.dependsOn ?? []) {
-      const d = byId.get(dep);
-      if (d) visit(d, [...trail, t.id]); // unknown deps already stripped by normalize
-    }
-    state.set(t.id, "done");
-    out.push(t);
-  };
-
-  for (const t of tasks) visit(t, []);
-  return out;
-}
-
-export interface RunOptions {
-  policy: RoutingPolicy;
-  execute: RoleExecutor;
-  /** Registry to route against. Swap this to lock every role to one provider. */
-  registry?: RegistryEntry[];
-  onProgress?: (event: OrchestratorEvent) => void;
-  /** Prior outcomes to resume from (append-only record). Their tasks are skipped. */
-  seedOutcomes?: TaskOutcome[];
-  /** Called after each task settles, with the full record + running total, for persistence. */
-  onCheckpoint?: (outcomes: TaskOutcome[], totalCost: number) => void;
-  /** Max tasks to run at once. 1 (default) = sequential. >1 runs independent tasks in parallel. */
-  concurrency?: number;
-  /** Optional human gate before development begins (design done → dev). Resolve "stop" to halt. */
-  onGate?: (info: { stage: string }) => Promise<"continue" | "stop">;
-}
-
-export type OrchestratorEvent =
-  | { type: "task_start"; task: Task; round: number; provider: string; modelId: string }
-  | { type: "task_done"; outcome: TaskOutcome; runningTotal: number }
-  | { type: "task_failed"; outcome: TaskOutcome; runningTotal: number }
-  | { type: "task_skipped"; taskId: string }
-  | { type: "test_failed"; taskId: string; bugs: number; round: number }
-  | { type: "retry_dev"; taskId: string; forTest: string; round: number }
-  | { type: "budget_halt"; runningTotal: number; cap: number }
-  | { type: "gate"; stage: string }
-  | { type: "cycle_or_error"; message: string };
-
-export interface RunResult {
-  outcomes: TaskOutcome[];
-  totalCost: number;
-  halted: boolean;
-  haltReason?: string;
-}
-
-/** Build handoff text from a task's dependency outcomes. */
-function gatherContext(task: Task, outcomes: Map<string, TaskOutcome>): string {
-  const deps = task.dependsOn ?? [];
-  if (deps.length === 0) return "";
-  const parts: string[] = [];
-  for (const depId of deps) {
-    const o = outcomes.get(depId);
-    if (!o) continue;
-    const snippet = o.finalText.trim();
-    if (snippet) parts.push(`### From ${depId} (${o.capability}):\n${snippet}`);
-    if (o.files.length) parts.push(`### Files from ${depId}: ${o.files.join(", ")}`);
-  }
-  return parts.length ? `Context from upstream work:\n\n${parts.join("\n\n")}` : "";
-}
-
-function bugReport(bugs: { severity: string; description: string; file?: string }[]): string {
-  return [
-    "The tester found these issues. Fix them, then stop:",
-    ...bugs.map((b) => `- [${b.severity}]${b.file ? ` (${b.file})` : ""} ${b.description}`),
-  ].join("\n");
-}
-
-export async function runBacklog(tasks: Task[], opts: RunOptions): Promise<RunResult> {
-  const { policy, execute } = opts;
-  const registry = opts.registry ?? REGISTRY;
-  const byId = new Map(tasks.map((t) => [t.id, t]));
-  const outcomes = new Map<string, TaskOutcome>();
-  const record: TaskOutcome[] = [];
-  let running = 0;
-
-  // Resume: replay prior outcomes so finished tasks are skipped and cost is restored.
-  // A failed attempt is billed but never "done" — it is rebuilt.
-  const seed = opts.seedOutcomes ?? [];
-  for (const o of seed) {
-    record.push(o);
-    if (o.error) outcomes.delete(o.taskId); // last wins: a later failure voids an earlier pass
-    else outcomes.set(o.taskId, o);
-    running += o.cost;
-  }
-  running = round2(running);
-  const wasDone = new Set(outcomes.keys());
-
-  let halted = false;
-  let haltReason: string | undefined;
-
-  const emit = opts.onProgress ?? (() => {});
-  const checkpoint = () => opts.onCheckpoint?.(record, round2(running));
-
-  let ordered: Task[];
-  try {
-    ordered = toposort(tasks);
-  } catch (e) {
-    const message = e instanceof Error ? e.message : String(e);
-    emit({ type: "cycle_or_error", message });
-    return { outcomes: [], totalCost: 0, halted: true, haltReason: message };
-  }
-
-  const runOne = async (task: Task, round: number, contextOverride?: string): Promise<TaskOutcome> => {
-    const decision = route(task, { policy, registry, runningTotalBefore: running });
-    emit({ type: "task_start", task, round, provider: decision.provider, modelId: decision.model.id });
-    const contextText = contextOverride ?? gatherContext(task, outcomes);
-    const meta = { taskId: task.id, capability: task.capability, provider: decision.provider, modelId: decision.model.id, round };
-    let outcome: TaskOutcome;
-    try {
-      outcome = { ...(await execute({ task, decision, contextText, round, limits: policy.taskLimits })), ...meta };
-    } catch (e) {
-      if (!(e instanceof TaskLimitError)) throw e;
-      // Limit breach: bill what was spent, record the failure, halt the build.
-      outcome = { finalText: "", files: [], cost: e.costSoFar, error: e.message, ...meta };
-      running += outcome.cost;
-      record.push(outcome);
-      halted = true;
-      haltReason = `${task.id} aborted: ${e.message}`;
-      emit({ type: "task_failed", outcome, runningTotal: round2(running) });
-      return outcome;
-    }
-    running += outcome.cost;
-    outcomes.set(task.id, outcome);
-    record.push(outcome);
-    emit({ type: "task_done", outcome, runningTotal: round2(running) });
-    return outcome;
-  };
-
-  // One task's full lifecycle: run it, then its Reviewer/Tester -> Developer feedback loop.
-  const runTaskUnit = async (task: Task): Promise<void> => {
-    let outcome = await runOne(task, 0);
-    const judges = task.capability === "test" || task.capability === "review";
-    if (!outcome.error && judges && outcome.verdict && !outcome.verdict.passed) {
-      // The code to fix: direct code deps, plus code deps reached through a review
-      // (a test depends on the review, which depends on the code).
-      const codeDeps: Task[] = [];
-      for (const id of task.dependsOn ?? []) {
-        const dep = byId.get(id);
-        if (!dep) continue;
-        if (dep.capability === "code") codeDeps.push(dep);
-        else if (dep.capability === "review") {
-          for (const id2 of dep.dependsOn ?? []) {
-            const d2 = byId.get(id2);
-            if (d2?.capability === "code" && !codeDeps.includes(d2)) codeDeps.push(d2);
-          }
-        }
-      }
-
-      let round = 1;
-      fix: while (outcome.verdict && !outcome.verdict.passed && round <= policy.maxFeedbackRounds) {
-        emit({ type: "test_failed", taskId: task.id, bugs: outcome.verdict.bugs.length, round });
-        const fixContext = bugReport(outcome.verdict.bugs);
-        for (const dep of codeDeps) {
-          emit({ type: "retry_dev", taskId: dep.id, forTest: task.id, round });
-          if ((await runOne(dep, round, fixContext)).error) break fix;
-        }
-        outcome = await runOne(task, round); // re-test
-        if (outcome.error) break;
-        round++;
-      }
-    }
-    checkpoint();
-  };
-
-  // Human gate: pause once before the first development (code) task begins.
-  let gateDone = false;
-  const passGate = async (): Promise<boolean> => {
-    if (gateDone || !opts.onGate) return true;
-    gateDone = true;
-    emit({ type: "gate", stage: "design→dev" });
-    const decision = await opts.onGate({ stage: "design→dev" });
-    return decision !== "stop";
-  };
-
-  const concurrency = Math.max(1, Math.floor(opts.concurrency ?? 1));
-
-  // ---- sequential path (concurrency 1) — unchanged behavior ----
-  if (concurrency === 1) {
-    for (const task of ordered) {
-      if (wasDone.has(task.id)) {
-        emit({ type: "task_skipped", taskId: task.id });
-        continue;
-      }
-      if (task.capability === "code" && !(await passGate())) {
-        checkpoint();
-        return { outcomes: record, totalCost: round2(running), halted: true, haltReason: "stopped at review gate" };
-      }
-      const est = route(task, { policy, registry, runningTotalBefore: running });
-      if (est.overCap) {
-        emit({ type: "budget_halt", runningTotal: round2(running + est.cost), cap: policy.budgetCapUSD });
-        checkpoint();
-        return { outcomes: record, totalCost: round2(running), halted: true, haltReason: "budget cap" };
-      }
-      await runTaskUnit(task);
-      if (halted) return { outcomes: record, totalCost: round2(running), halted, haltReason };
-    }
-    return { outcomes: record, totalCost: round2(running), halted: false };
-  }
-
-  // ---- parallel path (concurrency > 1) — ready-set scheduler ----
-  // JS is single-threaded, so mutations between awaits are atomic (no locks needed).
-  // Independent tasks (deps satisfied) run concurrently up to `concurrency`. A budget
-  // reservation on in-flight estimates prevents launches that could cross the cap.
-  const remaining = new Set(ordered.filter((t) => !wasDone.has(t.id)).map((t) => t.id));
-  for (const id of wasDone) emit({ type: "task_skipped", taskId: id });
-
-  const inFlight = new Map<string, Promise<void>>();
-  let reserved = 0;
-  let codeInFlight = 0; // code tasks are serialized (they share files) even in parallel mode
-  let failure: unknown; // first task error; rethrown after in-flight work drains
-
-  const depsSatisfied = (t: Task) => (t.dependsOn ?? []).every((d) => !remaining.has(d));
-  const readyTasks = () =>
-    ordered.filter((t) => remaining.has(t.id) && !inFlight.has(t.id) && depsSatisfied(t));
-
-  while (remaining.size > 0 && !halted) {
-    // Gate before any development task launches.
-    if (!gateDone && opts.onGate && readyTasks().some((t) => t.capability === "code")) {
-      if (!(await passGate())) {
-        halted = true;
-        haltReason = "stopped at review gate";
-        break;
-      }
-    }
-    for (const task of readyTasks()) {
-      if (inFlight.size >= concurrency) break;
-      // Only one code task builds at a time — they write to the shared workspace.
-      if (task.capability === "code" && codeInFlight >= 1) continue;
-      // Reservations keep full precision: rounding each one to cents drops sub-cent
-      // estimates entirely, so a wide backlog of cheap tasks would under-reserve.
-      const est = route(task, { policy, registry, runningTotalBefore: running + reserved });
-      if (running + reserved + est.cost > policy.budgetCapUSD) {
-        if (inFlight.size === 0) {
-          emit({ type: "budget_halt", runningTotal: round2(running + est.cost), cap: policy.budgetCapUSD });
-          halted = true;
-          haltReason = "budget cap";
-        }
-        break; // wait for in-flight tasks to free budget/capacity
-      }
-      reserved += est.cost;
-      const cost = est.cost;
-      const isCode = task.capability === "code";
-      if (isCode) codeInFlight++;
-      const settle = () => {
-        if (isCode) codeInFlight--;
-        reserved -= cost;
-        remaining.delete(task.id);
-        inFlight.delete(task.id);
-      };
-      // A rejection must NOT escape through Promise.race below: that abandons the
-      // sibling promises, and their later rejections would have no handler attached
-      // (unhandled rejection -> the host process dies mid-build). Capture the first
-      // failure, stop launching, drain what's running, checkpoint, then rethrow.
-      const p = runTaskUnit(task).then(settle, (e: unknown) => {
-        settle();
-        halted = true;
-        haltReason ??= e instanceof Error ? e.message : String(e);
-        failure ??= e;
-      });
-      inFlight.set(task.id, p);
-    }
-
-    if (inFlight.size === 0) break; // nothing running and nothing launchable -> done or halted
-    await Promise.race(inFlight.values());
-  }
-
-  await Promise.all(inFlight.values());
-  checkpoint();
-  if (failure) throw failure;
-  return { outcomes: record, totalCost: round2(running), halted, haltReason };
-}
-
-function round2(n: number): number {
-  return Math.round(n * 100) / 100;
-}

package/src/pm.ts

@@ -1,302 +0,0 @@
-// Phase 3 — the PM / Decomposer.
-// Turns a one-line idea into a tagged backlog (epic -> story -> task).
-//
-// Structured output: Pi has none built in, so we force it. The PM model is given
-// exactly ONE tool — submit_backlog, whose typebox schema IS the backlog shape —
-// and must call it. That's far more reliable than parsing JSON out of prose.
-//
-// Token estimates are NOT asked of the model (it's bad at them); we fill them from
-// code buckets after decomposition. The PM only decomposes + tags.
-
-import {
-  createAgentSession,
-  defineTool,
-  type AgentSession,
-} from "@earendil-works/pi-coding-agent";
-import { Type, type Static } from "typebox";
-import type { Backend, Capability, Difficulty, Provider, Task } from "./types.js";
-import { estimateTokens } from "./estimate.js";
-import { findEntry } from "./registry.js";
-import { piRuntime, resolvePiModel } from "./executor.js";
-import { addSessionCost } from "./session-cost.js";
-
-// ---- typebox schema = the backlog contract ----
-// DELIBERATELY PERMISSIVE. A forced-tool call fails INVISIBLY if the args don't
-// validate (Pi rejects it, our capture never fires). So: flat list, only id/title/
-// capability/difficulty required, capability/difficulty as free strings (coerced in
-// code), extra fields allowed. We validate/clean afterwards instead of at the gate.
-const TaskSchema = Type.Object(
-  {
-    id: Type.String({ description: "Unique task id, e.g. T-01" }),
-    title: Type.String({ description: "One concrete, buildable unit of work" }),
-    capability: Type.String({ description: "one of: plan | design | code | review | test | ops" }),
-    difficulty: Type.String({ description: "one of: trivial | low | medium | high" }),
-    dependsOn: Type.Optional(Type.Array(Type.String(), { description: "task ids that must finish first" })),
-    epic: Type.Optional(Type.String({ description: "optional grouping label" })),
-    story: Type.Optional(Type.String({ description: "optional grouping label" })),
-  },
-  { additionalProperties: true },
-);
-const BacklogSchema = Type.Object({ tasks: Type.Array(TaskSchema) }, { additionalProperties: true });
-
-const CAPS = new Set<Capability>(["plan", "design", "code", "review", "test", "ops"]);
-const DIFFS = new Set<Difficulty>(["trivial", "low", "medium", "high"]);
-function coerceCap(s: string): Capability {
-  const v = s?.toLowerCase().trim() as Capability;
-  return CAPS.has(v) ? v : "code";
-}
-function coerceDiff(s: string): Difficulty {
-  const v = s?.toLowerCase().trim() as Difficulty;
-  return DIFFS.has(v) ? v : "medium";
-}
-
-export type Backlog = Static<typeof BacklogSchema>;
-export type BacklogTask = Static<typeof TaskSchema>;
-
-// ---- the capture tool ----
-export function buildBacklogTool() {
-  let captured: Backlog | undefined;
-  const tool = defineTool({
-    name: "submit_backlog",
-    label: "Submit Backlog",
-    description: "Submit the finished backlog as a flat list of tasks. Call this exactly once.",
-    parameters: BacklogSchema,
-    execute: async (_id, params) => {
-      captured = params as Backlog;
-      return { content: [{ type: "text", text: `Backlog received: ${params.tasks.length} tasks.` }], details: {} };
-    },
-  });
-  return { tool, get: () => captured };
-}
-
-export type Scope = "full" | "change";
-
-export function pmSystemPrompt(scope: Scope = "full"): string {
-  const sizing =
-    scope === "change"
-      ? [
-          "This is a CHANGE to an EXISTING project whose files are already on disk.",
-          "Produce the FEWEST tasks that accomplish the change — usually 1 code task plus 1",
-          "`review` task that dependsOn it (cheap read-only wiring check), plus 1 test task",
-          "(dependsOn the review) only if the change is risky. Do NOT re-plan the whole project,",
-          "do NOT add design/setup/deploy tasks. One small tweak = code + review.",
-        ]
-      : [
-          "Scale the number of tasks to the request. A tiny page = a few tasks; a full app = many.",
-          "Group tasks under EPICS (big features/areas of the product). Set every task's `epic`",
-          "field to its epic name, e.g. 'Hero section', 'Contact form', 'Deployment'. Aim for",
-          "2-5 tasks per epic. Do not pad: never split one obvious unit of work into multiple",
-          "tasks. Skip design/plan/ops tasks when the request clearly doesn't need them.",
-          "For a MULTI-FILE app: name the target file(s) in each code task's title (e.g. 'Build",
-          "src/components/Header.jsx') and keep file names CONSISTENT across tasks — decide one",
-          "structure and reuse it. When several files must agree, add ONE early design task that",
-          "defines the file tree, and have the code tasks depend on it.",
-          "After EVERY code task add one `review` task that dependsOn that code task (a cheap",
-          "read-only wiring check). The test task must dependsOn the review task(s), not the code",
-          "task(s) directly. Order: design -> code -> review -> test.",
-        ];
-  return [
-    "You are the PROJECT MANAGER on an autonomous software team.",
-    "Break the user's request into a flat list of tasks.",
-    ...sizing,
-    "",
-    "Each TASK must be:",
-    "- atomic: one model can complete it in one focused turn",
-    "- tagged with a capability: plan | design | code | review | test | ops",
-    "- tagged with a difficulty: trivial | low | medium | high (how hard the thinking is)",
-    "Optional per task: dependsOn (ids that must finish first, e.g. code depends on design),",
-    "and epic/story labels for grouping. Use ids like T-01, unique across the list.",
-    "Order matters: a design task should precede the code task that implements it; tests come after code.",
-    "",
-    "CRITICAL: You have exactly ONE tool — submit_backlog — and you MUST call it with a",
-    "`tasks` array. Never reply with prose. Never ask the user a question. If anything is",
-    "unclear, make a reasonable assumption (e.g. the main file is index.html) and submit.",
-    "Always produce at least one task. Call submit_backlog exactly once.",
-  ].join("\n");
-}
-
-// ---- pure post-processing (testable, no model) ----
-
-export interface NormalizeResult {
-  backlog: Backlog;
-  diagnostics: string[];
-}
-
-/** Clean a raw backlog: drop duplicate task ids, strip dangling dependsOn refs. */
-export function normalizeBacklog(raw: Backlog): NormalizeResult {
-  const diagnostics: string[] = [];
-  const seen = new Set<string>();
-  const allIds = new Set(raw.tasks.map((t) => t.id));
-
-  const tasks = raw.tasks
-    .filter((t) => {
-      if (seen.has(t.id)) {
-        diagnostics.push(`dropped duplicate task id ${t.id}`);
-        return false;
-      }
-      seen.add(t.id);
-      return true;
-    })
-    .map((t) => {
-      const deps = (t.dependsOn ?? []).filter((d) => {
-        if (!allIds.has(d)) {
-          diagnostics.push(`task ${t.id}: dropped dangling dependsOn ${d}`);
-          return false;
-        }
-        return true;
-      });
-      return { ...t, dependsOn: deps };
-    });
-  return { backlog: { tasks }, diagnostics };
-}
-
-/** Flatten a backlog to routable Tasks, coercing loose tags + filling token estimates. */
-export function flattenBacklog(backlog: Backlog): Task[] {
-  return backlog.tasks.map((t) => {
-    const capability = coerceCap(t.capability);
-    const difficulty = coerceDiff(t.difficulty);
-    return {
-      id: t.id,
-      title: t.title,
-      capability,
-      difficulty,
-      dependsOn: t.dependsOn ?? [],
-      epic: t.epic,
-      story: t.story,
-      estTokens: estimateTokens(capability, difficulty),
-    };
-  });
-}
-
-// ---- text fallback: parse a task list out of prose if the tool wasn't used ----
-
-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) => (typeof p === "string" ? p : p && typeof p === "object" && "text" in p ? String((p as { text: unknown }).text) : ""))
-        .join("");
-    }
-  }
-  return "";
-}
-
-/** Best-effort: pull a { tasks: [...] } (or a bare [...]) out of a model's text reply. */
-export function extractBacklogFromText(text: string): Backlog | undefined {
-  const tryParse = (s: string): Backlog | undefined => {
-    try {
-      const p = JSON.parse(s) as unknown;
-      if (Array.isArray(p)) return { tasks: p as Backlog["tasks"] };
-      if (p && typeof p === "object" && Array.isArray((p as { tasks?: unknown }).tasks)) return p as Backlog;
-    } catch {
-      /* not json */
-    }
-    return undefined;
-  };
-  const fence = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
-  const objMatch = text.match(/\{[\s\S]*"tasks"[\s\S]*\}/);
-  const arrMatch = text.match(/\[[\s\S]*\]/);
-  for (const c of [fence?.[1], objMatch?.[0], arrMatch?.[0]]) {
-    if (!c) continue;
-    const r = tryParse(c.trim());
-    if (r?.tasks?.length) return r;
-  }
-  return undefined;
-}
-
-// ---- live decomposition (calls the PM model, spends money) ----
-
-export interface DecomposeOptions {
-  backend: Backend;
-  thinkingLevel?: "off" | "low" | "medium" | "high";
-  onEvent?: Parameters<import("@earendil-works/pi-coding-agent").AgentSession["subscribe"]>[0];
-  /** Override the PM model (else resolved from registry plan/mid). */
-  modelOverride?: { provider: Provider; model: string };
-  /** "change" = minimal tasks against an existing project; "full" = a fresh build. */
-  scope?: Scope;
-  /** Summary of the existing project (files + contents) so the PM plans with real context. */
-  projectContext?: string;
-  /** Council-approved epics: organize ALL tasks under exactly these. */
-  epics?: { name: string; rationale: string }[];
-}
-
-export interface DecomposeResult {
-  provider: Provider;
-  modelId: string;
-  backlog: Backlog;
-  tasks: Task[];
-  diagnostics: string[];
-}
-
-export async function decomposeIdea(idea: string, opts: DecomposeOptions): Promise<DecomposeResult> {
-  const runtime = await piRuntime();
-
-  // PM = plan capability, mid tier — unless the caller overrides the model.
-  const { entry } = findEntry("plan", "mid");
-  const pick = opts.modelOverride ?? entry.byBackend[opts.backend];
-  const model = resolvePiModel(runtime, pick.provider, pick.model);
-
-  const { tool, get } = buildBacklogTool();
-  const { session } = await createAgentSession({
-    model,
-    modelRuntime: runtime,
-    thinkingLevel: opts.thinkingLevel ?? "medium",
-    noTools: "all",
-    customTools: [tool],
-    tools: ["submit_backlog"],
-  });
-
-  const unsub = opts.onEvent ? session.subscribe(opts.onEvent) : undefined;
-  try {
-    const ctx = opts.projectContext ? `\n\n--- EXISTING PROJECT (plan the change against this) ---\n${opts.projectContext}` : "";
-    const epicsBlock = opts.epics?.length
-      ? `\n\n--- APPROVED EPICS (organize ALL tasks under EXACTLY these; set each task's epic field to one of these names) ---\n${opts.epics.map((e) => `- ${e.name}: ${e.rationale}`).join("\n")}`
-      : "";
-    await session.prompt(`${pmSystemPrompt(opts.scope ?? "full")}${ctx}${epicsBlock}\n\n--- REQUEST ---\n${idea}`);
-    let raw = get();
-    // Nudge up to 3 times if the tool wasn't called (or its args failed validation).
-    for (let i = 0; i < 3 && !raw; i++) {
-      await session.prompt(
-        "You did not call submit_backlog successfully. Call submit_backlog NOW with a `tasks` " +
-          "array as the tool arguments. Do not write prose. Make reasonable assumptions if needed.",
-      );
-      raw = get();
-    }
-    // Last resort: the model may have printed the backlog as JSON text — parse it.
-    if (!raw) raw = extractBacklogFromText(lastAssistantText(session));
-    if (!raw || !raw.tasks?.length) {
-      const stats = session.getSessionStats();
-      if (stats.tokens.total === 0) {
-        // The provider call returned nothing — bad/inaccessible key, OR (very common)
-        // the account has no credit/balance so the API rejects the request.
-        throw new Error(
-          `The ${pick.provider} model returned nothing (0 tokens). Likely causes: the API key is invalid, ` +
-            `the account has no credit/balance, or the key lacks access to ${pick.model}. Add credit or set a ` +
-            `working key, or pick a different provider in Settings → Preferred provider.`,
-        );
-      }
-      const said = lastAssistantText(session).slice(0, 200).replace(/\s+/g, " ").trim();
-      throw new Error(
-        `The planner didn't return a task list.${said ? ` It said: "${said}…"` : ""} Try rephrasing the request.`,
-      );
-    }
-
-    const { backlog, diagnostics } = normalizeBacklog(raw);
-    return {
-      provider: pick.provider,
-      modelId: pick.model,
-      backlog,
-      tasks: flattenBacklog(backlog),
-      diagnostics,
-    };
-  } finally {
-    addSessionCost(session.getSessionStats().cost);
-    unsub?.();
-    session.dispose();
-  }
-}