Pi Durable

1. Click Run. Each commit goes into storage before the transcript shows it.
2. Click Reset and Run. When bash shows output, click Kill process. Then click Reopen and resume(). The run continues without a click.
3. Set replay: "safe" on bash before bash starts. Do step 2 again. bash runs again. read keeps the default value, "unsafe".
4. Kill the process during the first answer, after a flush. The committed part stays in the transcript as an aborted answer.
5. Kill the process when a chunk is dashed. The harness loses only that chunk. A chunk is approximately 100 ms of output. A chunk of large tool output can be longer.

root.submit({ type: "input", content: "Deploy to staging", requestId: "deploy-7f3a" }, ctx)
// After a restart or a retry, the same requestId returns the stored submission.
// again.id === submission.id. Use harness.submission(id) to get it again and wait.

Each boundary adds all queued writes. By default, it also adds one steer. The end of a run also adds one follow-up. To add all queued steers or follow-ups at one time, set steeringMode: "all" or followUpMode: "all" in the harness settings. Use submission.abort() to remove a queued submission.

// The "pay" phase creates four Payment tasks that the checkout owns. Then it waits.
pay: async (task, runtime, ctx) => {
  await runtime.commit(async (tx) => {
    const payments = [];
    for (const card of task.input.cards)
      payments.push(await tx.createTask(Payment, { card }, { ownership: { kind: "task", taskId: task.id } }));
    return { status: "waiting", checkpoint: { phase: "decide", payments }, on: payments, policy: "failFast" };
  }, ctx);
},
// The abort handler of each Payment refunds its charge. Abort runs on child tasks first.

The outcome faulted shows that a task broke the task rules, for example with an error that it did not catch. If the harness aborts a task that no installed code can run, the task goes directly from pending or waiting to terminal, with the outcome orphaned.

const Todos = defineDoc<{ items: string[] }>({
  kind: "app.todos", version: 1, scope: "conversation",
  history: "rewindable", // "asOf" needs "rewindable": it reads old values
  fork: "asOf",  // what a fork starts with
  initial: () => ({ items: [] }),
});
await root.commit(async (tx) => { (await tx.doc(Todos, root.id)).items.push("write docs"); }, ctx);

Tokens in the next request:

settings: { compaction: {
  enabled: true,
  reserveTokens: 16384,     // above window - reserve, the next request waits for a compaction
  keepRecentTokens: 20000,  // roughly how much recent context stays verbatim
  backgroundTokens: 32768,  // this far below that, a compaction starts in the background
} }