Planning

const runAgent = async (client: Anthropic, task: string) => {
  // The entire goal exists in exactly one place — the first user message.
  // "Migrate every handler in src/routes from callback errors to Result<T, E>."
  const messages: Message[] = [
    { role: 'system', content: SYSTEM_PROMPT },
    { role: 'user', content: task },
  ];

  let response: Response | null = null;

  let steps = 0;
  const MAX_STEPS = 24;
  while (steps < MAX_STEPS) {
    steps++;
    const message = await client.messages.create({
      max_tokens: 4096,
      model: 'claude-haiku-4-5',
      messages,
    });

    messages.push({ role: 'assistant', content: message.content });
    response = extractResponse(message);

    // Nothing in this loop knows how many files the task named, or how many
    // of them have been touched. "Done" is whatever the model says it is.
    if (response?.finalAnswer === true) {
      console.log(response.content);
      break;
    }

    if (response?.finalAnswer === false && response.content.startsWith('edit_file:')) {
      const path = response.content.replace('edit_file:', '');
      messages.push({ role: 'tool', content: editFile(path) });
    }

    if (response?.finalAnswer === false && response.content.startsWith('build')) {
      // Green whether ten handlers were migrated or three: the old pattern is
      // still valid TypeScript, so nothing about it fails a build.
      messages.push({ role: 'tool', content: runBuild() });
    }
  }
};

$ npm run build

  ✓ compiled successfully in 3.1s
  0 errors, 0 warnings

$ rg -l 'cb\(err' src/routes | wc -l
  7

export type PlanStep = {
  id: string;
  what: string; // stated so "done" is decidable from outside the model
  dependsOn: string[]; // what actually blocks it — not the order it was written in
  done: boolean;
};

// The scope is enumerated once, up front, against the real directory — not
// re-derived at step nine from a transcript the goal is thirty messages back in.
export function buildPlan(handlers: string[]): PlanStep[] {
  const migrations = handlers.map((file, i) => ({
    id: `S${i + 2}`,
    what: `Migrate ${file} to Result<T, E>`,
    dependsOn: ['S1'],
    done: false,
  }));

  return [
    { id: 'S1', what: 'Add Result<T, E> and ok/err helpers to src/result.ts', dependsOn: [], done: false },
    ...migrations,
    {
      id: `S${handlers.length + 2}`,
      what: 'Delete the callback error helper in src/errors.ts',
      dependsOn: migrations.map((s) => s.id), // deletable only once nothing imports it
      done: false,
    },
  ];
}

export const remaining = (plan: PlanStep[]): PlanStep[] => plan.filter((s) => !s.done);

// The next step to hand the model is the next *unblocked* one, which is not
// always the next one on the list.
export const ready = (plan: PlanStep[]): PlanStep[] =>
  remaining(plan).filter((s) => s.dependsOn.every((id) => plan.find((p) => p.id === id)?.done === true));

export const check = (plan: PlanStep[], id: string): PlanStep[] =>
  plan.map((s) => (s.id === id ? { ...s, done: true } : s));

export const renderPlan = (plan: PlanStep[]): string =>
  plan.map((s) => `- [${s.done ? 'x' : ' '}] ${s.id} ${s.what}`).join('\n');

const runAgent = async (client: Anthropic, task: string) => {
  // Twelve steps, enumerated from the directory before the first edit.
  let plan = buildPlan(await listFiles('src/routes')); // 10 handlers

  const messages: Message[] = [
    { role: 'system', content: SYSTEM_PROMPT },
    { role: 'user', content: task },
  ];

  let response: Response | null = null;

  let steps = 0;
  const MAX_STEPS = 40;
  while (steps < MAX_STEPS) {
    steps++;

    // Re-stated every pass, so what is left is never further back than the
    // last message. The original ask decays into the transcript; this doesn't.
    messages.push({
      role: 'user',
      content: `${renderPlan(plan)}\n\nNext unblocked: ${ready(plan)[0]?.id ?? 'none'}`,
    });

    const message = await client.messages.create({
      max_tokens: 4096,
      model: 'claude-haiku-4-5',
      messages,
    });

    messages.push({ role: 'assistant', content: message.content });
    response = extractResponse(message);

    if (response?.finalAnswer === true) {
      const left = remaining(plan);
      if (left.length === 0) {
        console.log(response.content);
        break;
      }
      // Termination is a property of the plan, not of how finished the
      // transcript feels. Unchecked items are handed back by name.
      messages.push({
        role: 'tool',
        content: `Not done — ${left.length} of ${plan.length} steps unchecked: ${left.map((s) => s.id).join(', ')}`,
      });
      continue;
    }

    if (response?.finalAnswer === false && response.content.startsWith('edit_file:')) {
      const path = response.content.replace('edit_file:', '');
      messages.push({ role: 'tool', content: editFile(path) });
    }

    if (response?.finalAnswer === false && response.content.startsWith('check:')) {
      plan = check(plan, response.content.replace('check:', ''));
      messages.push({ role: 'tool', content: `${remaining(plan).length} steps remaining` });
    }
  }
};