@timqi/pier 0.1.3 → 0.1.5

package/dist/tasks/definitions.js

@@ -1,6 +1,6 @@
 // What a task *is* before it ever runs: the id it is minted with, the draft
 // validated into a definition, and when its trigger is next due. Every way a
-// definition can be created — HTTP, the task tool, Pier's own owned task —
+// definition can be created — HTTP, `pier task`, Pier's own owned task —
 // arrives here, so a field is checked in one place or nowhere.
 import { randomBytes } from "node:crypto";
 import { stat } from "node:fs/promises";
@@ -24,7 +24,7 @@ export const idSymbol = (byte) => ID_ALPHABET.charAt(byte & 31);
  *  not an error — `saveRun`'s ON CONFLICT DO UPDATE would quietly overwrite. */
 export const newId = () => Array.from(randomBytes(16), idSymbol).join("");
 /** A definition Pier's own code created is reconciled by that code and edited
- *  by nobody: `creator` is `"http"` (Console) or `session:<id>` (task tool);
+ *  by nobody: `creator` is `"http"` (Console) or `session:<id>` (`pier task`);
  *  anything else is an instance-layer owner, which names itself in `by`.
  *  Otherwise a public surface could repoint the tools task while its switch
  *  went on claiming Pier keeps the tools current. */
@@ -258,7 +258,7 @@ export class TaskDefinitions {
         if (trigger.type === "watch")
             await this.assertDirectory(trigger.cwd);
         const actionRaw = record(value.action);
-        // Self-documenting: tool callers (models) recover from this in one retry.
+        // Self-documenting: a model recovers from this in one retry.
         if (!actionRaw) {
             throw new Error('action required, e.g. {"type":"agent","session":{"mode":"fresh","cwd":"/abs/path"},"prompt":"..."}');
         }

package/dist/tasks/execution.js

@@ -92,9 +92,7 @@ export class TaskExecution {
                 log.debug(`${settled} (watch did not match)`);
             else
                 log.info(settled);
-            // A run that ends awaiting a supervisor decision suppresses its
-            // completion callback: the pending question is the notification.
-            if (run.callbackSessionId && !this.host.openDecisionId(run.id))
+            if (run.callbackSessionId)
                 run.callbackState = "pending";
             this.controllers.delete(run.id);
             try {

package/dist/tasks/groups.js

@@ -35,12 +35,12 @@ export class TaskGroups {
     }
     /** Enqueues every member or none: a partially started group is worse than
      * a rejected one. */
-    runAll(definitions, join, callerSessionId, parentRunId, callbackSessionId, callbackMode) {
+    runAll(definitions, join, callerSessionId, 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));
+            const runs = definitions.map((definition) => this.host.prepareMember(definition.id, group.id, callerSessionId));
             group.memberRunIds = runs.map((run) => run.id);
             this.store.saveGroup(group);
             return { group, runs };
@@ -150,9 +150,6 @@ export class TaskGroups {
                 `- "${run.context.definition.name}" \u2014 state: ${run.state}`,
                 `  ${runRef(run)}`,
             ];
-            const decision = this.host.openDecisionId(run.id);
-            if (decision)
-                head.push(`  Needs a decision: reply to message ${decision}`);
             if (group.join === "first" && run.id !== group.winnerRunId) {
                 head.push("  Cancelled after the winning run; resume its session to recover partial work.");
                 return head.join("\n");

package/dist/tasks/messages.js

@@ -1,15 +1,15 @@
-// What a parent and a child say to each other while a run is going. Every
-// message is a durable row before it is a delivery: either end may be mid-turn
-// or gone, and an undelivered message is retried, expired and said, never
-// dropped (§5). Delivery itself belongs to outbox.ts.
+// What a parent says to a child while a run is going. Every message is a
+// durable row before it is a delivery: the child may be mid-turn or gone, and
+// an undelivered message is retried, expired and said, never dropped (§5).
+// Delivery itself belongs to outbox.ts.
 import { runSource } from "./callbacks.js";
 import { newId } from "./definitions.js";
 import { Outbox } from "./outbox.js";
 import { isTerminal } from "./types.js";
 const MAX_MESSAGE_LENGTH = 16 * 1024;
-/** `answered` is a delivery that was read; `expired` is one given up on. */
+/** `expired` is a delivery given up on. */
 const ENGINE_STATE = {
-    pending: "pending", failed: "failed", delivered: "delivered", answered: "delivered", expired: "abandoned",
+    pending: "pending", failed: "failed", delivered: "delivered", expired: "abandoned",
 };
 function bounded(content) {
     const text = content.trim();
@@ -22,20 +22,14 @@ function bounded(content) {
 export class TaskMessenger {
     store;
     hub;
-    prepareResume;
     unreachable;
-    startRun;
     outbox;
     constructor(store, router, hub, 
-    /** Prepares a continuation; it starts only after the reply commits. */
-    prepareResume, 
     /** Reports a delivery nobody can complete (service.ts owns the surfaces). */
-    unreachable, startRun) {
+    unreachable) {
         this.store = store;
         this.hub = hub;
-        this.prepareResume = prepareResume;
         this.unreachable = unreachable;
-        this.startRun = startRun;
         this.outbox = new Outbox(router, {
             id: ({ message }) => message.id,
             reload: (id) => {
@@ -50,10 +44,8 @@ export class TaskMessenger {
                     message.state = "delivered";
                     message.deliveredAt = Date.now();
                 }
-                else if (callbackState === "abandoned") {
+                else if (callbackState === "abandoned")
                     message.state = "expired";
-                    message.answeredAt = Date.now();
-                }
                 else
                     message.state = callbackState ?? "pending";
                 this.store.saveMessage(message);
@@ -76,25 +68,6 @@ export class TaskMessenger {
         for (const message of this.store.expirePendingMessages())
             this.changed(message);
     }
-    /** The unanswered decision on a run, if any. */
-    openDecisionId(runId) {
-        return this.store.listMessages(runId).find((m) => m.kind === "decision" && (m.state === "pending" || m.state === "delivered"))?.id ?? null;
-    }
-    /** 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;
-            message.state = "expired";
-            message.error = reason;
-            message.answeredAt = Date.now();
-            this.store.saveMessage(message);
-            expired.push(message);
-        }
-        return expired;
-    }
     list(runId) {
         return this.store.listMessages(runId);
     }
@@ -102,7 +75,7 @@ export class TaskMessenger {
         return this.store.listRecentMessages(since);
     }
     async control(run, fromSessionId, kind, content) {
-        const message = this.create(run, kind, fromSessionId, run.targetSessionId ?? "", content, null);
+        const message = this.create(run, kind, fromSessionId, run.targetSessionId ?? "", content);
         this.changed(message);
         if (run.targetSessionId)
             this.deliver(message, run.targetSessionId);
@@ -112,9 +85,8 @@ export class TaskMessenger {
         if (!run.targetSessionId)
             return;
         for (const message of this.store.listMessages(run.id)) {
-            if (message.state !== "pending" || (message.kind !== "steer" && message.kind !== "follow_up"))
-                continue;
-            this.deliver(message, run.targetSessionId);
+            if (message.state === "pending")
+                this.deliver(message, run.targetSessionId);
         }
     }
     /** Delivery is fire-and-forget, so this sweep is what closes a failed one.
@@ -124,30 +96,13 @@ export class TaskMessenger {
             if (!run)
                 continue;
             // Expiring a dead control is not a retry, so it ignores the backoff.
-            if ((message.kind === "steer" || message.kind === "follow_up") && isTerminal(run.state)) {
+            if (isTerminal(run.state)) {
                 message.state = "expired";
                 message.error = "run finished before delivery completed";
                 this.store.saveMessage(message);
                 this.changed(message);
                 continue;
             }
-            // A reply that resumed a terminal run is the continuation's prompt, not a
-            // system input: the transcript read would re-inject it and start a turn no
-            // run owns. The continuation's `startedAt` is the proof instead.
-            if (message.kind === "reply" && isTerminal(run.state)) {
-                const resumed = message.resumeRunId ? this.store.getRun(message.resumeRunId) : undefined;
-                if (resumed?.startedAt)
-                    this.delivered(message);
-                else if (!resumed)
-                    this.abandon(message, `continuation ${message.resumeRunId ?? "(none)"} is gone`);
-                else if (isTerminal(resumed.state)) {
-                    // Never started and never will: said now, not four minutes later at
-                    // the ceiling. A duplicate report beats a special case that could
-                    // suppress the only one.
-                    this.abandon(message, `continuation ${resumed.id} ${resumed.state} before it started`);
-                }
-                continue;
-            }
             if ((message.nextAttemptAt ?? 0) > now)
                 continue;
             const target = message.toSessionId || run.targetSessionId;
@@ -155,76 +110,17 @@ export class TaskMessenger {
                 this.deliver(message, target);
         }
     }
-    /** Returns the receipt immediately; the reply arrives as a follow-up (active
-     *  run) or resumes the session (terminal run). A decision steers the
-     *  supervisor, or a blocked child would wait out its whole turn. */
-    async contact(run, fromSessionId, reason, content) {
-        if (!run.invokedBySessionId)
-            throw new Error("run has no supervisor session");
-        if (reason === "decision" && this.openDecisionId(run.id)) {
-            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.invokedBySessionId);
-        return this.require(message.id);
-    }
-    async reply(questionId, fromSessionId, content) {
-        const question = this.require(questionId);
-        if (question.kind !== "decision")
-            throw new Error("message is not a decision request");
-        if (question.toSessionId !== fromSessionId)
-            throw new Error("only the addressed supervisor may reply");
-        const existing = this.store.listMessages(question.runId).find((m) => m.kind === "reply" && m.replyTo === question.id);
-        const text = bounded(content);
-        if (existing) {
-            if (existing.content !== text)
-                throw new Error("decision already answered with different content");
-            return existing;
-        }
-        if (question.state !== "delivered" && question.state !== "pending") {
-            throw new Error(`decision is ${question.state}`);
-        }
-        const run = this.store.getRun(question.runId);
-        if (!run)
-            throw new Error(`unknown task run: ${question.runId}`);
-        // 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);
-        this.changed(reply);
-        if (continuation)
-            this.startRun(continuation);
-        else if (run.targetSessionId)
-            this.deliver(reply, run.targetSessionId);
-        return this.require(reply.id);
-    }
-    create(run, kind, fromSessionId, toSessionId, content, replyTo) {
+    create(run, kind, fromSessionId, toSessionId, content) {
         const message = {
             id: newId(),
             runId: run.id,
             kind,
             fromSessionId,
             toSessionId,
-            replyTo,
             state: "pending",
             content: bounded(content),
             createdAt: Date.now(),
             deliveredAt: null,
-            answeredAt: null,
             error: null,
             attempts: 0,
             nextAttemptAt: null,
@@ -247,56 +143,20 @@ export class TaskMessenger {
             callbackAttempts: message.attempts,
             callbackError: message.error,
             callbackNextAttemptAt: message.nextAttemptAt,
-            // Steer whatever someone is blocked on: a follow-up lands only once the
-            // recipient runs out of tool calls. Progress is a follow-up because nobody waits.
-            ...(message.kind === "follow_up" || message.kind === "progress" ? {} : { callbackMode: "steer" }),
+            // A steer interrupts; a follow-up lands only once the recipient runs out
+            // of tool calls.
+            ...(message.kind === "follow_up" ? {} : { callbackMode: "steer" }),
         };
     }
-    /** Proven by something other than the recipient's transcript. */
-    delivered(message) {
-        message.state = "delivered";
-        message.deliveredAt = Date.now();
-        message.error = null;
-        message.nextAttemptAt = null;
-        this.store.saveMessage(message);
-        this.changed(message);
-    }
-    abandon(message, why) {
-        message.state = "expired";
-        message.error = why;
-        message.answeredAt = Date.now();
-        message.nextAttemptAt = null;
-        this.store.saveMessage(message);
-        this.changed(message);
-        this.told(message, why);
-    }
-    /** Both ends are told, and an expired decision stops suppressing its run's
-     *  completion callback, which `execution.ts` decided once and never revisits. */
+    /** Both ends are told. */
     told(message, why) {
         this.unreachable(message.toSessionId, `a ${message.kind} from run ${message.runId}`, why);
         if (message.fromSessionId && message.fromSessionId !== message.toSessionId) {
             this.unreachable(message.fromSessionId, `your ${message.kind} on run ${message.runId}`, why);
         }
-        const run = this.store.getRun(message.runId);
-        if (message.kind !== "decision" || !run?.callbackSessionId)
-            return;
-        if (run.callbackState === null && isTerminal(run.state)) {
-            run.callbackState = "pending"; // the tick sweep delivers it
-            this.store.saveRun(run);
-        }
     }
     format(message, run) {
-        const title = run.context.definition.name;
-        if (message.kind === "progress") {
-            return `Subagent progress for task "${title}"\nRun: ${run.id}\nMessage: ${message.id}\n\n${message.content}`;
-        }
-        if (message.kind === "decision") {
-            return `Subagent needs a decision for task "${title}"\nRun: ${run.id}\nMessage: ${message.id}\nReply with the Task reply operation.\n\n${message.content}`;
-        }
-        if (message.kind === "reply") {
-            return `Supervisor reply for task "${title}"\nRun: ${run.id}\nReply to: ${message.replyTo ?? "-"}\n\n${message.content}`;
-        }
-        return `Task guidance for "${title}"\nRun: ${run.id}\nMessage: ${message.id}\n\n${message.content}`;
+        return `Task guidance for "${run.context.definition.name}"\nRun: ${run.id}\nMessage: ${message.id}\n\n${message.content}`;
     }
     origin(message, run) {
         return {