opencode-superagent 0.1.0 → 0.2.0

package/dist/src/ticket.js

@@ -125,7 +125,10 @@ export function getTicket(ticketID) {
 /** Same-thread, same-dedupe-key ticket still open or in progress, if any. */
 export function findDuplicate(threadID, dedupeKey) {
     const ids = byThread.get(threadID);
-    const candidates = ids === undefined ? [...tickets.values()] : [...ids].flatMap((id) => tickets.get(id) ?? []);
+    // No ids means this thread owns no in-memory ticket, so there is nothing to reuse.
+    if (ids === undefined)
+        return undefined;
+    const candidates = [...ids].flatMap((id) => tickets.get(id) ?? []);
     return candidates.find((ticket) => ticket.dedupeKey === dedupeKey && ACTIVE_STATES.includes(ticket.state));
 }
 export function isActive(ticket) {
@@ -161,6 +164,15 @@ export function activeTicketSummary(threadID, limit = 3) {
 export function activeTicketForWorker(sessionID) {
     return [...tickets.values()].find((ticket) => ticket.workerSessionID === sessionID && ticket.state === "in_progress");
 }
+/**
+ * Worker states after which the ticket may be dispatched again. `idle` is not
+ * here on purpose: an idle session can still be resumed, so a re-dispatch
+ * would race a live worker.
+ */
+export const TERMINAL_WORKER_STATES = ["done", "failed", "aborted"];
+export function isWorkerTerminal(state) {
+    return TERMINAL_WORKER_STATES.includes(state);
+}
 // ── validation ────────────────────────────────────────────────────────────────
 export function validateCreateInput(input) {
     if ((input.threadID ?? "").trim() === "")
@@ -525,7 +537,7 @@ export function listTickets(input = {}) {
  * Gate every dispatch must pass: a dispatch always names a ticket, and that
  * ticket must be workable right now. The rules are enforced here (not in the
  * prompt) so a Router cannot dispatch without a ticket, onto a closed ticket,
- * across threads, or onto a ticket that already has a running worker.
+ * across threads, or onto a ticket that already has a live (non-terminal) worker.
  */
 export const requireDispatchTicket = Effect.fn("superagent.requireDispatchTicket")(function* (ticketID, threadID) {
     if (ticketID === undefined || ticketID.trim() === "") {
@@ -551,11 +563,16 @@ export const requireDispatchTicket = Effect.fn("superagent.requireDispatchTicket
         });
     }
     // One ticket never runs two workers at once: the previous worker must be
-    // terminal (aborted, failed, done) before anything is dispatched again.
+    // terminal (done, failed, aborted) before anything is dispatched again.
+    // `idle` is NOT terminal — the session may still be resumed — so it blocks
+    // a re-dispatch exactly like `running`. A worker record that is gone blocks
+    // nothing: there is no live worker left to wait for.
     const workerID = ticket.workerSessionID;
-    if (workerID !== undefined && store.workers.get(workerID)?.state === "running") {
+    const worker = workerID === undefined ? undefined : store.workers.get(workerID);
+    if (workerID !== undefined && worker !== undefined && !isWorkerTerminal(worker.state)) {
+        const article = worker.state === "idle" ? "an" : "a";
         return yield* new Tool.Error({
-            message: `ticket ${ticket.id} already has a running worker ${workerID}; wait for it or abort_session it first, then ticket_create a new ticket for the re-dispatch`,
+            message: `ticket ${ticket.id} already has ${article} ${worker.state} worker ${workerID}; wait for it to finish, abort_session it, or ticket_create a new ticket for the re-dispatch`,
         });
     }
     return ticket;

package/dist/src/tools.js

@@ -49,6 +49,22 @@ export const ROUTER_TOOL_SPECS = [
             "派发成功即绑定工单：workerSessionID 写入、attempts+1、state → in_progress；Worker 结束自动结单。",
         ],
     },
+    {
+        name: "sleep",
+        group: "control",
+        description: 'Pause the router for a bounded number of seconds (default 30, range 1..600) with a real timer, never a busy loop, and return "slept Ns". In Goal mode, call it after dispatch to pause and give the Worker execution time before you check in again. Only the router may call it; tracked worker sessions neither see nor may call it.',
+        summary: "暂停指定秒数（默认 30，范围 1..600），给 Worker 预留执行时间。",
+        params: [{ name: "seconds", required: false, type: "number", note: "默认 30，1..600 的整数" }],
+        risk: "read",
+        permission: "status",
+        confirmation: "只读等待，自动执行（permission: status）；非法秒数直接报错。",
+        usage: [
+            "Goal 模式：dispatch 后先 sleep，再回来汇总，不要空转轮询 Worker。",
+            "seconds 缺省 30；必须是 1..600 的整数，0/负数/超界/非数字都报错。",
+            "真实定时器（Effect.sleep）：等待期间 Router 与其他任务照常推进。",
+            "仅 Router 可见：Worker 会话的工具列表里没有它，直调也会被拒绝。",
+        ],
+    },
     {
         name: "ticket_create",
         group: "dispatch",

package/dist/src/watchdog.d.ts

@@ -4,13 +4,20 @@ import { Effect } from "effect";
 export declare const WATCHDOG_INTERVAL_MS = 60000;
 /** Default stall threshold. Overridable with the `stallTimeoutMs` plugin option. */
 export declare const STALL_TIMEOUT_MS: number;
-/** Prefix marking a worker already reported as stalled. Guards duplicate watchdog alerts. */
+/**
+ * Older records may still carry the watchdog marker in `lastReport`; keep
+ * honouring it so a restart cannot re-alert the same legacy stall.
+ */
 export declare const STALLED_PREFIX = "watchdog: stalled";
+/** Test/hydrate hook: forget every in-memory stall alert. */
+export declare function resetWatchdogAlerts(): void;
+export declare const checkWorker: (ctx: Plugin.Context, sessionID: string, now: number, stallTimeoutMs: number) => Effect.Effect<void, never, never>;
 /**
  * Periodic stall detector. Every interval it flags `running` workers whose
  * session has been busy longer than the stall timeout without an `idle`
- * update, reports them to the router, and marks them `failed`. It never
- * interrupts: stalled workers stay alive until someone stops or re-dispatches
- * them. All errors are swallowed with a warning so the loop never dies.
+ * update, and reports them to the router. It is alert-only: the worker record
+ * keeps its `running` state, its ticket stays open and the worker is never
+ * interrupted, so the Router stays in control. Alerts are deduped per busy
+ * window. All errors are swallowed with a warning so the loop never dies.
  */
 export declare const registerWatchdog: (ctx: Plugin.Context) => Effect.Effect<void, never, import("effect/Scope").Scope>;

package/dist/src/watchdog.js

@@ -1,24 +1,37 @@
 import { DateTime, Effect, Option, Stream } from "effect";
 import { ensureRouter } from "./router.js";
-import { saveWorker, store, toSessionID } from "./state.js";
-import { closeTicketsForWorker } from "./ticket.js";
+import { store, toSessionID } from "./state.js";
 /** Default interval between stall checks. Overridable with the `watchdogIntervalMs` plugin option. */
 export const WATCHDOG_INTERVAL_MS = 60_000;
 /** Default stall threshold. Overridable with the `stallTimeoutMs` plugin option. */
 export const STALL_TIMEOUT_MS = 30 * 60_000;
-/** Prefix marking a worker already reported as stalled. Guards duplicate watchdog alerts. */
+/**
+ * Older records may still carry the watchdog marker in `lastReport`; keep
+ * honouring it so a restart cannot re-alert the same legacy stall.
+ */
 export const STALLED_PREFIX = "watchdog: stalled";
+/**
+ * Sessions already reported for their current busy window. Alert-only mode
+ * never mutates the worker record, so dedupe lives in memory. Keying by
+ * `time.busy` lets a resumed worker alert once more if it stalls again.
+ */
+const alerted = new Map();
+/** Test/hydrate hook: forget every in-memory stall alert. */
+export function resetWatchdogAlerts() {
+    alerted.clear();
+}
 function optionMs(ctx, key, fallback) {
     const raw = ctx.options[key];
     if (typeof raw !== "number" || !Number.isFinite(raw) || raw <= 0)
         return fallback;
     return raw;
 }
-const checkWorker = Effect.fn("superagent.watchdogCheck")(function* (ctx, sessionID, now, stallTimeoutMs) {
+export const checkWorker = Effect.fn("superagent.watchdogCheck")(function* (ctx, sessionID, now, stallTimeoutMs) {
     const worker = store.workers.get(sessionID);
-    if (worker === undefined || worker.state !== "running")
+    if (worker === undefined || worker.state !== "running") {
+        alerted.delete(sessionID);
         return;
-    // Already alerted: only the running→failed transition reports once.
+    }
     if (worker.lastReport !== undefined && worker.lastReport.startsWith(STALLED_PREFIX))
         return;
     const info = yield* ctx.session.get({ sessionID: toSessionID(sessionID) }).pipe(Effect.option);
@@ -27,13 +40,20 @@ const checkWorker = Effect.fn("superagent.watchdogCheck")(function* (ctx, sessio
         return;
     }
     const busy = info.value.time.busy;
-    if (busy === undefined)
+    if (busy === undefined) {
+        alerted.delete(sessionID);
         return;
+    }
     const busyMs = DateTime.toEpochMillis(busy);
     const idle = info.value.time.idle;
     // While a session runs, `idle` still holds the previous execution's end.
     // Only an `idle` newer than `busy` proves progress since this execution started.
-    if (idle !== undefined && DateTime.toEpochMillis(idle) > busyMs)
+    if (idle !== undefined && DateTime.toEpochMillis(idle) > busyMs) {
+        alerted.delete(sessionID);
+        return;
+    }
+    // One alert per busy window: duplicate checks must not spam the Router.
+    if (alerted.get(sessionID) === busyMs)
         return;
     const stalledMs = now - busyMs;
     if (stalledMs <= stallTimeoutMs)
@@ -47,15 +67,11 @@ const checkWorker = Effect.fn("superagent.watchdogCheck")(function* (ctx, sessio
             .synthetic({ sessionID: toSessionID(routerID), text, description: "superagent watchdog", delivery: "queue" })
             .pipe(Effect.catch((cause) => Effect.logWarning("superagent watchdog failed to report to router", { cause })));
     }
-    // Alert only: never interrupt automatically, so long tasks are not killed by mistake.
-    worker.state = "failed";
-    worker.lastReport = `${STALLED_PREFIX} ${minutes}m${worker.lastReport === undefined ? "" : ` | ${worker.lastReport}`}`;
-    yield* saveWorker(ctx, worker);
-    yield* closeTicketsForWorker(ctx, {
-        sessionID,
-        outcome: "failed",
-        summary: `watchdog: stalled ${minutes}m`,
-    }).pipe(Effect.catch((cause) => Effect.logWarning("superagent watchdog failed to close ticket", { sessionID, cause })));
+    alerted.set(sessionID, busyMs);
+    // Alert only: never change worker.state, never close its ticket and never
+    // interrupt automatically, so a long task is not killed by mistake. The
+    // Router decides whether to stop/re-dispatch.
+    yield* Effect.logWarning("superagent watchdog: worker stalled", { sessionID, minutes });
 });
 const checkAll = Effect.fn("superagent.watchdogCheckAll")(function* (ctx, stallTimeoutMs) {
     const now = Date.now();
@@ -66,9 +82,10 @@ const checkAll = Effect.fn("superagent.watchdogCheckAll")(function* (ctx, stallT
 /**
  * Periodic stall detector. Every interval it flags `running` workers whose
  * session has been busy longer than the stall timeout without an `idle`
- * update, reports them to the router, and marks them `failed`. It never
- * interrupts: stalled workers stay alive until someone stops or re-dispatches
- * them. All errors are swallowed with a warning so the loop never dies.
+ * update, and reports them to the router. It is alert-only: the worker record
+ * keeps its `running` state, its ticket stays open and the worker is never
+ * interrupted, so the Router stays in control. Alerts are deduped per busy
+ * window. All errors are swallowed with a warning so the loop never dies.
  */
 export const registerWatchdog = Effect.fn("superagent.registerWatchdog")(function* (ctx) {
     const intervalMs = optionMs(ctx, "watchdogIntervalMs", WATCHDOG_INTERVAL_MS);

package/dist/src/watcher.d.ts

@@ -8,4 +8,10 @@ import { type WorkerRecord } from "./state.js";
  * between the two writes can only lose the summary, never the evidence.
  */
 export declare const captureReport: (ctx: Plugin.Context, worker: WorkerRecord, text: string) => Effect.Effect<import("./report.js").ReportRecord, never, never>;
+/**
+ * Apply a `session.idle` notification. Only a running worker may become idle:
+ * `done`, `failed` and `aborted` are terminal for the lifecycle, and an idle
+ * event must never resurrect or overwrite them.
+ */
+export declare const handleIdle: (ctx: Plugin.Context, sessionID: string) => Effect.Effect<void, never, never>;
 export declare const registerWatcher: (ctx: Plugin.Context) => Effect.Effect<void, never, import("effect/Scope").Scope>;

package/dist/src/watcher.js

@@ -1,5 +1,5 @@
 import { Effect, Stream } from "effect";
-import { buildReport, reportNotice, reportSummary, saveReport } from "./report.js";
+import { buildReport, lastAssistantText, reportNotice, reportSummary, saveReport } from "./report.js";
 import { ensureRouter } from "./router.js";
 import { saveWorker, store, toSessionID } from "./state.js";
 import { closeTicketsForWorker } from "./ticket.js";
@@ -15,30 +15,6 @@ export const captureReport = Effect.fn("superagent.captureReport")(function* (ct
     worker.lastReport = reportSummary(record);
     return record;
 });
-function lastAssistantText(messages) {
-    for (let index = messages.length - 1; index >= 0; index--) {
-        const message = messages[index];
-        if (typeof message !== "object" || message === null)
-            continue;
-        const typed = message;
-        if (typed.type !== "assistant")
-            continue;
-        if (!Array.isArray(typed.content))
-            continue;
-        const text = typed.content
-            .flatMap((part) => {
-            if (typeof part !== "object" || part === null)
-                return [];
-            const candidate = part;
-            return candidate.type === "text" && typeof candidate.text === "string" ? [candidate.text] : [];
-        })
-            .join("\n")
-            .trim();
-        if (text !== "")
-            return text;
-    }
-    return undefined;
-}
 function errorDetail(data) {
     if (typeof data !== "object" || data === null)
         return undefined;
@@ -66,6 +42,18 @@ function interruptDetail(data) {
     const reason = data.reason;
     return typeof reason === "string" && reason !== "" ? `interrupted (${reason})` : "interrupted";
 }
+/**
+ * Apply a `session.idle` notification. Only a running worker may become idle:
+ * `done`, `failed` and `aborted` are terminal for the lifecycle, and an idle
+ * event must never resurrect or overwrite them.
+ */
+export const handleIdle = Effect.fn("superagent.workerIdle")(function* (ctx, sessionID) {
+    const worker = store.workers.get(sessionID);
+    if (worker === undefined || worker.state !== "running")
+        return;
+    worker.state = "idle";
+    yield* saveWorker(ctx, worker);
+});
 const handleEnded = Effect.fn("superagent.workerEnded")(function* (ctx, sessionID, state, detail) {
     const sessions = ctx.session;
     const worker = store.workers.get(sessionID);
@@ -167,11 +155,7 @@ export const registerWatcher = Effect.fn("superagent.registerWatcher")(function*
                 return;
             }
             case "session.idle": {
-                const worker = store.workers.get(sessionID);
-                if (worker === undefined || worker.state === "idle" || worker.state === "aborted")
-                    return;
-                worker.state = "idle";
-                yield* saveWorker(ctx, worker);
+                yield* handleIdle(ctx, sessionID);
                 return;
             }
             default:

package/dist/tui.js

@@ -14,82 +14,6 @@ import { createMemo, createSignal, For, onCleanup, onMount, Show } from "solid-j
 // src/protocol.ts
 import { Rpc } from "@opencode/plugin/effect";
 import { Schema } from "effect";
-var Definition = Rpc.define({
-  id: "opencode.superagent",
-  methods: {
-    router: {
-      input: Schema.toStandardSchemaV1(Schema.Struct({})),
-      output: Schema.toStandardSchemaV1(Schema.Struct({ sessionID: Schema.String }))
-    },
-    status: {
-      input: Schema.toStandardSchemaV1(Schema.Struct({})),
-      output: Schema.toStandardSchemaV1(Schema.Struct({
-        router: Schema.optionalKey(Schema.String),
-        pending: Schema.Number,
-        workers: Schema.Array(Schema.Struct({
-          sessionID: Schema.String,
-          title: Schema.optionalKey(Schema.String),
-          threads: Schema.Array(Schema.String),
-          state: Schema.Literals(["running", "idle", "failed", "done", "aborted"])
-        }))
-      }))
-    },
-    tickets: {
-      input: Schema.toStandardSchemaV1(Schema.Struct({
-        threadID: Schema.optionalKey(Schema.String),
-        status: Schema.optionalKey(Schema.String),
-        limit: Schema.optionalKey(Schema.Number)
-      })),
-      output: Schema.toStandardSchemaV1(Schema.Struct({ text: Schema.String }))
-    },
-    ticket: {
-      input: Schema.toStandardSchemaV1(Schema.Struct({ ticketID: Schema.String })),
-      output: Schema.toStandardSchemaV1(Schema.Struct({ text: Schema.String }))
-    },
-    dispatch: {
-      input: Schema.toStandardSchemaV1(Schema.Struct({
-        task: Schema.String,
-        title: Schema.optionalKey(Schema.String),
-        threadID: Schema.optionalKey(Schema.String),
-        agent: Schema.optionalKey(Schema.String),
-        directory: Schema.optionalKey(Schema.String),
-        ticketID: Schema.String
-      })),
-      output: Schema.toStandardSchemaV1(Schema.Struct({ sessionID: Schema.String })),
-      errors: { "dispatch.rejected": Schema.toStandardSchemaV1(Schema.Struct({})) }
-    },
-    trigger: {
-      input: Schema.toStandardSchemaV1(Schema.Struct({
-        id: Schema.optionalKey(Schema.String),
-        source: Schema.String,
-        threadID: Schema.String,
-        author: Schema.optionalKey(Schema.String),
-        text: Schema.String,
-        title: Schema.optionalKey(Schema.String),
-        createdAt: Schema.optionalKey(Schema.Number)
-      })),
-      output: Schema.toStandardSchemaV1(Schema.Struct({
-        route: Schema.Literals(["router", "worker", "dropped"]),
-        sessionID: Schema.optionalKey(Schema.String)
-      }))
-    },
-    stop: {
-      input: Schema.toStandardSchemaV1(Schema.Struct({ sessionID: Schema.String })),
-      output: Schema.toStandardSchemaV1(Schema.Struct({ interrupted: Schema.Boolean }))
-    },
-    abort: {
-      input: Schema.toStandardSchemaV1(Schema.Struct({
-        sessionID: Schema.optionalKey(Schema.String),
-        reason: Schema.optionalKey(Schema.String),
-        all: Schema.optionalKey(Schema.Boolean),
-        stale: Schema.optionalKey(Schema.Boolean)
-      })),
-      output: Schema.toStandardSchemaV1(Schema.Struct({ text: Schema.String })),
-      errors: { "abort.rejected": Schema.toStandardSchemaV1(Schema.Struct({})) }
-    }
-  },
-  events: {}
-});
 
 // src/tools.ts
 var GROUP_LABELS = {
@@ -126,6 +50,22 @@ var ROUTER_TOOL_SPECS = [
       "\u6D3E\u53D1\u6210\u529F\u5373\u7ED1\u5B9A\u5DE5\u5355\uFF1AworkerSessionID \u5199\u5165\u3001attempts+1\u3001state \u2192 in_progress\uFF1BWorker \u7ED3\u675F\u81EA\u52A8\u7ED3\u5355\u3002"
     ]
   },
+  {
+    name: "sleep",
+    group: "control",
+    description: 'Pause the router for a bounded number of seconds (default 30, range 1..600) with a real timer, never a busy loop, and return "slept Ns". In Goal mode, call it after dispatch to pause and give the Worker execution time before you check in again. Only the router may call it; tracked worker sessions neither see nor may call it.',
+    summary: "\u6682\u505C\u6307\u5B9A\u79D2\u6570\uFF08\u9ED8\u8BA4 30\uFF0C\u8303\u56F4 1..600\uFF09\uFF0C\u7ED9 Worker \u9884\u7559\u6267\u884C\u65F6\u95F4\u3002",
+    params: [{ name: "seconds", required: false, type: "number", note: "\u9ED8\u8BA4 30\uFF0C1..600 \u7684\u6574\u6570" }],
+    risk: "read",
+    permission: "status",
+    confirmation: "\u53EA\u8BFB\u7B49\u5F85\uFF0C\u81EA\u52A8\u6267\u884C\uFF08permission: status\uFF09\uFF1B\u975E\u6CD5\u79D2\u6570\u76F4\u63A5\u62A5\u9519\u3002",
+    usage: [
+      "Goal \u6A21\u5F0F\uFF1Adispatch \u540E\u5148 sleep\uFF0C\u518D\u56DE\u6765\u6C47\u603B\uFF0C\u4E0D\u8981\u7A7A\u8F6C\u8F6E\u8BE2 Worker\u3002",
+      "seconds \u7F3A\u7701 30\uFF1B\u5FC5\u987B\u662F 1..600 \u7684\u6574\u6570\uFF0C0/\u8D1F\u6570/\u8D85\u754C/\u975E\u6570\u5B57\u90FD\u62A5\u9519\u3002",
+      "\u771F\u5B9E\u5B9A\u65F6\u5668\uFF08Effect.sleep\uFF09\uFF1A\u7B49\u5F85\u671F\u95F4 Router \u4E0E\u5176\u4ED6\u4EFB\u52A1\u7167\u5E38\u63A8\u8FDB\u3002",
+      "\u4EC5 Router \u53EF\u89C1\uFF1AWorker \u4F1A\u8BDD\u7684\u5DE5\u5177\u5217\u8868\u91CC\u6CA1\u6709\u5B83\uFF0C\u76F4\u8C03\u4E5F\u4F1A\u88AB\u62D2\u7EDD\u3002"
+    ]
+  },
   {
     name: "ticket_create",
     group: "dispatch",
@@ -422,6 +362,15 @@ function describeLimits(width = DETAIL_WIDTH) {
 }
 
 // src/ticket-view.ts
+var TICKET_STATES = [
+  "open",
+  "in_progress",
+  "blocked",
+  "done",
+  "failed",
+  "cancelled",
+  "superseded"
+];
 var TICKET_PANEL_WIDTH = 36;
 var TICKET_TITLE_MAX = 26;
 var TICKET_TERMINAL_LIMIT = 3;
@@ -516,6 +465,87 @@ function ticketPanel(rows, width = TICKET_PANEL_WIDTH, terminalLimit = TICKET_TE
   };
 }
 
+// src/protocol.ts
+var Definition = Rpc.define({
+  id: "opencode.superagent",
+  methods: {
+    router: {
+      input: Schema.toStandardSchemaV1(Schema.Struct({})),
+      output: Schema.toStandardSchemaV1(Schema.Struct({ sessionID: Schema.String }))
+    },
+    status: {
+      input: Schema.toStandardSchemaV1(Schema.Struct({})),
+      output: Schema.toStandardSchemaV1(Schema.Struct({
+        router: Schema.optionalKey(Schema.String),
+        pending: Schema.Number,
+        workers: Schema.Array(Schema.Struct({
+          sessionID: Schema.String,
+          title: Schema.optionalKey(Schema.String),
+          threads: Schema.Array(Schema.String),
+          state: Schema.Literals(["running", "idle", "failed", "done", "aborted"])
+        }))
+      }))
+    },
+    tickets: {
+      input: Schema.toStandardSchemaV1(Schema.Struct({
+        threadID: Schema.optionalKey(Schema.String),
+        status: Schema.optionalKey(Schema.Literals(TICKET_STATES)),
+        limit: Schema.optionalKey(Schema.Number)
+      })),
+      output: Schema.toStandardSchemaV1(Schema.Struct({ text: Schema.String })),
+      errors: {
+        "tickets.invalid_status": Schema.toStandardSchemaV1(Schema.Struct({ status: Schema.String }))
+      }
+    },
+    ticket: {
+      input: Schema.toStandardSchemaV1(Schema.Struct({ ticketID: Schema.String })),
+      output: Schema.toStandardSchemaV1(Schema.Struct({ text: Schema.String }))
+    },
+    dispatch: {
+      input: Schema.toStandardSchemaV1(Schema.Struct({
+        task: Schema.String,
+        title: Schema.optionalKey(Schema.String),
+        threadID: Schema.optionalKey(Schema.String),
+        agent: Schema.optionalKey(Schema.String),
+        directory: Schema.optionalKey(Schema.String),
+        ticketID: Schema.String
+      })),
+      output: Schema.toStandardSchemaV1(Schema.Struct({ sessionID: Schema.String })),
+      errors: { "dispatch.rejected": Schema.toStandardSchemaV1(Schema.Struct({})) }
+    },
+    trigger: {
+      input: Schema.toStandardSchemaV1(Schema.Struct({
+        id: Schema.optionalKey(Schema.String),
+        source: Schema.String,
+        threadID: Schema.String,
+        author: Schema.optionalKey(Schema.String),
+        text: Schema.String,
+        title: Schema.optionalKey(Schema.String),
+        createdAt: Schema.optionalKey(Schema.Number)
+      })),
+      output: Schema.toStandardSchemaV1(Schema.Struct({
+        route: Schema.Literals(["router", "worker", "dropped"]),
+        sessionID: Schema.optionalKey(Schema.String)
+      }))
+    },
+    stop: {
+      input: Schema.toStandardSchemaV1(Schema.Struct({ sessionID: Schema.String })),
+      output: Schema.toStandardSchemaV1(Schema.Struct({ interrupted: Schema.Boolean }))
+    },
+    abort: {
+      input: Schema.toStandardSchemaV1(Schema.Struct({
+        sessionID: Schema.optionalKey(Schema.String),
+        reason: Schema.optionalKey(Schema.String),
+        all: Schema.optionalKey(Schema.Boolean),
+        stale: Schema.optionalKey(Schema.Boolean)
+      })),
+      output: Schema.toStandardSchemaV1(Schema.Struct({ text: Schema.String })),
+      errors: { "abort.rejected": Schema.toStandardSchemaV1(Schema.Struct({})) }
+    }
+  },
+  events: {}
+});
+
 // tui.tsx
 var events = [{
   thread: "T-1",

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "opencode-superagent",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Superagent: a resident router agent that dispatches background worker agents in OpenCode",
   "type": "module",
   "license": "MIT",
@@ -15,6 +15,7 @@
     "url": "https://github.com/xtccc/opencode-superagent/issues"
   },
   "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
     "access": "public"
   },
   "exports": {