opencode-superagent 0.1.0 → 0.2.1

package/dist/src/version.js

@@ -0,0 +1,76 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+/**
+ * Plugin version, read from the package's own `package.json`.
+ *
+ * The version is the only thing this module exposes: it is deliberately not a
+ * diagnostics dump, so logging it can never leak config, tokens, absolute
+ * paths or session ids.
+ */
+/** Shown when no candidate `package.json` can be read or parsed. */
+export const UNKNOWN_VERSION = "0.0.0-unknown";
+/**
+ * `package.json` locations relative to this module, most specific first:
+ * - source (dev / tests): `src/version.ts` → `../package.json`
+ * - build output: `dist/src/version.js` → `../../package.json`
+ *
+ * Both are tried so the same code works in the repo and in a packed tarball.
+ */
+const CANDIDATES = ["../package.json", "../../package.json"];
+/** Extract `version` from raw `package.json` text; `undefined` when unusable. */
+export function versionFromPackageJson(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+    if (typeof parsed !== "object" || parsed === null)
+        return undefined;
+    const value = parsed.version;
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed === "" ? undefined : trimmed;
+}
+function readRelative(file) {
+    try {
+        return readFileSync(path.resolve(import.meta.dir, file), "utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Read the first usable candidate, falling back to {@link UNKNOWN_VERSION}.
+ *
+ * `read` is injectable so the fallback path is testable without touching the
+ * filesystem: pass `() => undefined` for a missing package, or a stub that
+ * returns unparsable JSON.
+ */
+export function loadVersion(read = readRelative) {
+    for (const candidate of CANDIDATES) {
+        const raw = read(candidate);
+        if (raw === undefined)
+            continue;
+        const version = versionFromPackageJson(raw);
+        if (version !== undefined)
+            return version;
+    }
+    return UNKNOWN_VERSION;
+}
+let cached;
+/** Cached plugin version; the process never changes version at runtime. */
+export function pluginVersion() {
+    cached ??= loadVersion();
+    return cached;
+}
+/**
+ * One-line startup notice. Says what is loaded and that upgrading an already
+ * running gateway is not enough — the plugin has no hot reload, so a service
+ * restart is required before the new code is active.
+ */
+export function versionNotice() {
+    return `superagent ${pluginVersion()} loaded; restart the OpenCode gateway after upgrading (no hot reload)`;
+}

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,8 +1,9 @@
 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";
+import { closeOutcomeForWorkerState } from "./ticket-state.js";
 /**
  * Capture one finished report: the complete text goes to `report:<sessionID>`
  * first, then the worker record keeps a short summary for status lines and the
@@ -15,30 +16,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 +43,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);
@@ -87,11 +76,12 @@ const handleEnded = Effect.fn("superagent.workerEnded")(function* (ctx, sessionI
     // A worker that reached a terminal state closes its in-progress ticket.
     // Interruptions (`idle`) leave it open: the abort tool closes it explicitly
     // and a plain interrupt may still be resumed with a follow-up.
-    if (state === "done" || state === "failed") {
+    const closeOutcome = closeOutcomeForWorkerState(state);
+    if (closeOutcome !== undefined) {
         yield* closeTicketsForWorker(ctx, {
             sessionID,
-            outcome: state,
-            summary: worker.lastReport ?? report ?? detail ?? `${state} (worker ${sessionID})`,
+            outcome: closeOutcome,
+            summary: worker.lastReport ?? report ?? detail ?? `${closeOutcome} (worker ${sessionID})`,
         }).pipe(Effect.catch((cause) => Effect.logWarning("superagent failed to close ticket for ended worker", { sessionID, cause })));
     }
     // Keep the thread subscriptions after the worker ends: follow-ups on the
@@ -167,11 +157,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/src/worker-state.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Worker records and the in-memory worker registry they live in.
+ *
+ * This module is intentionally dependency-free: `state.ts` owns KV persistence
+ * and the rest of the store, while the ticket layer only needs to look up a
+ * worker's state when it gates a dispatch. Keeping the record type and the
+ * registry map here lets `ticket.ts` avoid importing `state.ts`, which is what
+ * breaks the state ↔ ticket import cycle. `store.workers` in `state.ts` is the
+ * same map instance, so both layers always see one registry.
+ */
+export type WorkerState = "running" | "idle" | "failed" | "done" | "aborted";
+export declare const WORKER_STATES: ReadonlyArray<WorkerState>;
+export interface WorkerRecord {
+    readonly sessionID: string;
+    readonly title?: string;
+    /**
+     * Primary thread this worker was dispatched for. Legacy records decode to
+     * `""` and `hydrate` backfills it from `thread.workers`, so every live record
+     * carries a forward link to its thread without losing the multi-thread
+     * `threads` list.
+     */
+    threadID: string;
+    /** Trigger that authorized the dispatch, when the record knows it. */
+    triggerID?: string;
+    readonly threads: Array<string>;
+    state: WorkerState;
+    readonly createdAt: number;
+    /** Last persisted write. Refreshed by `saveWorker`, so an aborted record keeps a traceable timestamp. */
+    updatedAt?: number;
+    lastReport?: string;
+    directory?: string;
+}
+/** Canonical in-memory worker registry; `store.workers` points at this map. */
+export declare const workers: Map<string, WorkerRecord>;
+/**
+ * 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 declare const TERMINAL_WORKER_STATES: ReadonlyArray<WorkerState>;
+export declare function isWorkerTerminal(state: WorkerState): boolean;

package/dist/src/worker-state.js

@@ -0,0 +1,22 @@
+/**
+ * Worker records and the in-memory worker registry they live in.
+ *
+ * This module is intentionally dependency-free: `state.ts` owns KV persistence
+ * and the rest of the store, while the ticket layer only needs to look up a
+ * worker's state when it gates a dispatch. Keeping the record type and the
+ * registry map here lets `ticket.ts` avoid importing `state.ts`, which is what
+ * breaks the state ↔ ticket import cycle. `store.workers` in `state.ts` is the
+ * same map instance, so both layers always see one registry.
+ */
+export const WORKER_STATES = ["running", "idle", "failed", "done", "aborted"];
+/** Canonical in-memory worker registry; `store.workers` points at this map. */
+export const workers = new Map();
+/**
+ * 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);
+}

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",
@@ -211,11 +151,14 @@ var ROUTER_TOOL_SPECS = [
     name: "status",
     group: "query",
     description: "Show a compact summary of the router, pending triggers and worker sessions.",
-    summary: "\u67E5\u770B Router\u3001pending \u89E6\u53D1\u5668\u6570\u91CF\u4E0E\u5168\u90E8 Worker \u7684 thread/\u72B6\u6001/\u6700\u8FD1\u62A5\u544A\u3002",
+    summary: "\u67E5\u770B\u63D2\u4EF6\u7248\u672C\u3001Router\u3001pending \u89E6\u53D1\u5668\u6570\u91CF\u4E0E\u5168\u90E8 Worker \u7684 thread/\u72B6\u6001/\u6700\u8FD1\u62A5\u544A\u3002",
     params: [],
     risk: "read",
     confirmation: "\u53EA\u8BFB\uFF0C\u81EA\u52A8\u6267\u884C\uFF08permission: status\uFF09\u3002",
-    usage: ["system \u72B6\u6001\u884C\u53EA\u7ED9\u8BA1\u6570\uFF0C\u7EC6\u8282\u7528 status / thread_detail\u3002"]
+    usage: [
+      "\u9996\u884C\u662F\u63D2\u4EF6\u7248\u672C\u4E0E\u300C\u5347\u7EA7\u540E\u9700\u91CD\u542F\u7F51\u5173\u300D\u63D0\u793A\uFF0C\u7528\u6765\u5224\u65AD\u7F51\u5173\u662F\u5426\u8FD8\u5728\u8DD1\u65E7\u4EE3\u7801\u3002",
+      "system \u72B6\u6001\u884C\u53EA\u7ED9\u8BA1\u6570\uFF0C\u7EC6\u8282\u7528 status / thread_detail\u3002"
+    ]
   },
   {
     name: "thread_detail",
@@ -422,6 +365,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 +468,89 @@ 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({
+        version: Schema.optionalKey(Schema.String),
+        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 })),
+      errors: { "stop.rejected": Schema.toStandardSchemaV1(Schema.Struct({})) }
+    },
+    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.1",
   "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": {
@@ -42,6 +43,7 @@
     "prepare": "bun run build",
     "prepack": "bun run build",
     "test": "bun test",
+    "test:e2e": "bun run e2e/plugin-load.e2e.ts",
     "typecheck": "bun check --no-script",
     "typecheck:tsc": "tsc --noEmit"
   },