dsh-plugin-t-expert 0.1.0

package/lib/teams/harness-compat.js

@@ -0,0 +1,179 @@
+import { SubagentError } from '@deepseek-ai/dsh-subagent';
+/**
+ * Exact protocol exported by dsh-subagent/internal in Alpha.5 and rc.1.
+ * That subpath does not exist in Alpha.2, so importing it statically prevents
+ * the plugin from loading there. This small adapter uses the same process-
+ * stable symbol and call signature as upstream queueHostSubagentPrompt.
+ * Source: packages/subagent/subagent/src/internal.ts at dsh-v0.1.2-rc.1.
+ */
+const hostPromptQueue = Symbol.for('dsh.subagent.queuePrompt');
+// 0.1.5 keeps queueHostSubagentPrompt but replaces its symbol with this
+// delivery-mode-aware implementation (packages/subagent/subagent/src/internal.ts).
+const hostPromptDeliver = Symbol.for('dsh.subagent.deliverPrompt');
+function boundary(runtime) {
+    return runtime;
+}
+function unsupported(detail) {
+    throw new Error(`t-team: unsupported Harness subagent contract (${detail}); use an explicitly tested Harness version and a coherent dependency installation`);
+}
+/** Read child-owned history, excluding any descriptor inherited from a parent. */
+export function sessionOwnEvents(session) {
+    const current = session;
+    if (typeof current.ownEvents === 'function')
+        return current.ownEvents.call(session);
+    const legacy = session;
+    if (!Array.isArray(legacy.events))
+        return unsupported('missing ownEvents/legacy session log');
+    return legacy.events.slice(legacy.header.seedLength ?? 0);
+}
+/** Install before the first request, including cold resume, with HMR cleanup. */
+export function installContinuableMemberSetup(ctx, setup) {
+    const runtime = boundary(ctx.subagents);
+    if (typeof runtime.registerContinuableSetup === 'function') {
+        // Upstream owns this registration with this.ctx.effect. Cordis resolves
+        // that ctx to the accessing plugin, so its disposal revokes installations
+        // even while the subagents service and child Agents remain live.
+        runtime.registerContinuableSetup.call(ctx.subagents, (childCtx) => {
+            if (childCtx.agent === undefined)
+                return unsupported('legacy setup lacks child Agent');
+            return setup(childCtx, childCtx.agent);
+        });
+        return;
+    }
+    if ((typeof runtime[hostPromptQueue] !== 'function' && typeof runtime[hostPromptDeliver] !== 'function') || typeof runtime.sendMessage !== 'function') {
+        return unsupported('missing continuable setup and modern host queue');
+    }
+    const installed = new WeakSet();
+    const active = new Set();
+    ctx.effect(() => {
+        const stop = ctx.on('agent/session-start', ({ agent }) => {
+            if (installed.has(agent))
+                return;
+            // Deliberately synchronous: awaiting here loses the first-request race.
+            let teardown;
+            try {
+                teardown = setup(agent.ctx, agent);
+            }
+            catch (error) {
+                // session-start is a notification: Harness logs a thrown listener and
+                // still admits the first prompt. Reject request assembly explicitly so
+                // a malformed saved route cannot silently execute on a default model.
+                const failure = new Error(`t-team: member initialization failed: ${String(error)}`, { cause: error });
+                ctx.logger.warn(failure.message);
+                teardown = agent.ctx.on('agent/request', () => { throw failure; });
+            }
+            installed.add(agent);
+            let disposed = false;
+            const dispose = () => {
+                if (disposed)
+                    return;
+                disposed = true;
+                active.delete(dispose);
+                installed.delete(agent);
+                teardown();
+            };
+            active.add(dispose);
+            // Listeners contributed to agent.ctx already follow its lifetime. Also
+            // release our bookkeeping and remove them if this plugin is reloaded.
+            try {
+                agent.ctx.effect(() => dispose, 't-team: child compatibility setup');
+            }
+            catch (error) {
+                dispose();
+                throw error;
+            }
+        });
+        return () => {
+            stop();
+            for (const dispose of [...active])
+                dispose();
+        };
+    }, 't-team: member lifecycle compatibility');
+}
+/** Queue a distinct host-authored turn; never substitute model-message steer. */
+export async function queueMemberPrompt(runtime, parent, childId, content, signal) {
+    const host = boundary(runtime);
+    const source = { kind: 'plugin', plugin: 't-team' };
+    if (typeof host.followup === 'function') {
+        return host.followup.call(runtime, parent, childId, content, { source, signal });
+    }
+    const deliver = host[hostPromptDeliver];
+    if (typeof deliver === 'function')
+        return deliver.call(runtime, parent, childId, content, source, signal, 'queue');
+    const queue = host[hostPromptQueue];
+    if (typeof queue !== 'function')
+        return unsupported('missing host FIFO delivery');
+    return queue.call(runtime, parent, childId, content, source, signal);
+}
+/** Guard all resumable delivery paths, preserving the native service receiver. */
+export function guardSubagentDelivery(ctx, isRetired) {
+    const runtime = ctx.subagents;
+    const host = boundary(runtime);
+    const legacy = host.followup;
+    const queue = host[hostPromptQueue];
+    const deliver = host[hostPromptDeliver];
+    const send = host.sendMessage;
+    if (typeof legacy !== 'function' && ((typeof queue !== 'function' && typeof deliver !== 'function') || typeof send !== 'function')) {
+        return unsupported('cannot install complete retired-member guard');
+    }
+    ctx.effect(() => {
+        const descriptors = new Map([
+            ['followup', Object.getOwnPropertyDescriptor(host, 'followup')],
+            [hostPromptQueue, Object.getOwnPropertyDescriptor(host, hostPromptQueue)],
+            [hostPromptDeliver, Object.getOwnPropertyDescriptor(host, hostPromptDeliver)],
+            ['sendMessage', Object.getOwnPropertyDescriptor(host, 'sendMessage')],
+        ]);
+        let active = true;
+        const check = async (sender, targetId) => {
+            if (active && await isRetired(sender, targetId)) {
+                throw new SubagentError(`T Team member "${targetId}" was retired and cannot be resumed`, 'NOT_RESUMABLE');
+            }
+        };
+        const guardedLegacy = async (parent, childId, content, options) => {
+            await check(parent, childId);
+            return legacy.call(runtime, parent, childId, content, options);
+        };
+        const guardedQueue = async (parent, childId, content, source, signal) => {
+            await check(parent, childId);
+            return queue.call(runtime, parent, childId, content, source, signal);
+        };
+        const guardedSend = async (sender, targetId, content, options) => {
+            await check(sender, targetId);
+            return send.call(runtime, sender, targetId, content, options);
+        };
+        const guardedDeliver = async (parent, childId, content, source, signal, delivery) => {
+            await check(parent, childId);
+            return deliver.call(runtime, parent, childId, content, source, signal, delivery);
+        };
+        if (typeof legacy === 'function')
+            host.followup = guardedLegacy;
+        if (typeof queue === 'function')
+            host[hostPromptQueue] = guardedQueue;
+        if (typeof deliver === 'function')
+            host[hostPromptDeliver] = guardedDeliver;
+        if (typeof send === 'function')
+            host.sendMessage = guardedSend;
+        // Cordis wraps method reads in fresh Proxies. Compare the actual own
+        // descriptor to restore only our contribution, including prototype methods.
+        const restore = (key, installed) => {
+            if (Object.getOwnPropertyDescriptor(host, key)?.value !== installed)
+                return;
+            const original = descriptors.get(key);
+            if (original === undefined)
+                Reflect.deleteProperty(host, key);
+            else
+                Object.defineProperty(host, key, original);
+        };
+        return () => {
+            active = false;
+            if (typeof legacy === 'function')
+                restore('followup', guardedLegacy);
+            if (typeof queue === 'function')
+                restore(hostPromptQueue, guardedQueue);
+            if (typeof deliver === 'function')
+                restore(hostPromptDeliver, guardedDeliver);
+            if (typeof send === 'function')
+                restore('sendMessage', guardedSend);
+        };
+    }, 't-team: retired member guard');
+}

package/lib/teams/index.js

@@ -0,0 +1,441 @@
+/**
+ * T Team for DeepSeek Harness.
+ *
+ * A host-plane plugin that registers the `t_team_*` tools and one usage
+ * agent-scoped usage section. Each session keeps a stable tool set and core
+ * instructions. Existing business tools cover the complete team lifecycle.
+ * After installation any session can
+ * run multi-agent teamwork through natural language (e.g. "use T Team to research X"):
+ * the model creates a team (it becomes the captain), spawns members as
+ * durable continuable subagents, breaks the goal into tasks with
+ * dependencies, wakes members with messages, relays reports, and collects
+ * results.
+ *
+ * Installation (bundle): `dsh plugin --profile <name> add dsh-plugin-t-expert`
+ * (or a local path). The bundle patch mounts this plugin row into the host
+ * composition; the tools register into the shared `tools` registry and the
+ * usage section into the global system prompt, so the plugin needs no realm.
+ *
+ * @module t-team
+ */
+import z from '@deepseek-ai/schemastery';
+import { createUserMessage } from '@deepseek-ai/dsh-llm';
+import { haltTeamWork, stagedPlanApprovedContext, registerTTeamTools, } from "./tools.js";
+import { installTTeamGestureBoundary, registerTTeamCommand } from "./command.js";
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { collectArchivedTeamsActivity, collectTeamsActivity } from "./snapshot.js";
+import { findTeamByCaptain } from "./state.js";
+import { formatProfilesForPrompt } from "./profiles.js";
+import { installTeamCapabilities } from "./capabilities.js";
+import { TEAM_TOOL_NAMES } from "./tool-names.js";
+import { authenticatedWebRoutes, readJsonRequest, RequestBodyError } from "./web-routes.js";
+/** Web-server service key candidates, newest first. */
+const WEB_SERVER_KEYS = ['webServer', 'httpServer'];
+/** Workspace registry service key candidates, newest first. */
+const WORKSPACE_KEYS = ['workspaceRegistry', 'workspace'];
+export const name = 't-team';
+export const inject = ['tools', 'llm', 'subagents', 'systemPrompt', 'agents'];
+// `z.object()` has an implicit `{}` default in Schemastery.  Fallback routes
+// are optional, so model absence explicitly; otherwise a missing route is
+// validated as an empty object and fails on the required provider/model keys.
+const fallbackRouteConfig = z.union([
+    z.object({ provider: z.string().required(), model: z.string().required() }),
+    z.const(undefined),
+]);
+export const Config = z.object({
+    stateDir: z.string().default('.t-team'),
+    memberProvider: z.string().default('spawn'),
+    memberModel: z.string(),
+    executionPrompt: z.string(),
+    fallback: fallbackRouteConfig,
+    profiles: z.dict(z.object({
+        description: z.string(),
+        protocol: z.string(),
+        executionPrompt: z.string(),
+        fallback: fallbackRouteConfig,
+        members: z.array(z.object({
+            name: z.string().required(),
+            role: z.string(),
+            provider: z.string(),
+            model: z.string(),
+            reasoning_effort: z.string(),
+            executionPrompt: z.string(),
+            fallback: fallbackRouteConfig,
+        })).min(1).required(),
+        taskPlanning: z.union([z.const('captain'), z.const('seed')]),
+        reviewPolicy: z.object({
+            requirementsMinRounds: z.natural().min(1),
+            requirementsMaxRounds: z.natural().min(1),
+            codeMaxRounds: z.natural().min(1),
+            maxRepairAttempts: z.natural().min(1),
+            requiredReviewers: z.array(z.string()),
+        }),
+        tasks: z.array(z.object({
+            id: z.string().required(),
+            subject: z.string().required(),
+            description: z.string(),
+            assignee: z.string(),
+            dependencies: z.array(z.string()),
+        })),
+    })).default({}),
+    memberMaxDepth: z.natural().default(1),
+    maxMembers: z.natural().min(1).default(8),
+    promptSectionOrder: z.natural().default(117),
+    slashCommand: z.boolean().default(true),
+});
+/** The model-facing usage policy: when and how to drive T Team. */
+export function usageSectionText(toolNames, profilesText = '') {
+    return `T Team captain protocol:
+1. Inspect current team state when needed, using t_team_status. Continue existing work without duplicating its roster/tasks. Create only when no current team exists, with the user's goal as description and approval="required"; automatic approval requires an explicit request to run immediately. Staged plans never spawn or schedule work.
+2. Add each needed role once; members inherit your model route unless another is requested/needed. A requested profile goes to create({profile}); it supplies its roster. Seed profiles also supply tasks; captain-planning profiles require your DAG. Do not duplicate either.
+3. Build the complete smallest useful DAG while staged. Every task needs a subject; dependencies represent prerequisites. Give every required contributor a task or explicit message. Present the plan and end your turn for review; never approve in that planning turn. Approve only after a later explicit user approval or the Web action.
+4. Respect Web approve/return/discard control messages. On return, ask what to change before editing; after the answer, use one atomic t_team_edit_plan batch (edit downstream references before removals), summarize and await review again. Never inspect or edit .t-team state files or plugin source code to revise plans. Discard does not authorize a replacement.
+5. The scheduler dispatches ready tasks after approval. Delegate; do not duplicate slow work or send messages merely to start a stage. Handle reports/user work, then yield when waiting is all that remains: reports wake you automatically. Use status after a delivery or user request, never busy-poll or wait for unassigned members.
+6. Tasks carry attempt_id capabilities. Use the current attempt_id; stale means ownership changed. Pause members only on explicit request; later guidance via send_message continues that same attempt. Retry, transfer or take over through reassign_task first; it revokes the old attempt and waits for quiescence. Prefer a member. Captain implementation/review takeover requires a user request. Every takeover is one ready task at a time, finished in this turn; never yield with captain-owned work open.
+7. Quality kinds (requirements, implementation, verification, review, repair, integration) require objective + acceptance; implementation/repair also require inScope + verify. Derive paths/commands from the workspace/profile, never assume src/ or pnpm test. Review/requirements complete only with verdict=pass; needs_revision/reject fail with findings. Never approve your own implementation or ask for a deliberate failure.
+8. When full quality mode is requested: requirements → implementation → verification → review → integration. Plan the entire DAG while staged, including implementation before requirements finishes and integration depending on review round 1. Failed review automatically adds repair + next review and rewires pending downstream gates. Do not recreate this loop, omit integration or depend on a failed task. Review acceptance judges the latest implementation. Do not put smoke-test scripts into task instructions.
+9. Halted means the user stopped work (including the captain turn). Resume only on a later explicit user request with a reason, via t_team_resume or create_task({resume:true,resumeReason}); creating tasks alone never resumes. Escalated means the review loop hit its limit, not a halt. Deployment requires explicit user confirmation.
+10. Wait for all required tasks to be terminal and members idle/ready, present results, then delete/archive unless the user wants to continue. Never discard unfinished work without authorization.
+Tools: ${toolNames}${profilesText === '' ? '' : `\n\n${profilesText}`}`;
+}
+export function apply(ctx, config) {
+    const resolved = {
+        stateDir: config.stateDir ?? '.t-team',
+        memberProvider: config.memberProvider ?? 'spawn',
+        memberModel: config.memberModel,
+        executionPrompt: config.executionPrompt,
+        fallback: config.fallback,
+        memberMaxDepth: config.memberMaxDepth ?? 1,
+        maxMembers: config.maxMembers ?? 8,
+        profiles: config.profiles ?? {},
+    };
+    // Provider registration is a sibling plugin's effect (`subagent-spawn` /
+    // `subagent-fork` rows), which can land after this mount under the Loader's
+    // concurrent activation — so capability validation happens at the first
+    // member spawn (`spawnMember`), the earliest point the provider list is
+    // settled, rather than here.
+    const tTeamRuntime = registerTTeamTools(ctx, resolved);
+    installTeamCapabilities(ctx, {
+        stateDir: resolved.stateDir,
+        isPendingMember: tTeamRuntime.isPendingMember,
+        order: config.promptSectionOrder,
+        // Keep the bounded profile directory available without extra tool calls.
+        // installTeamCapabilities snapshots this once; no business state rewrites it.
+        captainPrompt: () => usageSectionText(TEAM_TOOL_NAMES.join(', '), formatProfilesForPrompt(config.profiles)),
+    });
+    // Deterministic activation surfaces: the closed-namespace `/t-team`
+    // host command (surfaces in the Web GUI slash menu via the Harness
+    // ui-commands client) and the plain-text gesture boundary for surfaces
+    // without command adjudication (headless CLI). Both default on; a profile
+    // can disable them to keep the natural-language trigger exclusive.
+    //
+    // `commands` is registered lazily (not a required inject): it ships in the
+    // base bundle of every standard profile, but a minimal composition that
+    // omits the command registry keeps the plugin fully functional — the fiber
+    // never pends on it and simply never gains the slash command.
+    if (config.slashCommand ?? true) {
+        ctx.inject(['commands'], (commandCtx) => {
+            registerTTeamCommand(commandCtx, () => config.profiles ?? {});
+        });
+        installTTeamGestureBoundary(ctx, () => config.profiles ?? {});
+    }
+    // The activity panel data/artwork routes need the Web server and the
+    // workspace registry, which headless profiles do not mount; under
+    // concurrent activation they may also bind after this plugin. Register the
+    // routes lazily: try now, then on each service binding event. In a webless
+    // profile the plugin stays tool-only and never blocks boot.
+    let webRegistered = false;
+    const registerWebSurface = () => {
+        if (webRegistered)
+            return;
+        const rawWebServer = (ctx.get(WEB_SERVER_KEYS[0]) ?? ctx.get(WEB_SERVER_KEYS[1]));
+        const workspaceRegistry = (ctx.get(WORKSPACE_KEYS[0]) ?? ctx.get(WORKSPACE_KEYS[1]));
+        if (rawWebServer === undefined || workspaceRegistry === undefined)
+            return;
+        const webServer = authenticatedWebRoutes(rawWebServer, () => ctx.get('connection'));
+        webRegistered = true;
+        // Activity panel data route: the browser floater polls this for team
+        // snapshots (disk truth + live subagent activity). Mirrors the Claude
+        // Code desktop watcher's server-side snapshot pattern.
+        ctx.effect(() => webServer.register({
+            kind: 'exact',
+            path: '/plugins/t-team/state',
+            handler: async (req, res) => {
+                const url = new URL(req.url ?? '/', 'http://x');
+                const roots = workspaceRegistry.list().map((workspace) => ({
+                    workspace: workspace.title,
+                    stateRoot: join(workspace.path, resolved.stateDir),
+                }));
+                // ?archived=1 serves teams moved to archive/ (post-delete review).
+                const snapshots = url.searchParams.get('archived') === '1'
+                    ? await collectArchivedTeamsActivity(ctx, roots)
+                    : await collectTeamsActivity(ctx, roots);
+                const body = JSON.stringify({ teams: snapshots });
+                res.writeHead(200, {
+                    'content-type': 'application/json; charset=utf-8',
+                    'cache-control': 'no-store',
+                });
+                res.end(body);
+            },
+        }), 't-team: activity route');
+        ctx.effect(() => webServer.register({
+            kind: 'exact',
+            path: '/plugins/t-team/halt',
+            handler: async (req, res) => {
+                if (req.method !== 'POST') {
+                    res.writeHead(405, { allow: 'POST', 'cache-control': 'no-store' });
+                    res.end();
+                    return;
+                }
+                let payload;
+                try {
+                    payload = await readJsonRequest(req);
+                }
+                catch (error) {
+                    res.writeHead(error instanceof RequestBodyError ? error.status : 400, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' });
+                    res.end(JSON.stringify({ error: error instanceof Error ? error.message : 'invalid request body' }));
+                    return;
+                }
+                const sessionId = typeof payload.sessionId === 'string' ? payload.sessionId.trim() : '';
+                const teamId = typeof payload.teamId === 'string' ? payload.teamId.trim() : '';
+                if (sessionId === '' || teamId === '') {
+                    res.writeHead(400, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' });
+                    res.end(JSON.stringify({ error: 'sessionId and teamId are required' }));
+                    return;
+                }
+                const captain = ctx.agents.get(sessionId);
+                if (captain === undefined) {
+                    res.writeHead(409, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' });
+                    res.end(JSON.stringify({ error: 'captain session is not attached' }));
+                    return;
+                }
+                const workspace = captain.session.header.cwd ?? process.cwd();
+                const stateRoot = join(workspace, resolved.stateDir);
+                const team = await findTeamByCaptain(stateRoot, captain.id);
+                if (team === undefined || team.id !== teamId) {
+                    res.writeHead(404, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' });
+                    res.end(JSON.stringify({ error: 'team not found for this captain' }));
+                    return;
+                }
+                try {
+                    const result = await haltTeamWork({
+                        ctx,
+                        stateRoot,
+                        teamId,
+                        captain,
+                    });
+                    res.writeHead(200, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' });
+                    res.end(JSON.stringify(result));
+                }
+                catch (error) {
+                    ctx.logger.warn(`t-team: halt failed for ${teamId}: ${String(error)}`);
+                    res.writeHead(500, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' });
+                    res.end(JSON.stringify({ error: 'failed to stop the team' }));
+                }
+            },
+        }), 't-team: halt route');
+        ctx.effect(() => webServer.register({
+            kind: 'exact',
+            path: '/plugins/t-team/plan',
+            handler: async (req, res) => {
+                if (req.method !== 'POST') {
+                    res.writeHead(405, { allow: 'POST', 'cache-control': 'no-store' });
+                    res.end();
+                    return;
+                }
+                let payload;
+                try {
+                    payload = await readJsonRequest(req);
+                }
+                catch (error) {
+                    res.writeHead(error instanceof RequestBodyError ? error.status : 400, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' });
+                    res.end(JSON.stringify({ error: error instanceof Error ? error.message : 'invalid request body' }));
+                    return;
+                }
+                const sessionId = typeof payload['sessionId'] === 'string' ? payload['sessionId'].trim() : '';
+                const teamId = typeof payload['teamId'] === 'string' ? payload['teamId'].trim() : '';
+                const action = typeof payload['action'] === 'string' ? payload['action'] : '';
+                if (sessionId === '' || teamId === '' || action === '') {
+                    res.writeHead(400, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' });
+                    res.end(JSON.stringify({ error: 'sessionId, teamId, and action are required' }));
+                    return;
+                }
+                const captain = ctx.agents.get(sessionId);
+                if (captain === undefined) {
+                    res.writeHead(409, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' });
+                    res.end(JSON.stringify({ error: 'captain session is not attached' }));
+                    return;
+                }
+                const workspace = captain.session.header.cwd ?? process.cwd();
+                const stateRoot = join(workspace, resolved.stateDir);
+                const team = await findTeamByCaptain(stateRoot, captain.id);
+                if (team === undefined || team.id !== teamId) {
+                    res.writeHead(404, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' });
+                    res.end(JSON.stringify({ error: 'team not found for this captain' }));
+                    return;
+                }
+                try {
+                    if (action === 'approve') {
+                        const approved = await tTeamRuntime.approveStagedTeam(captain, teamId);
+                        // The browser receives the HTTP result, so the model needs its own
+                        // control message. steer wakes an idle captain or joins its next
+                        // step; the tool approve path already returns to the model itself.
+                        try {
+                            captain.steer(createUserMessage({
+                                content: [{ type: 'text', text: stagedPlanApprovedContext(team.name) }],
+                                source: { kind: 'plugin', plugin: 't-team' },
+                            }));
+                        }
+                        catch (error) {
+                            // Approval is already committed. Do not report a failed approval
+                            // and invite a retry that could duplicate the user's action.
+                            ctx.logger.warn(`t-team: approval notification failed for ${teamId}: ${String(error)}`);
+                        }
+                        res.writeHead(200, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' });
+                        res.end(JSON.stringify({ ok: true, phase: 'running', ...approved }));
+                        return;
+                    }
+                    if (action === 'continue') {
+                        const continued = await tTeamRuntime.continueStagedPlanning(captain, teamId);
+                        res.writeHead(200, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' });
+                        res.end(JSON.stringify({ ok: true, phase: 'staged', review: 'awaiting_feedback', ...continued }));
+                        return;
+                    }
+                    if (action === 'discard') {
+                        const discarded = await tTeamRuntime.discardStagedTeam(captain, teamId);
+                        res.writeHead(200, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' });
+                        res.end(JSON.stringify({ ok: true, phase: 'archived', ...discarded }));
+                        return;
+                    }
+                    const dependencies = Array.isArray(payload['dependencies'])
+                        ? payload['dependencies'].filter((item) => typeof item === 'string')
+                        : [];
+                    let mutation;
+                    if (action === 'update_member') {
+                        if (typeof payload['memberName'] !== 'string'
+                            || typeof payload['provider'] !== 'string'
+                            || typeof payload['model'] !== 'string')
+                            throw new Error('memberName, provider, and model are required');
+                        mutation = {
+                            action,
+                            memberName: payload['memberName'],
+                            provider: payload['provider'],
+                            model: payload['model'],
+                            ...typeof payload['role'] === 'string' || payload['role'] === null ? { role: payload['role'] } : {},
+                            ...typeof payload['reasoningEffort'] === 'string' || payload['reasoningEffort'] === null
+                                ? { reasoningEffort: payload['reasoningEffort'] }
+                                : {},
+                            ...typeof payload['executionPrompt'] === 'string' || payload['executionPrompt'] === null
+                                ? { executionPrompt: payload['executionPrompt'] }
+                                : {},
+                        };
+                    }
+                    else if (action === 'update_task') {
+                        if (typeof payload['taskId'] !== 'string' || typeof payload['subject'] !== 'string') {
+                            throw new Error('taskId and subject are required');
+                        }
+                        mutation = {
+                            action,
+                            taskId: payload['taskId'],
+                            subject: payload['subject'],
+                            dependencies,
+                            ...typeof payload['description'] === 'string' || payload['description'] === null
+                                ? { description: payload['description'] }
+                                : {},
+                            ...typeof payload['assignee'] === 'string' || payload['assignee'] === null
+                                ? { assignee: payload['assignee'] }
+                                : {},
+                        };
+                    }
+                    else if (action === 'add_task') {
+                        if (typeof payload['subject'] !== 'string')
+                            throw new Error('subject is required');
+                        mutation = {
+                            action,
+                            subject: payload['subject'],
+                            dependencies,
+                            ...typeof payload['description'] === 'string' || payload['description'] === null
+                                ? { description: payload['description'] }
+                                : {},
+                            ...typeof payload['assignee'] === 'string' || payload['assignee'] === null
+                                ? { assignee: payload['assignee'] }
+                                : {},
+                        };
+                    }
+                    else if (action === 'remove_task') {
+                        if (typeof payload['taskId'] !== 'string')
+                            throw new Error('taskId is required');
+                        mutation = { action, taskId: payload['taskId'] };
+                    }
+                    else {
+                        throw new Error(`unknown plan action "${action}"`);
+                    }
+                    const updated = await tTeamRuntime.updateStagedPlan(captain, teamId, mutation);
+                    res.writeHead(200, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' });
+                    res.end(JSON.stringify({ ok: true, phase: updated.phase, members: updated.members.length, tasks: updated.tasks.length }));
+                }
+                catch (error) {
+                    res.writeHead(409, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' });
+                    res.end(JSON.stringify({ error: error instanceof Error ? error.message : 'plan operation failed' }));
+                }
+            },
+        }), 't-team: plan route');
+        // Whale mascot artwork: serve the packaged V2 role/action images to the
+        // activity panel. An explicit allowlist guards the route (no path
+        // traversal); the images ship with the bundle (files: assets/).
+        const artDir = fileURLToPath(new URL('../assets/t-team/', import.meta.url));
+        const ART_ALLOWLIST = new Set([
+            'team-lead-v2.png',
+            'member-researcher-v2.png', 'member-engineer-v2.png',
+            'member-qa-v2.png', 'member-designer-v2.png',
+            'member-security-v2.png', 'member-docs-v2.png',
+            'member-data-v2.png', 'member-operator-v2.png',
+            'action-working-v2.png', 'action-thinking-v2.png',
+            'action-reporting-v2.png', 'action-celebrating-v2.png',
+            'action-sleeping-v2.png', 'action-sending-v2.png',
+        ]);
+        ctx.effect(() => webServer.register({
+            kind: 'prefix',
+            path: '/plugins/t-team/assets',
+            handler: async (req, res) => {
+                let name;
+                try {
+                    name = decodeURIComponent(new URL(req.url ?? '/', 'http://x').pathname.split('/').pop() ?? '');
+                }
+                catch {
+                    // Malformed percent-encoding: treat as an unknown asset, not a 400.
+                    res.writeHead(404);
+                    res.end();
+                    return;
+                }
+                if (!ART_ALLOWLIST.has(name)) {
+                    res.writeHead(404);
+                    res.end();
+                    return;
+                }
+                try {
+                    const data = await readFile(join(artDir, name));
+                    res.writeHead(200, {
+                        'content-type': 'image/png',
+                        'cache-control': 'public, max-age=86400',
+                    });
+                    res.end(data);
+                }
+                catch (error) {
+                    ctx.logger.warn(`t-team: artwork read failed for ${name}: ${String(error)}`);
+                    res.writeHead(404);
+                    res.end();
+                }
+            },
+        }), 't-team: artwork route');
+    };
+    registerWebSurface();
+    ctx.on('internal/service', (name) => {
+        if (WEB_SERVER_KEYS.includes(name)
+            || WORKSPACE_KEYS.includes(name)) {
+            registerWebSurface();
+        }
+    });
+}