@timqi/pier 0.0.29 → 0.1.0

package/dist/tasks/groups.js

@@ -2,12 +2,10 @@
 // separate endings into one answer — when the join condition is met, which
 // members are cancelled, and the single aggregated callback that goes back.
 // Delivering it is the outbox's job; deciding it is this file's.
-import { Router } from "../core/router.js";
 import { logger } from "../log.js";
 import { runRef, runResultText } from "./callbacks.js";
 import { newId } from "./definitions.js";
 import { Outbox } from "./outbox.js";
-import { TaskStore } from "./store.js";
 import { isTerminal } from "./types.js";
 const log = logger("tasks");
 /** Core-owned fan-out join: members run detached, the group delivers one
@@ -16,11 +14,13 @@ export class TaskGroups {
     store;
     host;
     changed;
+    unreachable;
     outbox;
     constructor(store, router, host, changed, unreachable) {
         this.store = store;
         this.host = host;
         this.changed = changed;
+        this.unreachable = unreachable;
         this.outbox = new Outbox(router, {
             id: (group) => group.id,
             reload: (id) => this.store.getGroup(id),
@@ -38,21 +38,21 @@ export class TaskGroups {
     }
     /** Enqueues every member or none: a partially started group is worse than
      * a rejected one. */
-    runAll(definitions, join, callerSessionId, parentRunId, callbackSessionId) {
-        const group = this.create(join, callerSessionId, callbackSessionId);
-        const runs = [];
-        try {
-            for (const definition of definitions) {
-                runs.push(this.host.startMember(definition.id, group.id, callerSessionId, parentRunId));
-            }
-        }
-        catch (error) {
-            log.warn(`group ${group.id} rolled back after ${String(runs.length)} members`, error);
-            for (const run of runs)
-                this.host.cancel(run.id);
-            throw error;
-        }
-        this.setMembers(group, runs.map((run) => run.id));
+    runAll(definitions, join, callerSessionId, parentRunId, callbackSessionId, callbackMode) {
+        if (definitions.length < 2)
+            throw new Error("a task group needs at least 2 members");
+        const { group, runs } = this.store.transact(() => {
+            const group = this.create(join, callerSessionId, callbackSessionId, callbackMode);
+            const runs = definitions.map((definition) => this.host.prepareMember(definition.id, group.id, callerSessionId, parentRunId));
+            group.memberRunIds = runs.map((run) => run.id);
+            this.store.saveGroup(group);
+            return { group, runs };
+        });
+        this.changed(group);
+        for (const run of runs)
+            this.host.startMember(run);
+        // Skipped members do not pass through execution's settled hook.
+        this.evaluate(this.get(group.id));
         return { group: this.get(group.id), runs };
     }
     members(id) {
@@ -64,12 +64,13 @@ export class TaskGroups {
             this.host.cancel(runId);
         return this.get(id);
     }
-    create(join, invokedBySessionId, callbackSessionId) {
-        const group = {
+    create(join, invokedBySessionId, callbackSessionId, callbackMode) {
+        return {
             id: newId(),
             join,
             invokedBySessionId,
             callbackSessionId,
+            ...(callbackMode === "steer" ? { callbackMode } : {}),
             memberRunIds: [],
             winnerRunId: null,
             callbackState: null,
@@ -79,13 +80,6 @@ export class TaskGroups {
             createdAt: Date.now(),
             finishedAt: null,
         };
-        this.store.saveGroup(group);
-        return group;
-    }
-    setMembers(group, runIds) {
-        group.memberRunIds = runIds;
-        this.store.saveGroup(group);
-        this.changed(group);
     }
     get(id) {
         const group = this.store.getGroup(id);
@@ -109,6 +103,21 @@ export class TaskGroups {
         }
     }
     evaluate(group) {
+        if (group.finishedAt !== null)
+            return;
+        // Old versions could leave an empty group when admission failed. Retire
+        // that broken record without inventing a successful zero-member join.
+        if (group.memberRunIds.length === 0) {
+            group.finishedAt = Date.now();
+            group.callbackState = group.callbackSessionId ? "abandoned" : null;
+            group.callbackError = "group admission failed before its members were recorded";
+            this.store.saveGroup(group);
+            this.changed(group);
+            log.error(`group ${group.id}: ${group.callbackError}`);
+            if (group.callbackSessionId)
+                this.unreachable(group.callbackSessionId, `task group ${group.id}`, group.callbackError);
+            return;
+        }
         const members = group.memberRunIds.map((id) => this.host.getRun(id));
         if (group.join === "first") {
             const winner = members.find((run) => isTerminal(run.state));

package/dist/tasks/messages.js

@@ -4,12 +4,9 @@
 // the two ends are different sessions and either may be mid-turn, gone, or
 // finished — an undelivered message is retried, expired and *said*, never
 // dropped (§5b).
-import { EventHub } from "../core/hub.js";
-import { Router } from "../core/router.js";
 import { logger } from "../log.js";
 import { runSource } from "./callbacks.js";
 import { newId } from "./definitions.js";
-import { TaskStore } from "./store.js";
 import { isTerminal, MAX_DELIVERY_ATTEMPTS, retryDelay, undeliverable } from "./types.js";
 const log = logger("tasks");
 const MAX_MESSAGE_LENGTH = 16 * 1024;
@@ -25,18 +22,20 @@ export class TaskMessenger {
     store;
     router;
     hub;
-    resumeRun;
+    prepareResume;
     unreachable;
+    startRun;
     constructor(store, router, hub, 
-    /** Continues a terminal child with a supervisor reply as its prompt. */
-    resumeRun, 
+    /** Prepares a continuation; it starts only after the reply commits. */
+    prepareResume, 
     /** Reports a delivery nobody can complete (service.ts owns the surfaces). */
-    unreachable) {
+    unreachable, startRun) {
         this.store = store;
         this.router = router;
         this.hub = hub;
-        this.resumeRun = resumeRun;
+        this.prepareResume = prepareResume;
         this.unreachable = unreachable;
+        this.startRun = startRun;
     }
     expirePending() {
         for (const message of this.store.expirePendingMessages())
@@ -49,6 +48,7 @@ export class TaskMessenger {
     /** A manual continuation supersedes an unanswered decision (design 04):
      * one continuation per run, never two racing ones. */
     expireDecisions(runId, reason) {
+        const expired = [];
         for (const message of this.store.listMessages(runId)) {
             if (message.kind !== "decision" || (message.state !== "pending" && message.state !== "delivered"))
                 continue;
@@ -56,8 +56,9 @@ export class TaskMessenger {
             message.error = reason;
             message.answeredAt = Date.now();
             this.store.saveMessage(message);
-            this.changed(message);
+            expired.push(message);
         }
+        return expired;
     }
     list(runId) {
         return this.store.listMessages(runId);
@@ -67,6 +68,7 @@ export class TaskMessenger {
     }
     async control(run, fromSessionId, kind, content) {
         const message = this.create(run, kind, fromSessionId, run.targetSessionId ?? "", content, null);
+        this.changed(message);
         if (run.targetSessionId)
             this.deliver(message, run, run.targetSessionId);
         return this.require(message.id);
@@ -139,6 +141,7 @@ export class TaskMessenger {
             throw new Error("run already has a pending supervisor decision");
         }
         const message = this.create(run, reason, fromSessionId, run.invokedBySessionId, content, null);
+        this.changed(message);
         this.deliver(message, run, run.invokedBySessionId);
         return this.require(message.id);
     }
@@ -161,25 +164,28 @@ export class TaskMessenger {
         const run = this.store.getRun(question.runId);
         if (!run)
             throw new Error(`unknown task run: ${question.runId}`);
-        const reply = this.create(run, "reply", fromSessionId, question.fromSessionId, text, question.id);
-        question.state = "answered";
-        question.answeredAt = Date.now();
-        this.store.saveMessage(question);
+        // A rejected continuation must leave the question answerable. Persist the
+        // answer and its queued run together, before either publishes or executes.
+        const { reply, continuation } = this.store.transact(() => {
+            const reply = this.create(run, "reply", fromSessionId, question.fromSessionId, text, question.id);
+            question.state = "answered";
+            question.answeredAt = Date.now();
+            this.store.saveMessage(question);
+            const continuation = isTerminal(run.state)
+                ? this.prepareResume(run.id, this.format(reply, run), fromSessionId)
+                : undefined;
+            if (continuation) {
+                reply.resumeRunId = continuation.id;
+                this.store.saveMessage(reply);
+            }
+            return { reply, continuation };
+        });
         this.changed(question);
-        // Core routes the reply: follow-up into an active run, auto-resume of a
-        // terminal one — the replier gets the continuation's callback.
-        if (run.targetSessionId && (run.state === "queued" || run.state === "running")) {
+        this.changed(reply);
+        if (continuation)
+            this.startRun(continuation);
+        else if (run.targetSessionId)
             this.deliver(reply, run, run.targetSessionId);
-        }
-        else if (isTerminal(run.state)) {
-            // Creating the continuation is not delivering the reply: the run is
-            // queued, and a restart or a cancel before it starts loses the prompt
-            // that carries the text. So the id is recorded and the sweep below
-            // settles it against the continuation's own `startedAt`.
-            reply.resumeRunId = this.resumeRun(run.id, this.format(reply, run), fromSessionId).id;
-            this.store.saveMessage(reply);
-            this.changed(reply);
-        }
         return this.require(reply.id);
     }
     create(run, kind, fromSessionId, toSessionId, content, replyTo) {
@@ -200,7 +206,6 @@ export class TaskMessenger {
             nextAttemptAt: null,
         };
         this.store.saveMessage(message);
-        this.changed(message);
         return message;
     }
     /** Never awaits the recipient: the seam's `systemInput` settles with the turn
@@ -377,6 +382,7 @@ export class TaskMessenger {
             throw new Error(`unknown task message: ${id}`);
         return message;
     }
+    /** Publish only after any transaction changing this message has committed. */
     changed(message) {
         this.hub.emitWorkspace({ type: "task-message-changed", runId: message.runId, messageId: message.id });
     }

package/dist/tasks/outbox.js

@@ -3,10 +3,12 @@
 // this logic was written twice and the two copies drifted — the ceiling was
 // checked in one order here and another there, and only one of them counted a
 // failed attempt.
-import { Router } from "../core/router.js";
 import { logger } from "../log.js";
 import { MAX_DELIVERY_ATTEMPTS, retryDelay, undeliverable } from "./types.js";
 const log = logger("tasks");
+/** The records a delivery names, from either side of the seam: a batch names
+ *  every one of them, a group names itself. */
+const callbackIds = (origin) => origin?.kind === "task-callback" ? origin.runIds ?? [origin.runId] : [];
 export class Outbox {
     router;
     kind;
@@ -35,6 +37,7 @@ export class Outbox {
             return;
         for (const record of mine)
             this.delivering.add(this.kind.id(record));
+        const counted = new Set();
         try {
             const session = await this.router.ensure({ channelId: "task", conversationId: sessionId });
             // The transcript read is both the crash-window dedupe and the proof.
@@ -46,40 +49,64 @@ export class Outbox {
                 return;
             // Waiting for a busy target is not a delivery attempt: counting it would
             // inflate the attempts once per second and skip the failure backoff
-            // straight to its ceiling.
-            if (session.state === "streaming") {
+            // straight to its ceiling. A record delegated with `steer` is the
+            // exception it asked for — it joins the running turn instead, and the
+            // rest of the batch keeps waiting for the turn to end. But only once:
+            // handed over, a steer sits in Pi's in-memory queue, invisible in the
+            // transcript until the turn drains it, so the queue is the second place
+            // this has to look before deciding nothing arrived (messages.ts:340).
+            const streaming = session.state === "streaming";
+            let sending = live;
+            if (streaming) {
+                const handedOver = await this.queued(session);
+                const steerNow = (record) => record.callbackMode === "steer" && !handedOver.has(this.kind.id(record));
+                sending = live.filter(steerNow);
                 for (const record of live)
-                    this.defer(record);
-                return;
+                    if (!steerNow(record))
+                        this.defer(record);
+                if (sending.length === 0)
+                    return;
             }
-            for (const record of live)
+            for (const record of sending) {
                 this.sent(record);
-            const { text, origin } = this.kind.input(live);
-            log.debug(`callback for ${live.map((r) => this.kind.id(r)).join(", ")} → session ${sessionId}`);
+                counted.add(this.kind.id(record));
+            }
+            const { text, origin } = this.kind.input(sending);
+            log.debug(`callback for ${sending.map((r) => this.kind.id(r)).join(", ")} → session ${sessionId}`);
             // Not awaited: `systemInput` settles with the recipient's whole turn, and
             // holding the delivery lock that long would keep the proof from ever
             // being read — which is the only thing that marks this delivered.
-            session.systemInput(text, origin, "followUp")
-                .catch((error) => this.retry(sessionId, live, error));
+            session.systemInput(text, origin, streaming ? "steer" : "followUp")
+                .catch((error) => this.retry(sessionId, sending, error, counted));
             // Pi records the input as it starts the turn, so the proof is usually
             // here already; the tick sweep is the backstop when it is not.
-            await this.settle(live, session);
+            await this.settle(sending, session);
         }
         catch (error) {
-            this.retry(sessionId, mine, error);
+            this.retry(sessionId, mine, error, counted);
         }
         finally {
             for (const record of mine)
                 this.delivering.delete(this.kind.id(record));
         }
     }
+    /** Handed over and waiting in the recipient's queue for the running turn to
+     *  drain it — what the transcript cannot answer yet. Empty unless the
+     *  session is streaming: Pi drops the list when the turn ends. */
+    async queued(session) {
+        const ids = new Set();
+        for (const origin of await session.pendingSystemInputs())
+            for (const id of callbackIds(origin))
+                ids.add(id);
+        return ids;
+    }
     /** Marks every record the transcript proves; returns the ones it does not. */
     async settle(records, session) {
         const seen = new Set();
         for (const turn of await session.history()) {
-            if (turn.role !== "system" || turn.origin?.kind !== "task-callback")
+            if (turn.role !== "system")
                 continue;
-            for (const id of turn.origin.runIds ?? [turn.origin.runId])
+            for (const id of callbackIds(turn.origin))
                 seen.add(id);
         }
         const unproven = [];
@@ -95,14 +122,15 @@ export class Outbox {
     /** The recipient is waiting for an answer that is now late: the retry itself
      *  is silent, so this line is the only sign it is being retried — and the
      *  ceiling is what ends the retrying out loud. */
-    retry(sessionId, batch, error) {
+    retry(sessionId, batch, error, counted) {
         log.warn(`callback to session ${sessionId} failed, will retry`, error);
         for (const stale of batch) {
             const record = this.kind.reload(this.kind.id(stale));
             // Already proven delivered, or already given up on: not a failure.
             if (!record || (record.callbackState !== "pending" && record.callbackState !== "failed"))
                 continue;
-            this.failed(record, error);
+            this.failed(record, error, counted.has(this.kind.id(record)));
+            counted.add(this.kind.id(record));
             this.spent(record, sessionId);
         }
     }
@@ -140,11 +168,10 @@ export class Outbox {
         record.callbackNextAttemptAt = null;
         this.write(record);
     }
-    /** Counts the attempt too: a target that fails before anything is sent (a
-     *  transcript that no longer exists) would otherwise retry at attempt 0 for
-     *  as long as the process lives, never reaching the ceiling. */
-    failed(record, error) {
-        record.callbackAttempts += 1;
+    /** A failed pass costs one attempt, whether it died before or after send. */
+    failed(record, error, counted) {
+        if (!counted)
+            record.callbackAttempts += 1;
         record.callbackState = "failed";
         record.callbackError = String(error);
         record.callbackNextAttemptAt = Date.now() + retryDelay(record.callbackAttempts);

package/dist/tasks/routes.js

@@ -51,10 +51,7 @@ export function registerTaskRoutes(app, tasks, activity) {
             const now = Date.now();
             const recent = c.req.query("scope") === "recent";
             const windowStart = now - 24 * 60 * 60 * 1000;
-            // "recent" is a superset of "active": a run still going is part of the
-            // last 24h no matter when it was queued, so it never drops a live run.
-            const runs = tasks.recentRuns(200).filter((run) => run.state === "queued" || run.state === "running" ||
-                (recent && run.queuedAt >= windowStart));
+            const runs = tasks.activityRuns(recent ? windowStart : undefined);
             const listed = await activity.factory.list();
             const byId = new Map(listed.map((session) => [session.id, session]));
             const linkedIds = new Set();

package/dist/tasks/runs.js

@@ -4,9 +4,7 @@
 // exploding (depth, children per root) are decided here, once, because every
 // caller — scheduler, tool, HTTP — enqueues through this one door.
 import { logger } from "../log.js";
-import { TaskCallbacks } from "./callbacks.js";
 import { newId } from "./definitions.js";
-import { TaskStore } from "./store.js";
 const log = logger("tasks");
 const MAX_DEPTH = 2;
 const MAX_CHILDREN_PER_ROOT = 16;
@@ -23,7 +21,8 @@ export class TaskRunQueue {
         this.execute = execute;
         this.changed = changed;
     }
-    enqueue(definition, input, source, parentRunId, provenance) {
+    /** Validate and persist only; callers may stage several runs in a transaction. */
+    prepare(definition, input, source, parentRunId, provenance) {
         const id = newId();
         const parent = parentRunId ? this.getRun(parentRunId) : null;
         const depth = provenance.depth ?? (parent ? parent.depth + 1 : 0);
@@ -63,6 +62,7 @@ export class TaskRunQueue {
             targetSessionId,
             sessionMode,
             callbackSessionId,
+            ...(provenance.callbackMode === "steer" ? { callbackMode: "steer" } : {}),
             background: provenance.background ?? false,
             callbackState: overlapped && callbackSessionId ? "pending" : null,
             callbackAttempts: 0,
@@ -84,7 +84,14 @@ export class TaskRunQueue {
             finishedAt: overlapped ? now : null,
         };
         this.store.saveRun(run);
+        return run;
+    }
+    /** Publish and execute only after all records this run relies on committed. */
+    start(run) {
         this.changed(run);
+        const { id, depth, triggerSource: source } = run;
+        const overlapped = run.skipReason === "overlap";
+        const definition = run.context.definition;
         // Why a run exists is the first question asked of a surprising one, and it
         // is answerable only here: the row keeps the ids, not the reason. A watch
         // probe queues on every interval and mostly matches nothing, so it says so
@@ -99,6 +106,5 @@ export class TaskRunQueue {
             this.execute(run);
         else if (run.callbackState === "pending")
             void this.callbacks.deliver(run);
-        return run;
     }
 }

package/dist/tasks/service.js

@@ -4,8 +4,6 @@
 // like it makes belongs to a file beside it (definitions, runs, execution,
 // groups, messages, callbacks) — what is genuinely here is scheduling and the
 // facade, so the HTTP routes and the task tool cannot drift apart.
-import { EventHub } from "../core/hub.js";
-import { Router } from "../core/router.js";
 import { logger } from "../log.js";
 import { AgentTaskRunner } from "./agent.js";
 import { TaskCallbacks } from "./callbacks.js";
@@ -14,7 +12,6 @@ import { TaskExecution } from "./execution.js";
 import { TaskGroups } from "./groups.js";
 import { TaskMessenger } from "./messages.js";
 import { TaskRunQueue } from "./runs.js";
-import { TaskStore } from "./store.js";
 import { handleTaskTool } from "./tool.js";
 import { isTerminal } from "./types.js";
 const log = logger("tasks");
@@ -52,20 +49,21 @@ export class TaskService {
         this.hub = hub;
         this.instance = instance;
         const unreachable = (sessionId, what, why) => this.unreachable(sessionId, what, why);
-        this.messages = new TaskMessenger(store, router, hub, (runId, prompt, fromSessionId) => this.resume(runId, prompt, { invokedBySessionId: fromSessionId, callbackSessionId: fromSessionId, background: true }), unreachable);
+        this.messages = new TaskMessenger(store, router, hub, (runId, prompt, fromSessionId) => this.prepareResume(runId, prompt, { invokedBySessionId: fromSessionId, callbackSessionId: fromSessionId, background: true }), unreachable, (run) => this.runs.start(run));
         this.definitions = new TaskDefinitions(store, factory, router, hub, instance?.systemActions);
         this.callbacks = new TaskCallbacks(store, router, (run) => this.changed(run), unreachable);
         this.groups = new TaskGroups(store, router, {
             getRun: (id) => this.getRun(id),
             cancel: (id) => { this.cancel(id); },
             openDecisionId: (runId) => this.messages.openDecisionId(runId),
-            startMember: (taskId, groupId, callerSessionId, parentRunId) => this.run(taskId, null, "agent", parentRunId, {
+            prepareMember: (taskId, groupId, callerSessionId, parentRunId) => this.prepareRun(taskId, null, "agent", parentRunId, {
                 invokedBySessionId: callerSessionId,
                 sourceSessionId: callerSessionId,
                 callbackSessionId: null,
                 background: true,
                 groupId,
             }),
+            startMember: (run) => this.runs.start(run),
         }, (group) => this.hub.emitWorkspace({ type: "task-group-changed", groupId: group.id }), unreachable);
         const agent = new AgentTaskRunner(factory, router, store, this.messages, (run) => this.changed(run));
         this.execution = new TaskExecution(store, this.definitions, this.callbacks, agent, {
@@ -198,8 +196,8 @@ export class TaskService {
     queryRuns(query = {}) {
         return this.store.queryRuns(query);
     }
-    recentRuns(limit = 100) {
-        return this.store.listRecentRuns(limit);
+    activityRuns(since) {
+        return this.store.activityRuns(since);
     }
     recentMessages(since) {
         return this.messages.recent(since);
@@ -222,13 +220,18 @@ export class TaskService {
         return this.store.taskOwnedSessionIds();
     }
     run(taskId, input = null, source = "manual", parentRunId = null, provenance = {}) {
+        const run = this.prepareRun(taskId, input, source, parentRunId, provenance);
+        this.runs.start(run);
+        return run;
+    }
+    prepareRun(taskId, input, source, parentRunId, provenance) {
         this.refusePaused(parentRunId);
         const task = this.get(taskId);
         // `enabled:false` pauses scheduling only; manual and agent triggers still
         // run a paused task on demand. Archiving is the terminal state.
         if (task.archived)
             throw new Error("archived tasks cannot run");
-        return this.runs.enqueue(task, input, source, parentRunId, provenance);
+        return this.runs.prepare(task, input, source, parentRunId, provenance);
     }
     async waitForRun(id) {
         const current = this.getRun(id);
@@ -256,9 +259,9 @@ export class TaskService {
     getGroup(id) {
         return this.groups.members(id);
     }
-    runGroup(definitions, join, callerSessionId, parentRunId, callbackSessionId) {
+    runGroup(definitions, join, callerSessionId, parentRunId, callbackSessionId, callbackMode) {
         this.refusePaused(parentRunId);
-        return this.groups.runAll(definitions, join, callerSessionId, parentRunId, callbackSessionId);
+        return this.groups.runAll(definitions, join, callerSessionId, parentRunId, callbackSessionId, callbackMode);
     }
     descendants(run) {
         const byParent = new Map();
@@ -291,6 +294,16 @@ export class TaskService {
         return this.messages.reply(messageId, fromSessionId, message);
     }
     resume(id, message, provenance = {}) {
+        const { run, expired } = this.store.transact(() => ({
+            run: this.prepareResume(id, message, provenance),
+            expired: this.messages.expireDecisions(id, "superseded by a manual resume"),
+        }));
+        for (const message of expired)
+            this.messages.changed(message);
+        this.runs.start(run);
+        return run;
+    }
+    prepareResume(id, message, provenance) {
         this.refusePaused();
         const prior = this.getRun(id);
         if (!isTerminal(prior.state))
@@ -299,8 +312,7 @@ export class TaskService {
             throw new Error("only persisted Agent runs can be resumed");
         }
         const prompt = requiredString(message, "message");
-        this.messages.expireDecisions(prior.id, "superseded by a manual resume");
-        return this.runs.enqueue(prior.context.definition, null, "agent", null, {
+        return this.runs.prepare(prior.context.definition, null, "agent", null, {
             ...provenance,
             sourceSessionId: provenance.invokedBySessionId ?? prior.invokedBySessionId,
             targetSessionId: prior.targetSessionId,

package/dist/tasks/store.js

@@ -2,7 +2,7 @@
 // runs, groups and messages are rows here, read and written through one
 // connection db.ts opened. A store owns its queries, never its own tables or
 // its own handle — the schema is db.ts's migration list.
-import { pierDb, statements } from "../db.js";
+import { pierDb, statements, transact } from "../db.js";
 const clamp = (limit, cap) => Math.min(Math.max(limit, 1), cap);
 export class TaskStore {
     db;
@@ -12,6 +12,10 @@ export class TaskStore {
         this.db = db;
         this.sql = statements(db);
     }
+    /** Commit related task records before publishing events or starting work. */
+    transact(work) {
+        return transact(this.db, work);
+    }
     // Every table is one JSON column plus query columns; these two are the only
     // readers, and the one seam where a future schema change normalizes old rows
     // (pre-v1 databases are refused outright in db.ts).
@@ -101,8 +105,18 @@ export class TaskStore {
             nextCursor: rows.length > limit && last ? { queuedAt: last.queuedAt, id: last.id } : null,
         };
     }
-    listRecentRuns(limit = 100) {
-        return this.#many("SELECT json FROM task_runs ORDER BY queued_at DESC LIMIT ?", clamp(limit, 500));
+    /** Activity never limits live work; only its optional history is bounded. */
+    activityRuns(since) {
+        const active = this.#many("SELECT json FROM task_runs WHERE state IN ('queued', 'running') ORDER BY queued_at DESC, id DESC");
+        if (since === undefined)
+            return active;
+        const recent = this.#many(`
+      SELECT json FROM task_runs
+      WHERE state NOT IN ('queued', 'running') AND queued_at >= ?
+        AND NOT (state = 'succeeded' AND json_extract(json, '$.matched') IS 0)
+      ORDER BY queued_at DESC, id DESC LIMIT 200
+    `, since);
+        return [...active, ...recent].sort((a, b) => b.queuedAt - a.queuedAt || b.id.localeCompare(a.id));
     }
     listRunsByRoot(rootRunId, limit = 100) {
         return this.#many(`