Memory

const runSession = async (client: Anthropic, task: string) => {
  // Every session starts from exactly these two messages. Nothing carries over.
  const messages: Message[] = [
    { role: 'system', content: SYSTEM_PROMPT },
    { role: 'user', content: task },
  ];

  let response: Response | null = null;

  let steps = 0;
  const MAX_STEPS = 12;
  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);

    if (response?.finalAnswer === true) {
      console.log(response.content);
      break;
    }

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

  // The session returns and `messages` goes out of scope. The correction the
  // engineer typed at step seven goes with it — tomorrow starts from those
  // same two messages and nothing else.
};

export type MemoryRecord = {
  id: string;
  scope: string[]; // what it applies to — matched against the task before recall
  rule: string; // what to do differently
  because: string; // why — the part that still holds on a case the rule never named
  evidence: string; // where it came from, so a later session can re-check it
  createdAt: string;
  lastConfirmedAt: string;
  supersededBy?: string;
};

const STALE_AFTER_DAYS = 90;
const store = openStore('.agent/memory.jsonl');

export function remember(draft: Pick<MemoryRecord, 'scope' | 'rule' | 'because' | 'evidence'>): MemoryRecord {
  const now = new Date().toISOString();
  const saved = { ...draft, id: newId(8), createdAt: now, lastConfirmedAt: now };
  store.append(saved);
  return saved;
}

export function recall(scope: string[], now = new Date()): MemoryRecord[] {
  // Matched against what this session is about to touch — not dumped wholesale.
  return store
    .all()
    .filter((r) => r.supersededBy === undefined)
    .filter((r) => r.scope.some((s) => scope.includes(s)))
    .filter((r) => daysSince(r.lastConfirmedAt, now) < STALE_AFTER_DAYS);
}

export function supersede(oldId: string, replacement: MemoryRecord): void {
  // A rule that stopped being true isn't deleted — it's pointed at the one
  // that replaced it, so a later session can see what changed and when.
  store.patch(oldId, { supersededBy: replacement.id });
}

const runSession = async (client: Anthropic, task: string, scope: string[]) => {
  // Read before doing anything, not after the mistake.
  const memories = recall(scope); // scope: ['repo:payments', 'tests:integration']

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

  let response: Response | null = null;

  let steps = 0;
  const MAX_STEPS = 12;
  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);

    if (response?.finalAnswer === true) {
      console.log(response.content);
      break;
    }

    // Written the moment a correction lands, while the reasoning behind it is
    // still in the window — a rule stored without its reason can't be applied
    // to the next case, only pattern-matched against the last one.
    if (response?.finalAnswer === false && response.content.startsWith('remember:')) {
      const draft = JSON.parse(response.content.replace('remember:', ''));
      const saved = remember({ scope, ...draft });
      messages.push({ role: 'tool', content: `remembered ${saved.id}` });
    }

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