@kingcrab/pi-imessage 1.1.1 → 1.2.0

package/dist/web/tasks.js

@@ -1,139 +1,33 @@
 import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
-import { UserEntry, } from "@earendil-works/pi-durable";
 import { displayHistory, historyActivity } from "./history.js";
-/** Newest generations shown per conversation, with every entry and task from the turn of the oldest one. */
-export const RECENT_GENERATIONS_PER_CONVERSATION = 10;
-/** Newest tasks shown for a conversation that never generated (schedulers). */
+/** Newest tasks listed per conversation; older finished ones are only flagged. */
 export const RECENT_TASKS_PER_CONVERSATION = 20;
-/** Pages of 5 entries read back from the oldest generation to find the user message that opened its turn. */
-const TURN_LOOKBACK_PAGES = 4;
-function firstLine(text, limit = 80) {
-    return text
-        .replace(/^\[(?:Group '[^']*'|DM|SMS) from [^\]]+\] /, "")
-        .split("\n")
-        .find((line) => line.trim())
-        ?.trim()
-        .slice(0, limit);
-}
-/** One line per entry: the first user or assistant message, tool calls by name only, tool results by text. */
-function summarizeEntry(entry) {
-    const message = entry.model?.[0];
-    if (!message)
-        return { role: undefined, text: undefined };
-    const content = message.content;
-    const text = typeof content === "string"
-        ? content
-        : content
-            .map((block) => block.type === "text"
-            ? block.text
-            : block.type === "toolCall"
-                ? `[toolCall ${block.name}]`
-                : block.type === "thinking"
-                    ? "[thinking]"
-                    : `[${block.type}]`)
-            .filter(Boolean)
-            .join(" ");
-    return { role: message.role, text: firstLine(text) };
-}
 /**
  * Read one consistent tree, newest first: all conversations, every unfinished task, every task that owns a
- * conversation and their parent chains. Per conversation the window is the newest generations plus every
- * entry and task back to the `pi.user` entry that opened the oldest one's turn. Entries and tasks share one
- * id sequence, so the window is a plain id range and the browser nests records by `owner` and `byTaskId`
- * without any inference. Descending scans stop at the window instead of reading the whole history
- * (earendil-works/pi#10546).
+ * conversation, their parent chains and the newest tasks of each conversation. Descending scans stop at the
+ * window instead of reading the whole task history (earendil-works/pi#10546).
  */
 export function readTaskTree(harness) {
     return harness.commit(async (tx) => {
         const conversations = [];
         const kept = new Map();
-        const entries = [];
         const more = {};
         let cursor;
         do {
             const page = await tx.scanConversations({}, 100, cursor);
             for (const conversation of page.items) {
-                const id = conversation.id;
-                // One descending scan: the newest tasks down to the oldest shown generation; a task scan with a
-                // conversation filter walks the global task order, so it must not run twice per conversation.
-                const recent = [];
-                let oldest;
-                let generations = 0;
-                let next;
-                scan: do {
-                    const tasks = await tx.scanTasks({ conversationId: id, order: "descending" }, 100, next);
-                    for (const task of tasks.items) {
-                        if (task.kind === "pi.generation") {
-                            if (++generations > RECENT_GENERATIONS_PER_CONVERSATION) {
-                                more[id] = true;
-                                break scan;
-                            }
-                            oldest = task;
-                        }
-                        else if (!generations && recent.length >= RECENT_TASKS_PER_CONVERSATION) {
-                            more[id] = true;
-                            break scan;
-                        }
-                        recent.push(task);
-                    }
-                    next = tasks.next;
-                } while (next);
-                let history;
-                let floor;
-                if (oldest) {
-                    history = [];
-                    let next;
-                    do {
-                        const window = await tx.scanEntries({ conversationId: id, minEntryId: oldest.id }, 100, next);
-                        history.push(...window.items);
-                        next = window.next;
-                    } while (next);
-                    // Walk back to the user message that opened the oldest generation's turn.
-                    let max = oldest.id - 1;
-                    for (let pages = 0; pages < TURN_LOOKBACK_PAGES; pages++) {
-                        const older = await tx.scanEntries({ conversationId: id, maxEntryId: max }, 5);
-                        const user = older.items.findIndex((entry) => UserEntry.is(entry));
-                        history.push(...(user === -1 ? older.items : older.items.slice(0, user + 1)));
-                        if (user !== -1 || !older.items.length)
-                            break;
-                        max = older.items[older.items.length - 1].id - 1;
-                    }
-                    const turn = history.find((entry) => UserEntry.is(entry) && entry.id < oldest.id);
-                    floor = turn ? turn.id : oldest.id;
-                    history = history.filter((entry) => entry.id >= floor);
-                    // Tasks between the turn's user message and its first generation sit on the next page.
-                    while (next && (recent.at(-1)?.id ?? 0) >= floor) {
-                        const tasks = await tx.scanTasks({ conversationId: id, order: "descending" }, 100, next);
-                        recent.push(...tasks.items.filter((task) => task.id >= floor));
-                        next = tasks.next;
-                    }
-                }
-                else {
-                    // Names and activity still come from the newest 100 entries, as on the Messages page.
-                    history = [...(await tx.scanEntries({ conversationId: id }, 100)).items];
-                    floor = history[RECENT_TASKS_PER_CONVERSATION - 1]?.id ?? 0;
-                }
-                const page = { items: history, next: undefined };
-                const { groupName } = displayHistory(page, 1);
+                const history = await tx.scanEntries({ conversationId: conversation.id }, 100);
+                const { groupName } = displayHistory(history, 1);
                 conversations.push({
                     ...conversation,
-                    updatedAt: historyActivity(page),
+                    updatedAt: historyActivity(history),
                     groupName: typeof groupName === "string" ? groupName : undefined,
                 });
-                for (const entry of history) {
-                    if (entry.id < floor)
-                        continue;
-                    entries.push({
-                        id: entry.id,
-                        conversationId: id,
-                        kind: entry.kind,
-                        byTaskId: entry.byTaskId,
-                        ...summarizeEntry(entry),
-                    });
-                }
-                for (const task of recent)
-                    if (!oldest || task.id >= floor)
-                        kept.set(task.id, task);
+                const newest = await tx.scanTasks({ conversationId: conversation.id, order: "descending" }, RECENT_TASKS_PER_CONVERSATION + 1);
+                for (const task of newest.items.slice(0, RECENT_TASKS_PER_CONVERSATION))
+                    kept.set(task.id, task);
+                if (newest.items.length > RECENT_TASKS_PER_CONVERSATION)
+                    more[conversation.id] = true;
                 if (conversation.owner && !kept.has(conversation.owner.taskId)) {
                     const owner = await tx.task(conversation.owner.taskId);
                     if (owner)
@@ -191,15 +85,13 @@ export function readTaskTree(harness) {
                 background: task.background,
                 abortRequested: task.abortRequested,
                 status: state.status,
-                // Phases exist only while a task runs; a terminal record keeps its outcome and drops the checkpoint.
                 phase: state.checkpoint && typeof state.checkpoint === "object" && !Array.isArray(state.checkpoint)
                     ? state.checkpoint.phase
                     : undefined,
                 on: state.status === "waiting" ? state.on : undefined,
-                until: state.status === "sleeping" ? state.until : undefined,
                 outcome: state.outcome?.status,
             });
         }
-        return { conversations, tasks, entries, more };
+        return { conversations, tasks, more };
     }, BACKGROUND_CONTEXT);
 }

package/docs/adr/{0004-native-extensions.md → 0003-native-extensions.md}

@@ -1,4 +1,4 @@
-# 0004. Native Durable extensions, not an SDK adapter
+# 0003. Native Durable extensions, not an SDK adapter
 
 Status: accepted (2026-10-04; owner accepted 2026-10-05)
 

package/docs/adr/{0006-jsonl-storage.md → 0004-jsonl-storage.md}

@@ -1,4 +1,4 @@
-# 0006. One JSONL storage, backed up by hand
+# 0004. One JSONL storage, backed up by hand
 
 Status: accepted (2026-10-04; owner accepted 2026-10-05)
 

package/docs/adr/{0007-images-by-path.md → 0005-images-by-path.md}

@@ -1,4 +1,4 @@
-# 0007. Store images as file paths
+# 0005. Store images as file paths
 
 Status: accepted (2026-10-04; owner accepted 2026-10-05)
 

package/docs/adr/{0010-test-budget.md → 0006-test-budget.md}

@@ -1,4 +1,4 @@
-# 0010. About 40 tests, only for our code
+# 0006. About 40 tests, only for our code
 
 Status: accepted (2026-10-04; owner accepted 2026-10-05)
 

package/docs/adr/{0011-reconcile-unsent-answers.md → 0007-reconcile-unsent-answers.md}

@@ -1,8 +1,8 @@
-# 0011. Reconcile unsent answers after intervening input
+# 0007. Reconcile unsent answers after intervening input
 
 Status: accepted (2026-10-04; owner chose reconciliation and explicitly included different senders)
 
-**Context.** Native steer places all selected messages after a tool round when configured with `steeringMode: "all"`. At a final-answer boundary, however, Durable first records the answer and settles that run's inputs; selected new messages start another run. The earlier answer remains eligible for delivery even when a newer message corrects its assumptions. An `onYield` continuation does not change this: it is ignored when the boundary selects user input. See [the state ownership decision](0001-durable-owns-state.md) and [at-most-once replies](0003-replies-at-most-once.md).
+**Context.** Native steer places all selected messages after a tool round when configured with `steeringMode: "all"`. At a final-answer boundary, however, Durable first records the answer and settles that run's inputs; selected new messages start another run. The earlier answer remains eligible for delivery even when a newer message corrects its assumptions. An `onYield` continuation does not change this: it is ignored when the boundary selects user input. See [the state ownership decision](0001-durable-owns-state.md).
 
 **Example.** The model is finishing a two-day itinerary when the user says “three days instead.” Sending both itineraries is confusing. Conversely, blindly dropping the first answer when the new message asks an unrelated question can lose useful work.
 

package/docs/adr/{0012-run-in-owned-conversation.md → 0008-run-in-owned-conversation.md}

@@ -1,8 +1,8 @@
-# 0012. `/run` works in a conversation owned by one task
+# 0008. `/run` works in a conversation owned by one task
 
-Status: accepted (2026-10-04; owner accepted 2026-10-05). Replaces the `/run` part of [0008](0008-compaction-and-run.md); its compaction part stays.
+Status: accepted (2026-10-04; owner accepted 2026-10-05).
 
-**Context.** In 0008, `/run` works inside the chat's own conversation. Stopping it then means telling run work apart from ordinary work: `Conversation.abort()` also withdraws ordinary queued messages, so the draft tracked submission IDs and command receipts by hand. Durable already scopes abort by ownership: aborting a task aborts the conversations and work it owns.
+**Context.** Before this decision, `/run` worked inside the chat's own conversation. Stopping it then means telling run work apart from ordinary work: `Conversation.abort()` also withdraws ordinary queued messages, so the draft tracked submission IDs and command receipts by hand. Durable already scopes abort by ownership: aborting a task aborts the conversations and work it owns.
 
 **Example.** The user sends `/run 30m plan a two-day trip`, then "make it three days". The correction must reach the run. A later `/stop` must end the run without touching anything else.
 
@@ -12,9 +12,9 @@ Status: accepted (2026-10-04; owner accepted 2026-10-05). Replaces the `/run` pa
 - `/run` starts only when the chat conversation is idle. Otherwise it replies that the chat is busy and does nothing: no queueing, no moving of running work. A repeated `/run` during a run updates the deadline; a task text in it is sent to the run like an ordinary message.
 - While a run is active, all ordinary messages of the chat go to the run conversation as steers, with the message GUID as request ID. Commands do not.
 - An `onYield` hook continues the run until the model calls `end_run` (done, or the user is needed) or the deadline passes. The deadline only stops continuation: the current turn finishes, so a run can overrun. Ordinary messages do not extend it. Without unfinished work, the model ends the run instead of inventing a task.
-- Final answers of the run conversation are delivered as they are committed, including those between continuations, under [0003](0003-replies-at-most-once.md) and [0011](0011-reconcile-unsent-answers.md).
+- Final answers of the run conversation are delivered as they are committed, including those between continuations, at most once and under [0007](0007-reconcile-unsent-answers.md).
 - `/stop` aborts the run task. Durable aborts the run's work and withdraws its queued messages; they stay in history, unanswered, and are not resubmitted anywhere. Without an active run, `/stop` replies that nothing is running. There is no `/run-stop`. `/new` also stops the run.
-- A restart does not stop a run. `resume()` continues the run task like any other pending work, with the deadline from our run document; if it passed during the downtime, the current turn finishes and the run ends. Replies interrupted mid-send follow [0003](0003-replies-at-most-once.md).
+- A restart does not stop a run. `resume()` continues the run task like any other pending work, with the deadline from our run document; if it passed during the downtime, the current turn finishes and the run ends. A reply interrupted mid-send becomes `unknown` and is not resent.
 - The chat conversation keeps the record: the run's user messages and sent replies are written to it as passive entries, plus how the run ended. Tool calls and results stay in the run conversation, searchable under `durable/` like other history.
 
 **Consequences.** Stopping needs no submission bookkeeping and no command receipts. During a run, the chat has one place where work happens. Messages still queued in the run when `/stop` arrives are dropped, a narrower promise than before. After the run, the chat conversation knows what was said, not how; the model searches the run conversation when it needs details.

package/docs/adr/{0032-native-background-schedules.md → 0009-native-background-schedules.md}

@@ -1,4 +1,4 @@
-# 0032. Native background schedules and read-only execution history
+# 0009. Native background schedules and read-only execution history
 
 Status: proposed (owner requested native scheduling, compact migration and Web history)
 

package/docs/adr/0010-framework-and-workspace.md

@@ -0,0 +1,27 @@
+# 0010. The framework integrates iMessage and Durable; the workspace owns behavior
+
+Status: accepted (2026-10-31, owner, grilling session)
+
+**Problem.** Personal behavior, preferences and operations crept into the
+framework: a hard-coded idle reset, chat etiquette in the product prompt,
+claw-specific Git, deployment and restart procedures in the repository.
+
+**Decision.**
+
+- The *framework* is this repository and the service it runs. The *workspace*
+  is `WORKING_DIR` (`settings.json`, `AGENTS.md`, `extensions/`, `skills/`).
+- The framework does only the integration of iMessage and Durable: transport,
+  chat-to-conversation mapping, delivery and receipts, scheduling machinery,
+  the extension loader and read-only views. It keeps general tools (web,
+  browser, subagent, memory, images, messages).
+- Every other behavior lives in the workspace: personal tasks, chat etiquette,
+  thresholds such as idle reset, and operations (Git flow, deployment, restart).
+  The framework keeps no default or example for it.
+- The product prompt states only facts of the integration (interim and delivery
+  semantics, different senders are different people). How to behave belongs in
+  workspace `AGENTS.md`.
+- Workspace code is a plain Durable extension built with the framework's pinned
+  Durable SDK; the framework adds no API of its own for it.
+
+**Consequences.** Another deployment gets the integration and nothing personal.
+Changing behavior is a workspace edit and `/reload`, not a release.

package/docs/adr/README.md

@@ -1,55 +1,31 @@
 # Architecture decision records
 
-Accepted ADR files are never edited; this index records which ones are current.
-"Active" means the decision is in force. A replaced ADR points to its successor.
+These are the decisions in force. Accepted ADR files are never edited.
 
-## Current
+| ADR | Decision |
+|---|---|
+| [0001](0001-durable-owns-state.md) | Pi Durable owns all chat state |
+| [0002](0002-module-layering.md) | Modules in strict layers |
+| [0003](0003-native-extensions.md) | Native Durable extensions, not an SDK adapter |
+| [0004](0004-jsonl-storage.md) | One JSONL storage, backed up by hand |
+| [0005](0005-images-by-path.md) | Store images as file paths |
+| [0006](0006-test-budget.md) | About 40 tests |
+| [0007](0007-reconcile-unsent-answers.md) | Reconcile unsent answers |
+| [0008](0008-run-in-owned-conversation.md) | `/run` in an owned conversation |
+| [0009](0009-native-background-schedules.md) | Native background schedules and read-only execution history |
+| [0010](0010-framework-and-workspace.md) | The framework integrates iMessage and Durable; the workspace owns behavior |
 
-| ADR | Decision | Status |
-|---|---|---|
-| [0001](0001-durable-owns-state.md) | Pi Durable owns all chat state | Active |
-| [0002](0002-module-layering.md) | Modules in strict layers | Active |
-| [0003](0003-replies-at-most-once.md) | Replies are sent at most once | Active |
-| [0004](0004-native-extensions.md) | Native Durable extensions, not an SDK adapter | Active; Codex tier clause replaced by 0036 |
-| [0006](0006-jsonl-storage.md) | One JSONL storage, backed up by hand | Active |
-| [0007](0007-images-by-path.md) | Store images as file paths | Active |
-| [0008](0008-compaction-and-run.md) | Six-hour compaction | Active; `/run` clause replaced by 0012 |
-| [0010](0010-test-budget.md) | About 40 tests | Active |
-| [0011](0011-reconcile-unsent-answers.md) | Reconcile unsent answers | Active |
-| [0012](0012-run-in-owned-conversation.md) | `/run` in an owned conversation | Active |
-| [0013](0013-thin-adapters-around-durable.md) | Thin adapters around Durable | Active; scheduler clause replaced by 0042 |
-| [0016](0016-process-http-transport.md) | One process-owned HTTP transport | Active |
-| [0017](0017-browser-cli-owned-scope.md) | Conversation-scoped browser CLI tool | Accepted, to be implemented |
-| [0018](0018-tasks-without-prompt-api.md) | Ordinary `/stop`; no HTTP `/prompt` or `/send` | Active |
-| [0036](0036-workspace-policy-and-neutral-service-id.md) | Workspace policy and neutral service ID | Active |
-| [0040](0040-chat-progress-notices.md) | Chat progress notices | Active; consolidates 0020–0028, 0031 |
-| [0041](0041-restart-and-recovery.md) | Restart and recovery | Active; consolidates 0037–0039; self-restart path added by 0052 |
-| [0042](0042-background-schedules-and-workspace-extensions.md) | Background schedules and workspace extensions | Active; operator-run clause replaced by 0047 |
-| [0043](0043-remove-legacy-migration.md) | Remove the legacy migration code | Active; archived at tag `archive/legacy-migration` |
-| [0044](0044-message-channels.md) | Organize message sources as channels | Proposed |
-| [0045](0045-chat-scheduling-tools.md) | Native chat scheduling tools | Proposed |
+## Adding an ADR
 
-| [0046](0046-selective-command-redaction.md) | Selective command-preview redaction | Proposed; owner-requested implementation in #36 |
-| [0047](0047-one-scheduling-path.md) | One scheduling path for recurring and one-off work | Active |
-| [0048](0048-quiet-attachment-reads.md) | Quiet attachment reads | Proposed; owner-requested implementation in #38 |
-| [0049](0049-per-chat-progress-notices.md) | Per-chat progress notices via `/verbose` | Proposed; owner-requested implementation |
-| [0052](0052-host-owned-self-restart.md) | The host owns its own restart (`restart_service`) | Active; owner accepted on 2026-10-24 (#39) |
-| [0053](0053-service-log-errors.md) | Service-log errors for failures that break normal operation | Proposed; first kind (model call failed) implemented |
+Do not add an ADR on your own initiative. A new ADR, including one that
+reverses a decision above, is written only during a grilling session (the
+`grilling` skill), to record what the owner settled there. Outside such a
+session, describe the change in the GitHub issue, `docs/architecture.md` or
+the code.
 
-## Replaced or rejected
+## Removed ADRs
 
-| ADR | Decision | Replaced by |
-|---|---|---|
-| [0005](0005-history-migration.md) | Import old history once | 0043 (done) |
-| [0009](0009-one-shot-cutover.md) | Switch over in one step | 0043 (done) |
-| [0014](0014-ephemeral-private-storage.md) | Ephemeral private storage | 0018 |
-| [0015](0015-ordinary-stop-keeps-native-inbox.md) | `/stop` keeps the native inbox | 0018 |
-| [0030](0030-shared-web-read-cache.md) | Shared web read cache | Rejected; removed |
-| [0019](0019-remove-scheduled-services.md) | Remove scheduled services | 0042 |
-| [0020](0020-chat-task-progress.md)–[0028](0028-command-preview-120.md) | Progress notice format | 0040 |
-| [0031](0031-quiet-compaction-progress.md) | Quiet six-hour compaction progress | 0040 |
-| [0032](0032-native-background-schedules.md)–[0035](0035-external-business-task-extensions.md) | Native schedules, operator run, local time, workspace extensions | 0042 |
-| [0037](0037-restart-during-in-flight-work.md)–[0039](0039-rerun-interrupted-tools.md) | Restart and tool rerun | 0041 |
-
-Numbers 0029, 0050 and 0051 are not used: 0050 and 0051 were interim stop
-heuristics for #39 that the owner did not accept; 0052 replaced them.
+All other ADRs were removed on 2026-10-31, together with every reference to
+them, and the rest renumbered without gaps. The files are kept, under their old
+numbers, at the annotated tag `archive/adr-pre-prune`
+(`git show archive/adr-pre-prune:docs/adr/<file>`).

package/docs/api.md

@@ -7,7 +7,7 @@ The server has no authentication; do not expose it to untrusted networks.
 
 The pages `/`, `/chat`, `/chats`, `/tasks`, `/scheduled`, `/settings`, `/memory` and `/logs` are read-only.
 The Chats tab (`/chats`, `/chats/data`) lists groups and direct chats, one row
-each: reply eligibility, the `/verbose` choice with its effective value, the
+each: reply eligibility, the `/verbose` and `/interim` choices with their effective values, the
 conversation's model and thinking level, and last activity. Chats that do not
 reply are dimmed. It never shows message text. The message history page in the
 navigation is labelled Messages.
@@ -47,8 +47,7 @@ requests; detail history and its older-page cursors are not reduced to 15
 messages. Existing `/chat/data` and conversation detail responses without these
 view parameters retain their native state shapes.
 
-Every request reads current state directly; there is no server-side read cache
-(ADR 0030 was rejected).
+Every request reads current state directly; there is no server-side read cache.
 
 Pages load once and refresh only through the Refresh button, memory filtering/
 pagination or explicit navigation. There is no browser SSE connection, periodic
@@ -69,10 +68,10 @@ that arbitrary user-written secrets can be identified.
 
 The agent sends files and extra messages with its immediate `send_message`
 tool. HTTP `/prompt` and `/send` remain retired. Legacy cron management,
-reminders and PT Automation routes remain removed and return 404 (ADR 0019).
+reminders and PT Automation routes remain removed and return 404.
 
 `GET /scheduled` and `GET /scheduled/data` expose configured native background
-jobs (ADR 0032), not the retained legacy cron files. The JSON view contains `jobs`
+jobs, not the retained legacy cron files. The JSON view contains `jobs`
 with cadence, enabled state, native scheduler task/conversation IDs, phase and
 `nextAt`, and each job's latest ten execution tasks. `recent` contains the latest
 ten executions across all jobs. Results separate native task outcome from the
@@ -82,7 +81,7 @@ run, pause or resend buttons. Scheduling configuration takes effect at startup.
 Daily slots and learning dates use the service machine's local timezone (or an
 explicit process `TZ`). Each job includes `timezone`; Web deadlines and history
 use it even when the browser is in another timezone. Saved absolute deadlines
-remain unchanged on restart (ADR 0034).
+remain unchanged on restart.
 
 | Endpoint | Description | Example |
 |---|---|---|
@@ -99,6 +98,15 @@ previews. Raw outputs, commands, prompts and document contents stay local.
 Known credential indicators are redacted; arbitrary user-authored secrets cannot
 be guaranteed detectable. Missing or false keeps final-only delivery. The setting
 is reread for each notice; old tasks and unknown sends are not replayed
-([ADR 0040](adr/0040-chat-progress-notices.md)). `/verbose on|off` in a chat
+. `/verbose on|off` in a chat
 overrides this default for that chat only and `/verbose default` removes the
-override ([ADR 0049](adr/0049-per-chat-progress-notices.md)).
+override.
+
+Text the model writes next to a tool call is sent at once as an interim message
+in reply-enabled chats; subagent text stays private. `interimMessages: false` in
+`settings.json` turns this off by default, and `/interim on|off|default` sets it
+for one chat.
+
+`hiddenSkills` in `settings.json` is a list of skill names left out of the
+prompt's skill catalog; their files stay readable by path. It is read at startup
+and on `/reload`.

package/docs/architecture.md

@@ -45,15 +45,27 @@ extensions. Source and configuration reload without interrupting current calls.
 Failed reloads retain old definitions and schedule configuration. Removed task
 code stays in memory for calls that can still admit children; missing required
 code fails explicitly on restart. The assistant's `reload_extensions` tool uses
-the same service owner. See [workspace extensions](workspace-extensions.md),
-ADR 0035 and ADR 0036.
+the same service owner. See [workspace extensions](workspace-extensions.md).
 
 The built-in native `browser` extension wraps the pinned pi-browser CLI with
 host-derived conversation scopes. Browser children get private HOME/cache,
 profile/output and cwd; other coding tools are unchanged. The host owns scoped
 stop/reset/shutdown/restart cleanup, while Durable owns invocation state and
 unsafe replay policy. Read-only contexts do not offer the tool. This is not an
-OS sandbox; see [browser operations and retention](browser.md) and ADR 0017.
+OS sandbox; see [browser operations and retention](browser.md).
+
+The model is offered a fixed core of tools; every other built-in or workspace tool
+is deferred and loaded on demand with Durable's `tool_search`, the same in every
+conversation. The core includes Durable's `codemode` (`extensions/codemode.ts`):
+the model writes a script that calls the conversation's tools in a QuickJS
+sandbox and only the script's output enters the context; `models.*` is off, so
+scripts cannot start model calls, and the prompt section lists callable tools
+within a small token budget.
+
+`/run <duration>` (ADR 0008) treats the duration as time to use: after the
+stated task is done the run keeps verifying and improving within its scope
+until the deadline, and `end_run` ends it early only when blocked, when the
+user is needed or when nothing in scope remains.
 
 
 ### Native schedules
@@ -62,15 +74,14 @@ OS sandbox; see [browser operations and retention](browser.md) and ADR 0017.
 job's dedicated conversation owns a background scheduler, whose checkpoint saves
 the next deadline. Each occurrence is a child execution task delegating to an
 extension's native business task; terminal receipts supply Web history, not a
-parallel UI log. The framework owns daily/interval cadence, non-overlap, recovery
-and quiet six-hour native compaction. Workspace tasks own business policy and
+parallel UI log. The framework owns daily/interval cadence, non-overlap and recovery, and
+defines no schedule of its own: chat context is bounded by Durable's thresholds
+against the window each model advertises. Workspace tasks own business policy and
 documents, and can commit their state and the generic outgoing item atomically.
 The host delivery poll uses existing direct-send receipts and passive chat records.
 `web/schedules.ts` projects these native records, including latest-ten history.
 Daily slots and learning dates use the service machine's local timezone; the Web
-view uses the same timezone. Saved absolute deadlines survive restart. See
-[ADR 0032](adr/0032-native-background-schedules.md) and
-[ADR 0034](adr/0034-machine-local-schedule-time.md).
+view uses the same timezone. Saved absolute deadlines survive restart.
 
 ## 2. Workflow
 

package/docs/browser.md

@@ -1,6 +1,6 @@
 # Conversation-owned browser
 
-The host's built-in native Durable `browser` extension implements ADR 0017. It is
+The host's built-in native Durable `browser` extension scopes browser work to its conversation. It is
 registered with the other built-in tools, not loaded as a personal workspace
 business extension. It invokes the installed `PI_CODING_AGENT_DIR/bin/pi-browser`
 wrapper and its pinned Playwright CLI by argv; there is no SDK shim, private CLI
@@ -21,7 +21,7 @@ import or second browser driver.
 Open before interacting. A snapshot includes bounded accessibility text with
 current refs. Screenshot/other artifact links resolve from the reported private
 cwd; the result also gives the absolute output directory. Page output is
-untrusted. No attachment, discovery, headed overrides, global cleanup, arbitrary
+untrusted. No attachment, discovery, global cleanup, arbitrary
 profile/config/filename, storage export/import or arbitrary code execution is
 exposed to the model. Positional text follows `--`, so strings resembling flags
 remain literal. Native health checks and read-only subagents do not offer the tool.
@@ -36,7 +36,7 @@ and other tool-enabled native conversations receive distinct scope directories:
 WORKING_DIR/browser/<sha256-of-canonical-storage>/<conversation-id>/
   owner.json
   home/                    # private HOME/cache/CLI daemon registry
-  cwd/.playwright/         # private workspace identity and managed headless config
+  cwd/.playwright/         # private workspace identity and managed headed config
   state/profiles/owned/    # dedicated non-personal persistent Chrome profile
   state/output/            # snapshots/screenshots
   state/auth.json          # private last completed storage-state checkpoint
@@ -78,16 +78,16 @@ read with a byte limit.
 
 This is a tool boundary, **not an OS sandbox**. Unrestricted coding tools can
 still access host files or invoke another browser process. Stronger containment
-requires a separate decision. Never copy a personal Chrome profile, bypass a
-CAPTCHA/2FA or perform an unapproved irreversible action.
+requires a separate decision. Never bypass a CAPTCHA/2FA or perform an
+unapproved irreversible action.
 
 ## Verification
 
 - `test/browser.test.ts` uses a faux model and fake CLI boundary to check native
   registration, forced arguments/environment, forbidden controls, literal flag-like
   form text, owned stop/reset/restart, retention, cancellation and unsafe replay.
-- `node --experimental-strip-types ops/browser-smoke.mjs` uses the real installed
-  CLI and headless Chrome with temporary profiles and loopback pages. It checks
+- `node --experimental-strip-types scripts/browser-smoke.mjs` uses the real installed
+  CLI and visible Chrome with temporary profiles and loopback pages. It checks
   same-name sessions, daemon discovery, cookies/local storage, tabs/output files,
   literal arguments, selective cleanup and preserved login checkpoints on reopen.
   It never opens a personal profile, calls a paid model or sends an iMessage.

package/docs/install.md

@@ -0,0 +1,109 @@
+# Installation
+
+## Prerequisites
+
+- macOS, Node >=22.22.2, Python 3 and authenticated Pi models.
+- Terminal/Node Full Disk Access for Messages' SQLite database; Automation and
+  Accessibility permissions for Messages.app/rich-text sends; `/usr/bin/sips`.
+- The existing memory CLI at `WORKING_DIR/skills/file-memory/memory_cli.py`.
+- The installed `pi-browser` CLI and its pinned Playwright runtime. Run
+  `pi-browser setup` when needed and authorized; `pi-imessage preflight` never
+  installs it. Preflight
+  resolves the wrapper in Pi's agent `bin/`, or a preflight-only
+  `PI_BROWSER_CLI_PATH` override, and runs `--version` with temporary browser state
+  that is removed afterward. A wrapper whose `doctor` reports MISSING is not ready.
+  Version readiness does not prove browser privacy, login or per-chat isolation.
+- Reviewed native SQLite and image dependencies. Install dependencies with
+  `npm ci --ignore-scripts`; if native binaries are missing, review and approve
+  their build/download separately rather than silently enabling install scripts.
+
+Safe local checks (no live models/messages/workspace):
+
+```sh
+npm run check
+npm test
+node --experimental-strip-types src/cli.ts preflight
+node --experimental-strip-types src/cli.ts --help
+```
+
+For changes to the built-in browser, also run
+`node --experimental-strip-types scripts/browser-smoke.mjs`. This uses real visible
+Chrome and the installed pinned CLI with temporary HOME/profiles, loopback pages
+and synthetic login state; it never opens a personal profile or sends a message.
+See [browser isolation and retention](browser.md).
+
+`WORKING_DIR`, `WEB_HOST`, `WEB_PORT`, `WEB_ENABLED` and `MESSAGES_DB_PATH`
+are explicit host configuration. `npm start`, the
+executable CLI and the generated launchd job enable Node's environment proxy
+support. `HTTP_PROXY`, `HTTPS_PROXY`, `NO_PROXY` (and their lowercase forms) and
+`NODE_OPTIONS` are retained when generating the job; review them before install.
+CLI execution loads the current directory's `.env` using Node's parser; existing
+environment values take precedence and a missing file is allowed. Set
+`DOTENV_CONFIG_PATH` for another file. Module imports and `--help` do not load it.
+Other read errors stop startup without printing file contents. `.env` is trusted
+operator configuration, not a message attachment. Keep it private and out of Git.
+Installation pins its current directory as the job's working directory, so the
+same configuration path is used at launch. Selected environment values in the
+plist are a snapshot; regenerate a reviewed job to change those overrides.
+The job also pins the selected Pi agent directory as an absolute
+`PI_CODING_AGENT_DIR` (including the default). Relative paths and `~` are resolved
+at installation, after `.env` loading, so daemon HOME/cwd changes do not select a
+different auth.json, models.json, settings.json or skill root. This selects a
+configuration location; it does not copy credentials or grant access to it.
+
+No proxy credentials are printed by installation. Application startup configures
+one process-owned Undici transport after `.env` loading and before model/auth
+refresh. Global Pi `httpProxy` supplies HTTP/HTTPS defaults; explicit environment
+values win, lowercase proxy/bypass values take precedence, and `NO_PROXY` is
+honored. Project-local `httpProxy` is ignored. `/reload` applies changed settings
+for subsequent requests while old clients drain active requests. Shutdown stops
+messaging and Harness work before releasing owned HTTP resources. Standalone
+callers with injected runtimes retain transport control; deliberate fetch
+overrides and dispatchers owned by other callers are not replaced on cleanup.
+
+Pi settings in the agent directory and `WORKING_DIR/.pi/settings.json` supply
+request policy; `/reload` refreshes it. `retry.provider.timeoutMs` overrides the
+provider request timeout, otherwise `httpIdleTimeoutMs` supplies that default
+(300000 ms; 0 uses Pi's effectively unlimited value). This forwards a request
+option to supporting providers. Separately, application HTTP transport uses
+`httpIdleTimeoutMs` for native header/body inactivity timers; 0 disables those
+timers. An explicit provider request timeout can still limit a request when
+socket-idle timers are disabled. Provider retry limits/delay caps and `retry`
+generation policy are executed by Pi/Durable; transport remains SSE. These do
+not replace the old host activity timer, prompt maximum-duration or
+compaction-deadline behavior.
+
+Web defaults to localhost:7750 and has no authentication. Never expose it to
+untrusted networks.
+
+Lifecycle logs use ISO timestamps on stdout/stderr: application startup (PID,
+Node version and workspace), agent readiness/reload, the actual Web bind address
+or disabled state, messaging readiness (cursor and poll/compaction intervals),
+shutdown signal, resource cleanup and failures. Readiness is logged only after
+the corresponding initialization succeeds; it is not a model or delivery health
+check. Idle polls do not produce log lines. These lifecycle entries do not include
+message text, tool arguments or proxy/auth configuration.
+The generated launchd job redirects both streams to `WORKING_DIR/service.log`.
+Foreground runs use the terminal or the controller's selected redirection; the
+application does not open a second log file.
+
+## npm publishing
+
+The public package contains compiled JavaScript and Web assets, not a TypeScript
+executable under `node_modules`. `npm pack` builds through `prepack`;
+`npm run test:package` verifies the packed executable and inert installer in a
+temporary HOME/workspace without models or Messages.
+
+`.github/workflows/publish.yml` uses the existing npm trusted publisher with
+GitHub OIDC, Node 24 and `id-token: write`; no local npm login or token is needed.
+It runs the full checks, tests and package smoke before publishing with provenance.
+Future releases push a matching `v<package-version>` tag. To publish an existing
+version after fixing packaging, dispatch the workflow on main with that exact
+version; never move an already published GitHub tag.
+
+```sh
+gh workflow run publish.yml --ref main -f version=1.0.0
+```
+
+An installed npm service runs `dist/cli.js`; source deployments continue to use
+`src/cli.ts`. Package installation does not start or reload a service.