@pi-unipi/unipi 3.0.0-alpha.2 → 3.0.0-alpha.21

package/packages/input-shortcuts/src/undo-redo.ts

@@ -1,74 +1,86 @@
 /**
- * In-memory ring buffer for undo/redo with debounce and throttle.
+ * Linear checkpoint history for the editor.
  *
- * - Max 50 snapshots in undo stack
- * - 500ms debounce on snapshot creation
- * - 1s throttle on undo
- * - Redo buffer cleared on new snapshot
+ * `states` is the ordered list of editor texts and `index` points at the
+ * current one; undo steps back, redo steps forward. `record` is idempotent
+ * for the current state, so a flush that re-records the text an undo just
+ * restored is a no-op — no suppress flags needed.
+ *
+ * Memory is bounded two ways: at most MAX_STATES checkpoints and at most
+ * MAX_CHARS characters in total (oldest evicted first, running char total,
+ * O(1) amortized per operation).
  */
 
-import type { TextSnapshot } from "./types.ts";
-import { MAX_UNDO_SNAPSHOTS, UNDO_DEBOUNCE_MS } from "./types.ts";
+export const MAX_STATES = 100;
+export const MAX_CHARS = 2_000_000;
 
-export interface UndoRedoResult {
+export interface HistoryResult {
   text: string;
   ok: boolean;
   reason?: string;
 }
 
-export class UndoRedoBuffer {
-  private undoStack: TextSnapshot[] = [];
-  private redoStack: TextSnapshot[] = [];
-  private lastSnapshotAt = 0;
+export class EditHistory {
+  private states: string[] = [];
+  private index = -1;
+  private chars = 0;
 
-  /**
-   * Take a snapshot of current text BEFORE it changes.
-   * Pushes to undo stack, clears redo stack.
-   * 500ms debounce: skips if last snapshot was within 500ms.
-   */
-  snapshot(text: string): void {
-    const now = Date.now();
-    if (now - this.lastSnapshotAt < UNDO_DEBOUNCE_MS) return;
-
-    this.undoStack.push({ text, timestamp: now });
-    if (this.undoStack.length > MAX_UNDO_SNAPSHOTS) {
-      this.undoStack.shift();
+  /** Commit `text` as the current state. No-op when it did not change. */
+  record(text: string): void {
+    if (this.index >= 0 && this.states[this.index] === text) return;
+    // Anything after the current state was redone-able — a new edit kills it.
+    for (let i = this.index + 1; i < this.states.length; i++) {
+      this.chars -= this.states[i]!.length;
     }
-    this.redoStack = [];
-    this.lastSnapshotAt = now;
+    this.states.length = this.index + 1;
+    this.states.push(text);
+    this.chars += text.length;
+    this.index = this.states.length - 1;
+    this.evict();
   }
 
   /**
-   * Undo: pop from undo stack, push current text to redo.
+   * Step back. `current` is recorded first so un-flushed typing since the
+   * last burst is not lost — then the previous state is returned.
    */
-  undo(currentText: string): UndoRedoResult {
-    if (this.undoStack.length === 0) {
-      return { text: currentText, ok: false, reason: "nothing to undo" };
+  undo(current: string): HistoryResult {
+    this.record(current);
+    if (this.index <= 0) {
+      return { text: current, ok: false, reason: "nothing to undo" };
     }
-
-    const snapshot = this.undoStack.pop()!;
-    this.redoStack.push({ text: currentText, timestamp: Date.now() });
-    return { text: snapshot.text, ok: true };
+    this.index -= 1;
+    return { text: this.states[this.index]!, ok: true };
   }
 
   /**
-   * Redo: pop from redo stack, push current text to undo.
-   * No throttle on redo.
+   * Step forward. An edit after an undo invalidates the redo: `current`
+   * no longer matches the state we are sitting on, so record it and fail.
    */
-  redo(currentText: string): UndoRedoResult {
-    if (this.redoStack.length === 0) {
-      return { text: currentText, ok: false, reason: "nothing to redo" };
+  redo(current: string): HistoryResult {
+    const at = this.index >= 0 ? this.states[this.index] : undefined;
+    if (current !== at) {
+      this.record(current);
+      return { text: current, ok: false, reason: "nothing to redo" };
     }
-
-    const snapshot = this.redoStack.pop()!;
-    this.undoStack.push({ text: currentText, timestamp: Date.now() });
-    return { text: snapshot.text, ok: true };
+    if (this.index >= this.states.length - 1) {
+      return { text: current, ok: false, reason: "nothing to redo" };
+    }
+    this.index += 1;
+    return { text: this.states[this.index]!, ok: true };
   }
 
-  /** Clear both stacks. Call on session shutdown. */
+  /** Drop everything. Call on session shutdown. */
   clear(): void {
-    this.undoStack = [];
-    this.redoStack = [];
-    this.lastSnapshotAt = 0;
+    this.states = [];
+    this.index = -1;
+    this.chars = 0;
+  }
+
+  private evict(): void {
+    while (this.states.length > 1 && (this.states.length > MAX_STATES || this.chars > MAX_CHARS)) {
+      this.chars -= this.states[0]!.length;
+      this.states.shift();
+      this.index -= 1;
+    }
   }
 }

package/packages/kanboard/README.md

@@ -3,10 +3,14 @@
 The pi half of **kanboard v3**: a per-project board for deferred work. The
 storage, transition rules and web UI live in the Rust binary
 ([`crates/kanboard`](../../crates/kanboard) — one writer for every change); this
-package is the terminal-side bridge: commands, the task runner, hub settings and
-the `kanboard` skill.
+package is the terminal-side bridge: commands, the `-do` budget, the turn
+arbiter's kanboard monitor, hub settings and the `kanboard` skill.
+**There is no runner** — the session works board tasks itself; the runner,
+queue and strategy labels were removed (see
+[`docs/plans/2026-09-30-01a0f095.md`](../../docs/plans/2026-09-30-01a0f095.md)).
 
-Spec: [`docs/specs/2026-09-24-kanboard-v3-design.md`](../../docs/specs/2026-09-24-kanboard-v3-design.md).
+Spec: [`docs/specs/2026-09-24-kanboard-v3-design.md`](../../docs/specs/2026-09-24-kanboard-v3-design.md)
+(superseded for the runner/queue/strategy parts).
 
 ## Commands
 
@@ -18,7 +22,7 @@ Spec: [`docs/specs/2026-09-24-kanboard-v3-design.md`](../../docs/specs/2026-09-2
 | `open [--host H] [--port N]` | Ensure the daemon (reuse a healthy one, else spawn `serve` detached) and print `http://127.0.0.1:<port>/p/<slug>`. The browser opens only when `openBrowser` is on. |
 | `onboard` | `project add` for this workspace and remembers the slug. Idempotent. |
 | `close` | Shut down the board daemon — the web UI goes offline until the next `open`. Running tasks are unaffected. |
-| `status` | Daemon pid/port, project counts, active claims (session/pid/host/staleness), this session's queue, and the runner's current task. |
+| `status` | Daemon pid/port, project counts and active claims (session/pid/host/staleness). |
 | `doctor` | ✓/✗ setup check (binary, daemon health, project, summary agent, bind, claims) as a display-only message. |
 
 The other three commands are separate slash commands:
@@ -26,48 +30,46 @@ The other three commands are separate slash commands:
 | Command | What it does |
 |---|---|
 | `/unipi:kanboard-add [-p 1-5] [--after ID] [--status backlog\|todo] <title>` | Capture a task — no agent turn. Lines below the title are the body; existing file paths pasted there are attached. `-p` maps 1 none · 2 low · 3 medium · 4 high · 5 urgent. |
-| `/unipi:kanboard-do <request>` | Reveal the skill and hand the request to the agent with board writes enabled for that turn. The agent may add/move/queue/note; it cannot run tasks — queued ids are drained by the runner when the turn ends. |
-| `/unipi:kanboard-autowork start\|stop` | `start` runs ready tasks one by one (queue order first, then `claim-next`); `stop` finishes the current task, then stops. |
+| `/unipi:kanboard-do <request>` | Reveal the skill and hand the request to the agent with a **budget**: `doTasks` task slots (each `start` uses one) and `doWrites` board writes (add, edit, link, order, move backlog↔todo, note on tasks you don't hold). Always free: reads, and `finish`, `move <ID> blocked --comment` and `note` on tasks this session started. Budgets persist across turns until spent; `-do` tops up without stacking, `off` revokes. Children never write. |
+| `/unipi:kanboard-autowork start\|stop` | `start` turns autowork on: the session works every ready task one at a time, in any mode it chooses, with no budget limits. `stop` turns the offers off (never aborts the current turn). |
 
 The old `add`/`work`/`stop` subcommands and bare-text capture now just point at
 these commands.
 
-## Runner (`/unipi:kanboard-autowork start`)
-
-One job per session. The **runner owns the lifecycle transitions** the agent is
-not allowed to write:
-
-1. `claim-next --session <sid> --pid <ppid> --host <host> --gate <chainGate>` —
-   nothing ready → `Nothing ready (N waiting on deps, M blocked)`.
-2. **jev picks the mode** (one `choice` call over title + body ≤2000 chars):
-   `direct` (small clear change) · `plan` (needs an approved plan) · `goal`
-   (multi-turn objective with verification). jev null → `direct`; the choice is
-   logged to `~/.unipi/logs/kanboard.log` with `UNIPI_DEBUG_KANBOARD=1`.
-3. `set-run --mode`, then the task goes to the agent as a user message: title,
-   body, last 10 activity entries, each dependency with its status and last note,
-   and the rules (block with a comment to ask a question; never write
-   `in_review`/`done`/`cancelled`; work only on this task).
-   - **plan** → plan mode is entered through workflow's `unipi:plan-enter` runner
-     first; approval stays interactive; a discarded plan releases the task to Todo
-     with `plan discarded`.
-   - **goal** → long-horizon's `unipi:goal-start` runner starts a goal with the
-     task as the objective; the goal id is recorded with `set-run --goal` and
-     completion is read back with `unipi:goal-status`.
-4. Run end (a `/plan` settle after the last `agent_end`, once the agent reports
-   idle with no queued messages): the task is re-read — if the agent blocked it,
-   that is respected and reported (`▣ UNI-12 blocked: <comment>`) and the loop
-   continues; otherwise `release --to in_review --comment <last assistant text
-   ≤500 chars>`. `Esc` (aborted turn) → `release --to todo --comment "interrupted
-   by user"` and the loop stops. Session shutdown → `release --to todo` with
-   `session ended`.
-5. After each task: `✓ UNI-12 → In Review: <first line>`, then the loop takes
-   the next id from the session **queue** (`claim-next --id`; entries that went
-   stale are dropped with a notice), falls back to `claim-next` while autowork
-   is on, and stops when nothing is ready. The event loop is never blocked.
-
-Footer: `▣ UNI-12 · direct` while a task runs. The claimed task is persisted with
-`pi.appendEntry("unipi:kanboard-runner", …)`, so `/reload` or a resume offers to
-resume it or releases it to Todo.
+## Continuation: the turn arbiter's monitor
+
+There is no runner loop. When a run settles, `src/monitor.ts` — a nudge
+provider on core's turn arbiter (`agent_before_settle`) — proposes at most one
+continuation:
+
+- **Claims (priority 50):** a task this session started is still In Progress →
+  `↻ UNI-30 still In Progress — continue, or finish/block it (n/5)`.
+- **Autowork-next (priority 40):** autowork on, no open claims, a ready task
+  exists → `↻ next ready: UNI-33 <title> …`; nothing ready → an
+  `autowork done` notice, then autowork turns itself off.
+
+The monitor defers to a **long-horizon owner** (priority 100), to **pending
+events** and to **wait sources** (a running bg wake, a busy sidekick, a
+background subagent). It **disarms** on an aborted/errored run (Esc never gets
+talked over) and when a goal stops paused/budget with claims open (notice
+only). Runaway guards: 2 nudged runs with zero tool calls → `⚠ stalled`, a
+hard cap of 5 nudges per task, a question heuristic (the agent asked the user
+something → notice, no nudge), and in autowork the same stall rule plus a
+3-offers-per-task cap. After an Esc, a later prompt that names a claimed id
+re-arms the monitor.
+
+**Children are read-only.** Sidekicks and subagents may read the board; every
+write is refused with "board writes are the lead's job — report this to the
+lead". Reminders are silent there too.
+
+**Session identity & lifecycle.** On every lead `session_start` the session id
+becomes `UNIPI_KANBOARD_SESSION = pi-<pi session id>` (stable across `-c`/`-r`)
+and `UNIPI_KANBOARD_PID` the process pid. At startup stale claims whose pid died
+are reaped (`session lost: …`), and tasks released that way get a one-time
+notice ("UNI-30 was released when the last run ended — ask me to re-start it").
+On `session_shutdown` this session's open claims are released to Todo with
+`released: session ended mid-task (<session>)` (actor system — the agent actor
+cannot release).
 
 ## Settings (hub section "Kanboard")
 
@@ -80,9 +82,11 @@ resume it or releases it to Todo.
 | `openBrowser` | `false` | Open the board in a browser on `open` |
 | `requireAuth` | `false` | Also require the access token on 127.0.0.1 (remote always does) |
 | `keepToken` | `false` | Reuse `<home>/token` across daemon restarts |
-| `queueMax` | `10` | Tasks a session may queue (0 = unlimited); passed to the CLI as `UNIPI_KANBOARD_QUEUE_MAX` |
-| `maxSessions` | `2` | Distinct sessions running tasks per project (`UNIPI_KANBOARD_MAX_SESSIONS`) |
-| `turnAddLimit` | `20` | `add` calls allowed per -do turn or runner task (0 = unlimited) |
+| `maxSessions` | `2` | Distinct sessions holding in-progress tasks per project (`UNIPI_KANBOARD_MAX_SESSIONS`) |
+| `turnAddLimit` | `20` | `add` calls allowed per turn (0 = unlimited) — the runaway guard, applies in autowork too |
+| `reminders` | `true` | R1: steer on the first file-changing call while a mentioned task is still Todo (text only, never blocks; silent in child sessions) |
+| `doTasks` | `5` | Task slots a `/unipi:kanboard-do` grants (each `start` costs one) |
+| `doWrites` | `10` | Board writes a `/unipi:kanboard-do` grants; a stored `doCredits` migrates into this |
 | *actions* | | `Open board…`, `Stop daemon`, `Summary agent command…`, `Rotate access token` |
 
 `Summary agent command…` writes through `settings set agent-command` and
@@ -201,10 +205,10 @@ The extension never edits those files — the binary owns them.
 | `UNI-5 is unreadable: … (line N)` | That task's own file is broken — repair it before moving/noting it. |
 | The daemon looks stale | `unipi-kanboard status` (pid + liveness), then `/unipi:kanboard close`, `unipi-kanboard stop` (SIGTERM, ≤3s) or the hub's **Stop daemon** action. |
 | Nothing is ready | `unipi-kanboard list --ready --json` shows `waitingFor`; a cancelled dependency blocks forever — `link`/`unlink` to re-plan. |
-| The runner prompts for permission on every board call | Fixed in auto mode: `unipi-kanboard … --actor agent` is allow-listed by the permission gate (ask mode still asks). |
+| A board call prompts for permission | Fixed in auto mode: `unipi-kanboard … --actor agent` is allow-listed by the permission gate (ask mode still asks). |
 
 ## Tests
 
 ```bash
-npm test -w packages/kanboard     # bin resolution, commands, runner, settings
+npm test -w packages/kanboard     # bin resolution, commands, budget guard, monitor, settings
 ```