@tt-a1i/hive 1.3.0 → 1.4.0

package/dist/src/server/dispatch-ledger-store.d.ts

@@ -1,5 +1,5 @@
 import type { Database } from 'better-sqlite3';
-export type DispatchStatus = 'queued' | 'submitted' | 'reported';
+export type DispatchStatus = 'queued' | 'submitted' | 'reported' | 'cancelled';
 export interface DispatchRecord {
     artifacts: string[];
     createdAt: number;
@@ -28,6 +28,11 @@ interface ReportDispatchInput {
     toAgentId: string;
     workspaceId: string;
 }
+interface CancelDispatchInput {
+    dispatchId: string;
+    reason: string;
+    workspaceId: string;
+}
 export interface ListDispatchesOptions {
     limit?: number;
     offset?: number;
@@ -39,12 +44,28 @@ export declare const createDispatchLedgerStore: (db: Database) => {
     deleteWorkerDispatches: (workspaceId: string, workerId: string) => void;
     deleteWorkspaceDispatches: (workspaceId: string) => void;
     findOpenDispatch: (workspaceId: string, toAgentId: string, dispatchId?: string) => DispatchRecord | undefined;
+    findOpenDispatchById: (workspaceId: string, dispatchId: string) => DispatchRecord | undefined;
     listOpenDispatchKinds: () => Array<{
         type: "send";
         worker_id: string;
         workspace_id: string;
     }>;
     listWorkspaceDispatches: (workspaceId: string, options?: ListDispatchesOptions) => DispatchRecord[];
+    markCancelled: (input: CancelDispatchInput) => {
+        reportedAt: number;
+        reportText: string;
+        status: "cancelled";
+        artifacts: string[];
+        createdAt: number;
+        deliveredAt: number | null;
+        fromAgentId: string | null;
+        id: string;
+        sequence: number | null;
+        submittedAt: number | null;
+        text: string;
+        toAgentId: string;
+        workspaceId: string;
+    } | undefined;
     markReportedByWorker: (input: ReportDispatchInput) => {
         artifacts: string[];
         reportedAt: number;

package/dist/src/server/dispatch-ledger-store.js

@@ -77,7 +77,7 @@ export const createDispatchLedgerStore = (db) => {
            WHERE id = ?
              AND workspace_id = ?
              AND to_agent_id = ?
-             AND status != 'reported'
+             AND status IN ('queued', 'submitted')
            LIMIT 1`)
                 .get(dispatchId, workspaceId, toAgentId);
             return row ? toRecord(row) : undefined;
@@ -87,12 +87,23 @@ export const createDispatchLedgerStore = (db) => {
          FROM dispatches
          WHERE workspace_id = ?
            AND to_agent_id = ?
-           AND status != 'reported'
+           AND status IN ('queued', 'submitted')
          ORDER BY sequence ASC
          LIMIT 1`)
             .get(workspaceId, toAgentId);
         return row ? toRecord(row) : undefined;
     };
+    const findOpenDispatchById = (workspaceId, dispatchId) => {
+        const row = db
+            .prepare(`SELECT *
+         FROM dispatches
+         WHERE id = ?
+           AND workspace_id = ?
+           AND status IN ('queued', 'submitted')
+         LIMIT 1`)
+            .get(dispatchId, workspaceId);
+        return row ? toRecord(row) : undefined;
+    };
     const markReportedByWorker = (input) => {
         const dispatch = findOpenDispatch(input.workspaceId, input.toAgentId, input.dispatchId);
         if (!dispatch) {
@@ -113,6 +124,24 @@ export const createDispatchLedgerStore = (db) => {
             status: 'reported',
         };
     };
+    const markCancelled = (input) => {
+        const dispatch = findOpenDispatchById(input.workspaceId, input.dispatchId);
+        if (!dispatch) {
+            return undefined;
+        }
+        const cancelledAt = Date.now();
+        db.prepare(`UPDATE dispatches
+       SET status = ?,
+           reported_at = ?,
+           report_text = ?
+       WHERE id = ?`).run('cancelled', cancelledAt, input.reason, dispatch.id);
+        return {
+            ...dispatch,
+            reportedAt: cancelledAt,
+            reportText: input.reason,
+            status: 'cancelled',
+        };
+    };
     const listWorkspaceDispatches = (workspaceId, options = {}) => {
         const offset = options.offset ?? 0;
         const limit = options.limit ?? 100;
@@ -138,7 +167,7 @@ export const createDispatchLedgerStore = (db) => {
         return db
             .prepare(`SELECT workspace_id, to_agent_id AS worker_id, 'send' AS type
            FROM dispatches
-           WHERE status != 'reported'
+           WHERE status IN ('queued', 'submitted')
            ORDER BY sequence ASC`)
             .all();
     };
@@ -154,8 +183,10 @@ export const createDispatchLedgerStore = (db) => {
         deleteWorkerDispatches,
         deleteWorkspaceDispatches,
         findOpenDispatch,
+        findOpenDispatchById,
         listOpenDispatchKinds,
         listWorkspaceDispatches,
+        markCancelled,
         markReportedByWorker,
         markSubmitted,
     };

package/dist/src/server/hive-team-guidance.js

@@ -14,7 +14,7 @@
  * abstract identity restatement.
  */
 export const ORCHESTRATOR_REMINDER_TAIL = '<hive-system-reminder>\n' +
-    'You are the Hive Orchestrator. Reply by either: (a) `team send "<worker-name>" "<task>"` to dispatch follow-up work to a Hive worker, or (b) plain text to the user. Never call your CLI\'s built-in subagent tools (Task / Explore / etc.) — they bypass Hive and will not appear in the UI.\n' +
+    'You are the Hive Orchestrator. Reply by either: (a) `team send "<worker-name>" "<task>"` to dispatch follow-up work to a Hive worker, (b) `team cancel --dispatch <id> "<reason>"` to cancel an obsolete dispatch, or (c) plain text to the user. Never call your CLI\'s built-in subagent tools (Task / Explore / etc.) — they bypass Hive and will not appear in the UI.\n' +
     '</hive-system-reminder>';
 /**
  * Tail reminder appended to dispatches sent TO a worker. Reinforces the
@@ -31,6 +31,7 @@ const ORCHESTRATOR_RULES = [
     '普通、低风险、几分钟内能直接完成的小任务可以自己做；不要为了形式感派 worker。需要并行、长时间执行、独立 review/test、专门角色，或 user 明确要求 worker/成员处理时，再用 `team send`。',
     '如果只有一个可用 worker，直接用 `team send <worker-name> "<task>"` 派给它；不要把选择题丢回给 user。',
     '当 user 要你“让 worker ...”时，必须用 `team send <worker-name> "<task>"` 派给 Hive worker。',
+    '方向变更或 user 明确取消某个未完成派单时，使用 `team cancel --dispatch <id> "<reason>"` 显式关闭旧 dispatch；不要只用自然语言说“取消”。',
     '不要使用你所在 CLI 的内置 subagent / 子代理工具（如 Task / Explore 等）来代替 Hive worker；它们不会出现在 Hive UI，也不会更新 Hive 调度状态。',
     '`team list` 返回的 `last_pty_line` 是该 worker PTY 终端的最后一行原始输出（含任意 stdout / help / 控制序列噪声），**不是** worker 的正式汇报。正式汇报只来自 stdin 注入的 `[Hive 系统消息：来自 @<name> 的汇报]` 或 `[Hive 系统消息：来自 @<name> 的状态更新]`——只把这两种来源当作 reply。',
 ];
@@ -74,6 +75,7 @@ export const buildProtocolDoc = () => [
     '',
     '- `team list` — show workspace members and their status',
     '- `team send "<worker-name>" "<task>"` — dispatch to a worker by name (never id)',
+    '- `team cancel --dispatch <id> "<reason>"` — cancel an obsolete open dispatch',
     '',
     '## `team` CLI — worker',
     '',

package/dist/src/server/marketplace-store.d.ts

@@ -0,0 +1,38 @@
+export type MarketplaceLanguage = 'en' | 'zh';
+export interface MarketplaceAgentEntry {
+    path: string;
+    category: string;
+    name: string;
+    displayName?: string;
+    nameOverflows?: boolean;
+    description: string;
+    emoji: string | null;
+    color: string | null;
+    vibe: string | null;
+}
+export interface MarketplaceManifest {
+    source: {
+        repo: string;
+        commit: string;
+        fetched_at: string;
+    };
+    language: MarketplaceLanguage;
+    categories: string[];
+    agents: MarketplaceAgentEntry[];
+}
+export interface MarketplaceAgentDetail {
+    path: string;
+    frontmatter: Record<string, unknown>;
+    body: string;
+}
+export declare class MarketplaceNotFoundError extends Error {
+    constructor(message: string);
+}
+export declare const isMarketplaceLanguage: (value: unknown) => value is MarketplaceLanguage;
+/**
+ * Where on disk the bundled marketplace lives. Tests inject a fixture via
+ * `HIVE_MARKETPLACE_VENDOR_ROOT` (mirrors fs-sandbox's HIVE_FS_BROWSE_ROOT).
+ */
+export declare const getMarketplaceVendorRoot: () => string;
+export declare const loadManifest: (language: MarketplaceLanguage) => MarketplaceManifest;
+export declare const readAgent: (language: MarketplaceLanguage, relativePath: string) => MarketplaceAgentDetail;

package/dist/src/server/marketplace-store.js

@@ -0,0 +1,69 @@
+// Marketplace store — read-only access to the bundled `vendor/marketplace/`
+// snapshot of upstream agent prompt repos (one per UI language).
+//
+// **Vendor path invariant**: `new URL('../../vendor/marketplace', import.meta.url)`
+// resolves the same in dev and dist because `tsconfig.json` has `rootDir: "."`.
+//   - dev: this file is `src/server/marketplace-store.ts` → repo-root `vendor/`
+//   - dist: this file is `dist/src/server/marketplace-store.js` → `dist/vendor/`
+//
+// The build hook (`scripts/prepare-build-artifacts.mjs`) copies the source-of-
+// truth `vendor/marketplace/` into `dist/vendor/marketplace/` at pack time. If
+// either the `rootDir` setting or the build hook changes, that invariant must
+// be re-verified — there is no fallback path.
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import matter from 'gray-matter';
+import { isPathWithinRoot } from './fs-sandbox.js';
+export class MarketplaceNotFoundError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'MarketplaceNotFoundError';
+    }
+}
+const SUPPORTED_LANGUAGES = new Set(['en', 'zh']);
+export const isMarketplaceLanguage = (value) => typeof value === 'string' && SUPPORTED_LANGUAGES.has(value);
+const defaultVendorRoot = () => fileURLToPath(new URL('../../vendor/marketplace', import.meta.url));
+/**
+ * Where on disk the bundled marketplace lives. Tests inject a fixture via
+ * `HIVE_MARKETPLACE_VENDOR_ROOT` (mirrors fs-sandbox's HIVE_FS_BROWSE_ROOT).
+ */
+export const getMarketplaceVendorRoot = () => {
+    const override = process.env.HIVE_MARKETPLACE_VENDOR_ROOT;
+    return override && override.length > 0 ? resolve(override) : defaultVendorRoot();
+};
+const languageRoot = (language) => resolve(getMarketplaceVendorRoot(), language);
+export const loadManifest = (language) => {
+    const manifestPath = resolve(languageRoot(language), 'manifest.json');
+    if (!existsSync(manifestPath)) {
+        throw new MarketplaceNotFoundError(`Marketplace manifest missing for language: ${language}`);
+    }
+    const raw = readFileSync(manifestPath, 'utf8');
+    return JSON.parse(raw);
+};
+export const readAgent = (language, relativePath) => {
+    if (!relativePath.endsWith('.md')) {
+        throw new MarketplaceNotFoundError(`Marketplace agent path must end with .md: ${relativePath}`);
+    }
+    const root = languageRoot(language);
+    const candidate = resolve(root, relativePath);
+    if (!isPathWithinRoot(root, candidate)) {
+        throw new MarketplaceNotFoundError(`Marketplace agent path escapes language root: ${relativePath}`);
+    }
+    if (!existsSync(candidate)) {
+        throw new MarketplaceNotFoundError(`Marketplace agent not found: ${language}/${relativePath}`);
+    }
+    // Guard against upstream pushing a directory whose name ends in `.md` —
+    // the suffix check would pass, existsSync would pass, but readFileSync
+    // would throw EISDIR. Surface as a 404 instead of a 500.
+    if (!statSync(candidate).isFile()) {
+        throw new MarketplaceNotFoundError(`Marketplace agent not a file: ${language}/${relativePath}`);
+    }
+    const raw = readFileSync(candidate, 'utf8');
+    const parsed = matter(raw);
+    return {
+        path: relativePath,
+        frontmatter: parsed.data,
+        body: parsed.content,
+    };
+};

package/dist/src/server/route-types.d.ts

@@ -22,6 +22,13 @@ export interface ReportTaskBody {
     status?: string;
     artifacts?: unknown[];
 }
+export interface CancelTaskBody {
+    dispatch_id?: string;
+    project_id: string;
+    from_agent_id: string;
+    token?: string;
+    reason?: string;
+}
 export interface CreateWorkspaceBody {
     path: string;
     name: string;

package/dist/src/server/routes-dispatches.js

@@ -1,7 +1,7 @@
 import { serializeDispatchRecord } from './dispatch-ledger-serializer.js';
 import { getRequiredParam, route, sendJson } from './route-helpers.js';
 import { requireUiTokenFromRequest } from './ui-auth-helpers.js';
-const DISPATCH_STATUSES = new Set(['queued', 'submitted', 'reported']);
+const DISPATCH_STATUSES = new Set(['queued', 'submitted', 'reported', 'cancelled']);
 const MAX_DISPATCH_LIMIT = 100;
 const MAX_DISPATCH_OFFSET = 100_000;
 const readBoundedInt = (response, value, name, fallback, max) => {
@@ -33,7 +33,9 @@ export const dispatchRoutes = [
         }
         const state = url.searchParams.get('state');
         if (state !== null && !isDispatchStatus(state)) {
-            sendJson(response, 400, { error: 'state must be queued, submitted, or reported' });
+            sendJson(response, 400, {
+                error: 'state must be queued, submitted, reported, or cancelled',
+            });
             return;
         }
         const limit = readBoundedInt(response, url.searchParams.get('limit'), 'limit', MAX_DISPATCH_LIMIT, MAX_DISPATCH_LIMIT);

package/dist/src/server/routes-marketplace.d.ts

@@ -0,0 +1,2 @@
+import type { RouteDefinition } from './route-types.js';
+export declare const marketplaceRoutes: RouteDefinition[];

package/dist/src/server/routes-marketplace.js

@@ -0,0 +1,54 @@
+import { isMarketplaceLanguage, loadManifest, MarketplaceNotFoundError, readAgent, } from './marketplace-store.js';
+import { route, sendJson } from './route-helpers.js';
+import { requireUiTokenFromRequest } from './ui-auth-helpers.js';
+const readLanguageParam = (request) => {
+    const url = new URL(request.url ?? '/', 'http://127.0.0.1');
+    return url.searchParams.get('lang');
+};
+const readPathParam = (request) => {
+    const url = new URL(request.url ?? '/', 'http://127.0.0.1');
+    return url.searchParams.get('path') ?? '';
+};
+export const marketplaceRoutes = [
+    route('GET', '/api/marketplace/manifest', ({ request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken);
+        const lang = readLanguageParam(request);
+        if (!isMarketplaceLanguage(lang)) {
+            sendJson(response, 400, { error: 'Invalid or missing lang parameter (expected en|zh)' });
+            return;
+        }
+        try {
+            sendJson(response, 200, loadManifest(lang));
+        }
+        catch (error) {
+            if (error instanceof MarketplaceNotFoundError) {
+                sendJson(response, 404, { error: error.message });
+                return;
+            }
+            throw error;
+        }
+    }),
+    route('GET', '/api/marketplace/agent', ({ request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken);
+        const lang = readLanguageParam(request);
+        if (!isMarketplaceLanguage(lang)) {
+            sendJson(response, 400, { error: 'Invalid or missing lang parameter (expected en|zh)' });
+            return;
+        }
+        const relativePath = readPathParam(request);
+        if (!relativePath) {
+            sendJson(response, 400, { error: 'Missing path parameter' });
+            return;
+        }
+        try {
+            sendJson(response, 200, readAgent(lang, relativePath));
+        }
+        catch (error) {
+            if (error instanceof MarketplaceNotFoundError) {
+                sendJson(response, 404, { error: error.message });
+                return;
+            }
+            throw error;
+        }
+    }),
+];

package/dist/src/server/routes-runtime.js

@@ -25,6 +25,7 @@ export const runtimeRoutes = [
             agent_name: summary?.agent_name ?? 'Shell',
             run_id: run.runId,
             status: run.status,
+            terminal_input_profile: summary?.terminal_input_profile ?? 'default',
         });
     }),
     route('DELETE', '/api/workspaces/:workspaceId/shell/:runId', ({ params, request, response, store }) => {

package/dist/src/server/routes-team.js

@@ -29,6 +29,28 @@ export const teamRoutes = [
         });
         sendJson(response, 202, { dispatch_id: dispatch.id, ok: true });
     }),
+    route('POST', '/api/team/cancel', async ({ request, response, store }) => {
+        const body = await readJsonBody(request);
+        const projectId = requireNonEmptyString(body.project_id, 'project_id');
+        const fromAgentId = requireNonEmptyString(body.from_agent_id, 'from_agent_id');
+        const dispatchId = requireNonEmptyString(body.dispatch_id, 'dispatch_id');
+        const reason = requireNonEmptyString(body.reason, 'reason');
+        const agent = authenticateCliAgent({
+            fromAgentId,
+            getAgent: store.getAgent,
+            token: body.token,
+            validateToken: store.validateAgentToken,
+            workspaceId: projectId,
+        });
+        requireCommandForRole(agent, 'cancel');
+        const result = store.cancelTask(projectId, dispatchId, { fromAgentId, reason });
+        sendJson(response, 202, {
+            dispatch_id: result.dispatch?.id ?? null,
+            forward_error: result.forwardError,
+            forwarded: result.forwarded,
+            ok: true,
+        });
+    }),
     route('POST', '/api/team/report', async ({ request, response, store }) => {
         const body = await readJsonBody(request);
         const projectId = requireNonEmptyString(body.project_id, 'project_id');

package/dist/src/server/routes.js

@@ -1,6 +1,7 @@
 import { matchPath } from './route-helpers.js';
 import { dispatchRoutes } from './routes-dispatches.js';
 import { fsRoutes } from './routes-fs.js';
+import { marketplaceRoutes } from './routes-marketplace.js';
 import { openWorkspaceRoutes } from './routes-open-workspace.js';
 import { runtimeRoutes } from './routes-runtime.js';
 import { settingsRoutes } from './routes-settings.js';
@@ -20,6 +21,7 @@ const routes = [
     ...runtimeRoutes,
     ...teamRoutes,
     ...fsRoutes,
+    ...marketplaceRoutes,
 ];
 export const matchRoute = (method, pathname) => {
     for (const routeDefinition of routes) {

package/dist/src/server/runtime-store-helpers.d.ts

@@ -52,6 +52,7 @@ export declare const createRuntimeStoreLifecycle: ({ agentManager, services, }:
         agent_name: string;
         run_id: string;
         status: import("./agent-manager.js").RunStatus;
+        terminal_input_profile: import("./terminal-input-profile.js").TerminalInputProfile;
     }[];
     startAgent: (workspaceId: string, agentId: string, input: {
         hivePort: string;
@@ -74,7 +75,7 @@ export declare const createRuntimeStoreLifecycle: ({ agentManager, services, }:
     })[]>;
     registerTasksListener: (listener: (workspaceId: string, content: string) => void) => () => void;
     startWorkspaceWatch: (workspaceId: string) => Promise<void>;
-    writeRunInput: (runId: string, text: string) => void;
+    writeRunInput: (runId: string, input: Buffer | string) => void;
     pauseTerminalRun: (runId: string) => void;
     resizeTerminalRun: (runId: string, cols: number, rows: number) => void;
     resumeTerminalRun: (runId: string) => void;

package/dist/src/server/runtime-store-helpers.js

@@ -10,6 +10,7 @@ import { createSettingsStore } from './settings-store.js';
 import { createTasksFileService } from './tasks-file.js';
 import { createTasksFileWatcher } from './tasks-file-watcher.js';
 import { createTeamOperations } from './team-operations.js';
+import { resolveTerminalInputProfile } from './terminal-input-profile.js';
 import { createUiAuth } from './ui-auth.js';
 import { createWorkerOutputTracker } from './worker-output-tracker.js';
 import { createWorkspaceShellRuntime } from './workspace-shell-runtime.js';
@@ -63,7 +64,9 @@ export const createRuntimeStoreServices = (options = {}) => {
         deleteDispatch: dispatchLedgerStore.deleteDispatch,
         deleteMessage: messageLogStore.deleteMessage,
         findOpenDispatch: dispatchLedgerStore.findOpenDispatch,
+        findOpenDispatchById: dispatchLedgerStore.findOpenDispatchById,
         insertMessage: messageLogStore.insertMessage,
+        markDispatchCancelled: dispatchLedgerStore.markCancelled,
         markDispatchReportedByWorker: dispatchLedgerStore.markReportedByWorker,
         markDispatchSubmitted: dispatchLedgerStore.markSubmitted,
         workspaceStore,
@@ -167,8 +170,15 @@ export const createRuntimeStoreLifecycle = ({ agentManager, services, }) => {
                 const run = services.agentRuntime.getActiveRunByAgentId(workspaceId, agent.id);
                 if (!run)
                     return [];
+                const launchConfig = services.agentRuntime.peekAgentLaunchConfig(workspaceId, agent.id);
                 return [
-                    { agent_id: agent.id, agent_name: agent.name, run_id: run.runId, status: run.status },
+                    {
+                        agent_id: agent.id,
+                        agent_name: agent.name,
+                        run_id: run.runId,
+                        status: run.status,
+                        terminal_input_profile: resolveTerminalInputProfile(launchConfig),
+                    },
                 ];
             }),
             ...services.shellRuntime.listTerminalRuns(workspaceId),
@@ -186,14 +196,14 @@ export const createRuntimeStoreLifecycle = ({ agentManager, services, }) => {
             const workspace = services.workspaceStore.getWorkspaceSnapshot(workspaceId);
             await services.tasksFileWatcher.start(workspaceId, workspace.summary.path);
         },
-        writeRunInput: (runId, text) => {
+        writeRunInput: (runId, input) => {
             if (!agentManager)
                 throw new Error('Agent manager is required for PTY stdin writes');
             if (services.shellRuntime.hasRun(runId)) {
-                services.shellRuntime.writeInput(runId, text);
+                services.shellRuntime.writeInput(runId, input);
                 return;
             }
-            agentManager.writeInput(runId, text);
+            agentManager.writeInput(runId, input);
         },
         pauseTerminalRun: (runId) => {
             if (services.shellRuntime.hasRun(runId))

package/dist/src/server/runtime-store.d.ts

@@ -6,7 +6,8 @@ import type { DispatchRecord, ListDispatchesOptions } from './dispatch-ledger-st
 import type { RecoveryMessage } from './message-log-store.js';
 import type { PtyOutputBus } from './pty-output-bus.js';
 import type { SettingsStore } from './settings-store.js';
-import type { DispatchTaskInput, ReportTaskInput, ReportTaskResult, StatusTaskInput } from './team-operations.js';
+import type { CancelTaskInput, DispatchTaskInput, ReportTaskInput, ReportTaskResult, StatusTaskInput } from './team-operations.js';
+import type { TerminalRunSummary } from './terminal-input-profile.js';
 import type { WorkerInput, WorkspaceRecord } from './workspace-store.js';
 interface RuntimeStore {
     close: () => Promise<void>;
@@ -21,6 +22,7 @@ interface RuntimeStore {
     dispatchTaskByWorkerName: (workspaceId: string, workerName: string, text: string, input?: DispatchTaskInput) => Promise<DispatchRecord>;
     reportTask: (workspaceId: string, workerId: string, input?: ReportTaskInput) => ReportTaskResult;
     statusTask: (workspaceId: string, workerId: string, input?: StatusTaskInput) => ReportTaskResult;
+    cancelTask: (workspaceId: string, dispatchId: string, input: CancelTaskInput) => ReportTaskResult;
     listDispatches: (workspaceId: string, options?: ListDispatchesOptions) => DispatchRecord[];
     listWorkers: (workspaceId: string) => TeamListItem[];
     getLastPtyLineForAgent: (workspaceId: string, agentId: string) => string | null;
@@ -28,12 +30,7 @@ interface RuntimeStore {
     getWorker: (workspaceId: string, workerId: string) => AgentSummary;
     getAgent: (workspaceId: string, agentId: string) => AgentSummary;
     getPtyOutputBus: () => PtyOutputBus;
-    listTerminalRuns: (workspaceId: string) => Array<{
-        agent_id: string;
-        agent_name: string;
-        run_id: string;
-        status: string;
-    }>;
+    listTerminalRuns: (workspaceId: string) => TerminalRunSummary[];
     closeWorkspaceShell: (workspaceId: string, runId: string) => boolean;
     startWorkspaceShell: (workspaceId: string) => Promise<LiveAgentRun>;
     configureAgentLaunch: (workspaceId: string, agentId: string, input: AgentLaunchConfigInput) => void;
@@ -57,7 +54,7 @@ interface RuntimeStore {
     resizeAgentRun: (runId: string, cols: number, rows: number) => void;
     resumeTerminalRun: (runId: string) => void;
     settings: SettingsStore;
-    writeRunInput: (runId: string, text: string) => void;
+    writeRunInput: (runId: string, input: Buffer | string) => void;
     getUiToken: () => string;
     stopAgentRun: (runId: string) => void;
     validateAgentToken: (agentId: string, token: string | undefined) => boolean;

package/dist/src/server/runtime-store.js

@@ -48,6 +48,7 @@ export const createRuntimeStore = (options = {}) => {
             });
         },
         recordUserInput: services.teamOps.recordUserInput,
+        cancelTask: services.teamOps.cancelTask,
         dispatchTask: services.teamOps.dispatchTask,
         dispatchTaskByWorkerName: services.teamOps.dispatchTaskByWorkerName,
         reportTask: services.teamOps.reportTask,

package/dist/src/server/tasks-websocket-server.d.ts

@@ -1,7 +1,8 @@
 import type { Server } from 'node:http';
 import type { RuntimeStore } from './runtime-store.js';
+import type { TasksFileService } from './tasks-file.js';
 export interface TasksWebSocketServer {
     close: () => void;
     publish: (workspaceId: string, content: string) => void;
 }
-export declare const createTasksWebSocketServer: (server: Server, store: RuntimeStore) => TasksWebSocketServer;
+export declare const createTasksWebSocketServer: (server: Server, store: RuntimeStore, tasksFileService: Pick<TasksFileService, "readTasks">) => TasksWebSocketServer;

package/dist/src/server/tasks-websocket-server.js

@@ -10,7 +10,7 @@ const rejectUpgrade = (socket, status) => {
     socket.write(`HTTP/1.1 ${status}\r\n\r\n`);
     socket.destroy();
 };
-export const createTasksWebSocketServer = (server, store) => {
+export const createTasksWebSocketServer = (server, store, tasksFileService) => {
     const wss = new WebSocketServer({ noServer: true });
     const socketsByWorkspaceId = new Map();
     const validateUpgradeSession = (request) => {
@@ -33,8 +33,9 @@ export const createTasksWebSocketServer = (server, store) => {
             rejectUpgrade(socket, '401 Unauthorized');
             return;
         }
+        let workspacePath = '';
         try {
-            store.getWorkspaceSnapshot(workspaceId);
+            workspacePath = store.getWorkspaceSnapshot(workspaceId).summary.path;
         }
         catch {
             rejectUpgrade(socket, '404 Not Found');
@@ -50,6 +51,21 @@ export const createTasksWebSocketServer = (server, store) => {
                     socketsByWorkspaceId.delete(workspaceId);
                 }
             });
+            setImmediate(() => {
+                if (ws.readyState !== ws.OPEN)
+                    return;
+                try {
+                    ws.send(JSON.stringify({
+                        type: 'tasks-snapshot',
+                        content: tasksFileService.readTasks(workspacePath),
+                    }));
+                }
+                catch {
+                    if (ws.readyState === ws.OPEN) {
+                        ws.send(JSON.stringify({ type: 'tasks-snapshot', content: '' }));
+                    }
+                }
+            });
         });
     });
     return {

package/dist/src/server/team-authz.d.ts

@@ -1,5 +1,5 @@
 import type { AgentSummary } from '../shared/types.js';
-export type TeamCommand = 'send' | 'list' | 'report' | 'status' | 'help';
+export type TeamCommand = 'send' | 'list' | 'report' | 'status' | 'cancel' | 'help';
 export declare const commandAllowedForRole: (role: AgentSummary["role"], command: TeamCommand) => boolean;
 interface AuthenticateInput {
     fromAgentId: string | undefined;

package/dist/src/server/team-authz.js

@@ -1,5 +1,5 @@
 import { ForbiddenError, UnauthorizedError } from './http-errors.js';
-const ORCHESTRATOR_COMMANDS = new Set(['send', 'list', 'help']);
+const ORCHESTRATOR_COMMANDS = new Set(['send', 'list', 'cancel', 'help']);
 const WORKER_COMMANDS = new Set(['report', 'status', 'help']);
 const WORKER_ROLES = new Set(['coder', 'reviewer', 'tester', 'custom']);
 export const commandAllowedForRole = (role, command) => {

package/dist/src/server/team-operations.d.ts

@@ -13,7 +13,13 @@ export interface TeamOperationsInput {
     deleteDispatch: (dispatchId: string) => void;
     deleteMessage: (handle: MessageLogHandle) => void;
     findOpenDispatch: (workspaceId: string, toAgentId: string, dispatchId?: string) => DispatchRecord | undefined;
+    findOpenDispatchById: (workspaceId: string, dispatchId: string) => DispatchRecord | undefined;
     insertMessage: (record: MessageLogRecord) => MessageLogHandle;
+    markDispatchCancelled: (input: {
+        dispatchId: string;
+        reason: string;
+        workspaceId: string;
+    }) => DispatchRecord | undefined;
     markDispatchReportedByWorker: (input: {
         artifacts: string[];
         dispatchId?: string;
@@ -40,12 +46,21 @@ export interface StatusTaskInput {
     requireActiveRun?: boolean;
     text?: string;
 }
+export interface CancelTaskInput {
+    fromAgentId: string;
+    reason: string;
+}
 export interface ReportTaskResult {
     dispatch: DispatchRecord | null;
     forwardError: string | null;
     forwarded: boolean;
 }
-export declare const createTeamOperations: ({ agentRuntime, createDispatch, deleteDispatch, deleteMessage, findOpenDispatch, insertMessage, markDispatchReportedByWorker, markDispatchSubmitted, workspaceStore, }: TeamOperationsInput) => {
+export declare const createTeamOperations: ({ agentRuntime, createDispatch, deleteDispatch, deleteMessage, findOpenDispatch, findOpenDispatchById, insertMessage, markDispatchCancelled, markDispatchReportedByWorker, markDispatchSubmitted, workspaceStore, }: TeamOperationsInput) => {
+    cancelTask(workspaceId: string, dispatchId: string, input: CancelTaskInput): {
+        dispatch: DispatchRecord;
+        forwardError: string | null;
+        forwarded: boolean;
+    };
     dispatchTask: (workspaceId: string, workerId: string, text: string, input?: DispatchTaskInput) => Promise<DispatchRecord>;
     dispatchTaskByWorkerName(workspaceId: string, workerName: string, text: string, input?: DispatchTaskInput): Promise<DispatchRecord>;
     recordUserInput(workspaceId: string, orchestratorId: string, text: string): void;