toolroll 0.9.46 → 0.9.48

package/dist/task-activity.js

@@ -0,0 +1,53 @@
+/**
+ * What a running agent did last, recorded and read (live tasks).
+ *
+ * The recorder sits beside the live log on the agent's stream and keeps one
+ * row per run: a fixed kind from live.ts's vocabulary and when. No text, no
+ * tool names, no arguments are ever kept, so nothing here can leak a secret.
+ * The reader picks the newer of that row and the run's latest progress
+ * checkpoint, and asks the runner's heartbeat whether the worker still
+ * answers. Neither side reads or stats a live-log file.
+ */
+import { ACTIVITY_WORDS } from "./activity-line.js";
+import { liveActivityKind } from "./live.js";
+import { isAlive } from "./runner.js";
+/** At most one write per run this often while the kind stays the same: the age is in seconds, not milliseconds. */
+const SAME_KIND_EVERY_MS = 5_000;
+/** Watch a run's stream for what the agent does, alongside its live log (which may be null). Fail-soft: a write
+ * that fails never touches the run. */
+export function withRunActivity(liveLog, store, run, clock) {
+    let last = null;
+    return {
+        observe(event) {
+            liveLog?.observe(event);
+            const kind = liveActivityKind(event);
+            if (kind === null)
+                return;
+            try {
+                const now = clock();
+                if (last !== null && last.kind === kind && now.getTime() - last.at < SAME_KIND_EVERY_MS)
+                    return;
+                store.recordRunActivity(run, kind, now);
+                last = { kind, at: now.getTime() };
+            }
+            catch { /* display state: the next event tries again */ }
+        },
+        close() { liveLog?.close(); },
+    };
+}
+/** A live run's last activity: the newer of its recorded kind and its latest progress checkpoint, else when it
+ * started; and "offline" only when its registered worker's heartbeat has lapsed. */
+export function runActivityOf(store, run, now) {
+    const recorded = store.runActivity(run.id);
+    let what = ACTIVITY_WORDS["started"], at = run.startedAt;
+    if (recorded.kind !== null && recorded.at !== null && recorded.at >= at) {
+        what = ACTIVITY_WORDS[recorded.kind] ?? ACTIVITY_WORDS["tool"];
+        at = recorded.at;
+    }
+    if (recorded.progressAt !== null && recorded.progressAt > at) {
+        what = ACTIVITY_WORDS["progress"];
+        at = recorded.progressAt;
+    }
+    const worker = store.getRunner(run.runner)?.runner;
+    return { what, at, worker: worker === undefined || isAlive(worker, now) ? "online" : "offline" };
+}

package/dist/task-live.d.ts

@@ -0,0 +1,8 @@
+import { type LiveRoomOptions, type LiveRooms, type LiveViewer } from "./live-bus.js";
+import { type Store } from "./store.js";
+export type TaskViewer = LiveViewer;
+/** What changes when anything on the task page changes: one read over the family, kept short and opaque. */
+export declare function taskFingerprint(store: Store, root: string, now: Date, livenessMs?: number): string | null;
+export type TaskRooms = LiveRooms<string, TaskViewer>;
+/** Rooms keyed by the task family's root. With a bus, a write reaches every open page at once; without one, only the safety net. */
+export declare function createTaskRooms(fingerprint: (root: string) => string | null, options?: LiveRoomOptions): TaskRooms;

package/dist/task-live.js

@@ -0,0 +1,47 @@
+/**
+ * The live task page (live tasks): a task open in several browsers stays the
+ * same in all of them, and each shows who else has it open. The same design
+ * as the live canvas (flow-live.ts):
+ *
+ * - A change nudge. When the live bus says the workspace was written
+ *   (live-bus.ts), one indexed read keyed by the task family's root takes
+ *   the family's fingerprint (its versions' states, runs, decisions,
+ *   progress checkpoints, what the agent did last, and whether each live
+ *   run's worker still answers); when it changed, every open page hears
+ *   "change" and reads the task again the usual way. The nudge carries no
+ *   task data. With nothing written, an open page costs no reads; a
+ *   30-second check heals a missed signal (and notices a lapsed worker).
+ * - Who's here. Everyone else with the task open, by name, one line per
+ *   person however many pages they have. Memory only; it goes when the page
+ *   closes or hides.
+ *
+ * Streams are refresh hints only: nothing here writes, and a page that can't
+ * keep one open reads itself on its usual beat.
+ */
+import { createHash } from "node:crypto";
+import { createLiveRooms } from "./live-bus.js";
+import { DEFAULT_LIVENESS_MS } from "./runner.js";
+import { BUILT_IN } from "./store.js";
+/** What changes when anything on the task page changes: one read over the family, kept short and opaque. */
+export function taskFingerprint(store, root, now, livenessMs = DEFAULT_LIVENESS_MS) {
+    const row = store.handle.prepare(`WITH RECURSIVE family(ref, ext, depth) AS (
+      SELECT id, external_id, 0 FROM task_ref WHERE backend = ?3 AND external_id = ?1
+      UNION
+      SELECT child.id, child.external_id, family.depth + 1 FROM family
+        JOIN task_ref child ON child.backend = ?3 AND child.revision_of = family.ext WHERE family.depth < 63
+    )
+    SELECT (SELECT count(*) || ':' || group_concat(t.state || '@' || t.updated_at, ',') FROM family JOIN task t ON t.id = family.ext) AS tasks,
+      (SELECT count(*) || ':' || coalesce(max(r.id), 0) || ':' || coalesce(sum(r.outcome IS NULL), 0) || ':' || coalesce(max(coalesce(r.finished_at, r.started_at)), '') || ':' || coalesce(group_concat(r.phase), '')
+         FROM run r WHERE r.task_ref IN (SELECT ref FROM family)) AS runs,
+      (SELECT count(*) || ':' || coalesce(max(d.id), 0) || ':' || coalesce(sum(d.state = 'answered'), 0) FROM decision d JOIN run r ON r.id = d.run WHERE r.task_ref IN (SELECT ref FROM family)) AS decisions,
+      (SELECT coalesce(max(c.id), 0) FROM run_checkpoint c WHERE c.task_ref IN (SELECT ref FROM family)) AS progress,
+      (SELECT coalesce(max(a.at), '') FROM run_activity a JOIN run r ON r.id = a.run WHERE r.task_ref IN (SELECT ref FROM family) AND r.outcome IS NULL) AS activity,
+      (SELECT coalesce(group_concat(w.heartbeat_at > ?2), '') FROM run r JOIN runner w ON w.name = r.runner WHERE r.task_ref IN (SELECT ref FROM family) AND r.outcome IS NULL) AS workers
+    WHERE EXISTS (SELECT 1 FROM family)`).get(root, new Date(now.getTime() - livenessMs).toISOString(), BUILT_IN);
+    return row === undefined ? null : createHash("sha256").update(Object.values(row).map(String).join("|")).digest("hex").slice(0, 16);
+}
+/** Rooms keyed by the task family's root. With a bus, a write reaches every open page at once; without one, only the safety net. */
+export function createTaskRooms(fingerprint, options = {}) {
+    // Everyone on the task but you, once each, by name.
+    return createLiveRooms(fingerprint, (viewers, me) => [...new Set(viewers.map(one => one.name).filter(name => name !== me))].sort((a, b) => a.localeCompare(b)), options);
+}

package/dist/work-index.js

@@ -242,6 +242,17 @@ const PROJECTION = `WITH RECURSIVE admitted AS MATERIALIZED (
   FROM claimed c LEFT JOIN action_ledger completed ON completed.id=c.checked_id WHERE ($state IS NULL OR c.state=$state) AND ($leadId IS NULL OR EXISTS(SELECT 1 FROM team_task_owner own WHERE own.task_ref=c.root_ref AND own.lead=$leadId))
 )`;
 const registered = new WeakMap();
+const statements = new WeakMap();
+/** The page query is long and has one text per view filter: compile each once per connection. */
+function prepared(store, sql) {
+    let cache = statements.get(store.handle);
+    if (cache === undefined)
+        statements.set(store.handle, cache = new Map());
+    let statement = cache.get(sql);
+    if (statement === undefined)
+        cache.set(sql, statement = store.handle.prepare(sql));
+    return statement;
+}
 /** Connection-local pure parsing, with exactly the authoritative stored-scope
  * validator. The callback cannot query, inspect files or grant authority. */
 function registerValidators(store) {
@@ -358,7 +369,7 @@ export function workIndexPage(store, now, access, options = {}) {
     const limit = Number.isFinite(options.limit) ? Math.max(1, Math.min(WORK_INDEX_MAX_LIMIT, Math.floor(options.limit))) : WORK_INDEX_PAGE_LIMIT;
     const scope = cursorScope(access, options, view), cursor = readCursor(options.cursor, scope);
     const filter = view === 'needs-you' ? 'needs=1' : view === 'running' ? 'family_running=1' : view === 'completed' ? "code='complete'" : '1';
-    const rows = store.handle.prepare(`${projection}, selected_page AS MATERIALIZED (
+    const rows = prepared(store, `${projection}, selected_page AS MATERIALIZED (
     SELECT * FROM ranked WHERE ${filter} AND ($cursorRoot=0 OR
       ${ORDER}>$cursorRank OR (${ORDER}=$cursorRank AND (sort_at<$cursorAt OR (sort_at=$cursorAt AND root_ref<$cursorRoot))))
     ORDER BY ${ORDER},sort_at DESC,root_ref DESC LIMIT $limit

package/dist/workspace-revision.d.ts

@@ -1,4 +1,6 @@
 import type { Store } from './store.js';
+/** The service_cursor row the revision triggers move (live-bus.ts listens for it). */
+export declare const WORKSPACE_REVISION_KEY = "workspace-content:v1";
 export type WorkspaceRevision = {
     current(): string;
     expiresAt(now: Date): number;

package/dist/workspace-revision.js

@@ -2,7 +2,9 @@
  * metadata only: it never grants access or certifies task/process state. */
 import { createHash } from 'node:crypto';
 import { DEFAULT_LIVENESS_MS } from './runner.js';
-const KEY = 'workspace-content:v1';
+/** The service_cursor row the revision triggers move (live-bus.ts listens for it). */
+export const WORKSPACE_REVISION_KEY = 'workspace-content:v1';
+const KEY = WORKSPACE_REVISION_KEY;
 const PREFIX = 'workspace_revision_v1_';
 const MAX_AGE_MS = 60_000;
 const OMIT = new Set(['schema_version', 'service_cursor', 'wake', 'notification_delivery',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolroll",
-  "version": "0.9.46",
+  "version": "0.9.48",
   "description": "A control plane for unattended coding agents — queue tasks, walk away, come back to pull requests. Agents build in leased worktrees, never touch your default branch, and interrupt you only for decisions that need a human.",
   "directories": {
     "doc": "docs"