@tt-a1i/hive 2.1.14 → 2.1.15

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 All notable user-facing changes will be documented in this file.
 
+## 2.1.15 - 2026-07-02
+
+Worker avatars, terminal rendering reliability, and clearer team report delivery.
+
+- Adds custom worker avatars, including upload, crop, validation, persistence,
+  and display across the team UI.
+- Keeps worker avatars out of CLI team-list responses while still showing them
+  in the browser workspace.
+- Improves terminal rendering under heavy output and reconnect/restore flows,
+  reducing stale or duplicated terminal frames.
+- Tightens Dream memory consolidation instructions so procedure references are
+  only used for real saved workflows, skills, procedures, templates, or docs.
+- Makes `team report` delivery wording more accurate when Hive accepts a report
+  and durable Orchestrator delivery is still in progress.
+- Adjusts Orchestrator guidance so accepted dispatches are usually left alone
+  until a member reports, reducing premature status checks or cancels.
+
 ## 2.1.14 - 2026-06-25
 
 Terminal focus and Dream memory reliability.

package/dist/src/cli/team.js

@@ -124,6 +124,23 @@ const GOAL_REPORT_USAGE = 'Usage: team goal report --goal <goal-id> --status pro
 const GOAL_REPORT_STATUSES = new Set(['progress', 'done', 'blocked', 'failed']);
 const usageFor = (command) => (command === 'status' ? STATUS_USAGE : REPORT_USAGE);
 const withUsage = (message, command) => `${message}\n\n${usageFor(command)}`;
+const printOrchestratorDeliveryWarning = (action, payload) => {
+    if (payload.delivery_state === 'delivered' || payload.delivery_state === 'delivering')
+        return;
+    if (payload.delivery_state === 'queued') {
+        const detail = payload.forward_error ? `: ${payload.forward_error}` : '.';
+        console.error(`Hive recorded the ${action}, but Orchestrator did not receive it in real time. It is queued for durable delivery${detail}`);
+        return;
+    }
+    if (payload.delivery_state === 'failed') {
+        const detail = payload.forward_error ? `: ${payload.forward_error}` : '.';
+        console.error(`Hive recorded the ${action}, but could not deliver it to Orchestrator or confirm durable queueing${detail}`);
+        return;
+    }
+    if (payload.forwarded === false && payload.forward_error) {
+        console.error(`Hive recorded the ${action}, but could not deliver it to Orchestrator in real time: ${payload.forward_error}`);
+    }
+};
 const readGeneratedProtocolGuide = (topic) => {
     const protocolPath = join(process.cwd(), '.hive', 'PROTOCOL.md');
     if (!existsSync(protocolPath))
@@ -1043,9 +1060,7 @@ export const runTeamCommand = async (argv) => {
             artifacts: report.artifacts,
         });
         const payload = (await response.json());
-        if (payload.forwarded === false && payload.forward_error) {
-            console.error(`Hive recorded the status update, but could not deliver it to Orchestrator in real time: ${payload.forward_error}`);
-        }
+        printOrchestratorDeliveryWarning('status update', payload);
         if (payload.pending_warning)
             console.error(payload.pending_warning);
         return;
@@ -1064,9 +1079,7 @@ export const runTeamCommand = async (argv) => {
             artifacts: report.artifacts,
         });
         const payload = (await response.json());
-        if (payload.forwarded === false && payload.forward_error) {
-            console.error(`Hive recorded the report, but could not deliver it to Orchestrator in real time: ${payload.forward_error}`);
-        }
+        printOrchestratorDeliveryWarning('report', payload);
         if (payload.pending_warning)
             console.error(payload.pending_warning);
         return;

package/dist/src/server/agent-startup-instructions.d.ts

@@ -9,6 +9,7 @@ export declare const buildAgentLegacyIdentityMarker: ({ agent, workspace, }: {
     workspace: WorkspaceSummary;
 }) => string;
 export declare const WORKER_STARTUP_READY_STATUS = "ready: startup prompt received; Hive CLI channel OK; waiting for dispatch.";
+export declare const REVIEWER_STARTUP_READY_STATUS = "ready: reviewer available as the final review gate. If review finds issues, have them fixed and send the work back to me until no issues remain before reporting completion to the user.";
 export declare const buildAgentStartupInstructions: ({ agent, memoryDigest, workspace, flags, }: {
     agent: AgentSummary;
     memoryDigest?: string | null | undefined;

package/dist/src/server/agent-startup-instructions.js

@@ -5,6 +5,8 @@ import { TASKS_RELATIVE_PATH } from './tasks-file.js';
 export const buildAgentSessionBindingMarker = ({ agent, workspace, }) => `Hive session binding: workspace_id=${workspace.id}; agent_id=${agent.id}`;
 export const buildAgentLegacyIdentityMarker = ({ agent, workspace, }) => `You are ${escapeHiveEnvelopeText(agent.name)} (${agent.role}) in workspace ${escapeHiveEnvelopeText(workspace.name)}.`;
 export const WORKER_STARTUP_READY_STATUS = 'ready: startup prompt received; Hive CLI channel OK; waiting for dispatch.';
+export const REVIEWER_STARTUP_READY_STATUS = 'ready: reviewer available as the final review gate. If review finds issues, have them fixed and send the work back to me until no issues remain before reporting completion to the user.';
+const getStartupReadyStatus = (agent) => agent.role === 'reviewer' ? REVIEWER_STARTUP_READY_STATUS : WORKER_STARTUP_READY_STATUS;
 export const buildAgentStartupInstructions = ({ agent, memoryDigest, workspace, flags = FEATURE_FLAGS_ALL_OFF, }) => {
     const { workflowsEnabled } = flags;
     const lines = [
@@ -35,7 +37,8 @@ export const buildAgentStartupInstructions = ({ agent, memoryDigest, workspace,
         lines.push('Available team commands:', '- team status "<finding>" [--artifact <path>]                     escalate a patrol finding to the Orchestrator', '- team status --stdin [--artifact <path>]                         same, body read from stdin', '- team recall "<query>" [--limit <n>] [--window <n>]               search prior team messages/reports in this workspace', '- team memory show <memory-id>                                     inspect a memory entry and its evidence', '- team memory search "<query>" [--limit <n>]                         search active workspace memory', '- team --help                                                     command syntax only', '', 'You observe only: no dispatches are ever assigned to you, and `team report` is not available to your role.', '', 'Hive sentinel boundaries:', ...getHiveTeamRules(agent, flags));
     }
     else {
-        lines.push('Available team commands:', '- team report "<result>" [--dispatch <id>] [--artifact <path>]    report done / failed / blocked', '- team report --stdin [--dispatch <id>] [--artifact <path>]       same, body read from stdin (multi-line / quotes / special chars)', '- team status "<state>" [--artifact <path>]                       progress / standby update at any time; never closes a dispatch', '- team status --stdin [--artifact <path>]                         same, body read from stdin', '- team recall "<query>" [--limit <n>] [--window <n>]               search prior team messages/reports in this workspace', '- team memory show <memory-id>                                     inspect a memory entry and its evidence', '- team memory search "<query>" [--limit <n>]                         search active workspace memory', '- team memory dream show <dream-run-id>                            inspect a pending Dream run only when the Orchestrator assigns memory review', '- team --help                                                     command syntax only; NOT a way to report', '', 'Startup handshake:', `- After reading this startup message, immediately run exactly once: \`team status "${WORKER_STARTUP_READY_STATUS}"\`.`, '- This readiness status tells the Orchestrator this member started successfully; it does not close any dispatch.', '- Do not use `team report` for startup readiness. Use `team report` only after you receive an assigned dispatch task.', '', 'Syntax notes:', '- The body is the first positional argument; flag order is free: `team report "result" --dispatch X` and `team report --dispatch X "result"` are both valid.', "- Long bodies (multi-line / quotes / shell metacharacters) always go through `--stdin`, piped in via your shell (POSIX: a quoted heredoc `<<'EOF' … EOF` to stop $var / backtick expansion; Windows cmd: `type body.txt |` or `< body.txt`; PowerShell: `Get-Content -Raw -Encoding utf8 body.txt |`). `--stdin` only reads from stdin and relies on no shell syntax of its own.", '- On error the CLI also prints USAGE — fix the arguments against it.', '', 'Hive member boundaries:', ...getHiveTeamRules(agent, flags));
+        const startupReadyStatus = getStartupReadyStatus(agent);
+        lines.push('Available team commands:', '- team report "<result>" [--dispatch <id>] [--artifact <path>]    report done / failed / blocked', '- team report --stdin [--dispatch <id>] [--artifact <path>]       same, body read from stdin (multi-line / quotes / special chars)', '- team status "<state>" [--artifact <path>]                       progress / standby update at any time; never closes a dispatch', '- team status --stdin [--artifact <path>]                         same, body read from stdin', '- team recall "<query>" [--limit <n>] [--window <n>]               search prior team messages/reports in this workspace', '- team memory show <memory-id>                                     inspect a memory entry and its evidence', '- team memory search "<query>" [--limit <n>]                         search active workspace memory', '- team memory dream show <dream-run-id>                            inspect a pending Dream run only when the Orchestrator assigns memory review', '- team --help                                                     command syntax only; NOT a way to report', '', 'Startup handshake:', `- After reading this startup message, immediately run exactly once: \`team status "${startupReadyStatus}"\`.`, '- This readiness status tells the Orchestrator this member started successfully; it does not close any dispatch.', '- Do not use `team report` for startup readiness. Use `team report` only after you receive an assigned dispatch task.', '', 'Syntax notes:', '- The body is the first positional argument; flag order is free: `team report "result" --dispatch X` and `team report --dispatch X "result"` are both valid.', "- Long bodies (multi-line / quotes / shell metacharacters) always go through `--stdin`, piped in via your shell (POSIX: a quoted heredoc `<<'EOF' … EOF` to stop $var / backtick expansion; Windows cmd: `type body.txt |` or `< body.txt`; PowerShell: `Get-Content -Raw -Encoding utf8 body.txt |`). `--stdin` only reads from stdin and relies on no shell syntax of its own.", '- On error the CLI also prints USAGE — fix the arguments against it.', '', 'Hive member boundaries:', ...getHiveTeamRules(agent, flags));
     }
     lines.push('', '</hive-message>', '');
     return lines.join('\n');

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

@@ -23,6 +23,7 @@ export const buildOrchestratorReminderTail = ({ workflowsEnabled }) => {
         '(a) `team list`, then `team send "<member-name>" "<task>"` to dispatch to a suitable existing member by name. Prefer user-created/user-managed members already in the current team; stale names fail. ' +
         `If no existing member fits, a member is stopped/queued/not prompt-ready, or independent branches need more members, report that condition and recommend what member the user may start or add; do not take a branch yourself. Use \`team spawn <role> [--cli <${BUILTIN_COMMAND_PRESET_CLI_LIST}>] [--ephemeral]\` only when the user explicitly authorizes it or workspace policy permits autonomous staffing for this task. ` +
         '(b) `team cancel --dispatch <id> "<reason>"` to close an obsolete dispatch. ' +
+        'Accepted dispatches should normally be left alone until the member reports. Do not cancel or send status checks unless progress is genuinely overdue or the user asks. ' +
         (workflowsEnabled
             ? '(c) `team workflow run --stdin` to fan out across 3+ members or run a staged review→fix — never a loop of `team send` (no barrier, no UI group, no stop button). (d) plain text only for clarification, status/final synthesis, or the explicitly allowed trivial check. '
             : '(c) plain text only for clarification, status/final synthesis, or the explicitly allowed trivial check. ') +
@@ -58,6 +59,7 @@ const CORE_ORCHESTRATOR_RULES = [
     'Do not keep a non-trivial parallel branch for yourself just to avoid dispatching.',
     'If a dispatch must be changed or cancelled, use `team cancel --dispatch <id> "<reason>"`, then resend the full updated task if needed.',
     'Each `team send` creates a separate dispatch and requires a separate `team report`.',
+    'Accepted dispatches should normally be left alone until the member reports. Do not cancel or send status checks unless progress is genuinely overdue or the user asks.',
     'Treat stopped, queued, delivery-failed, and prompt-readiness-timeout as current-team runtime conditions to report or retry, not proof that the member is unsuitable.',
     '`team spawn` is persistent by default. When authorized to create task-scoped capacity, prefer `--ephemeral` unless the user asks for persistent capacity.',
     'All Hive members in one workspace share the same filesystem root with no per-member isolation. Split dispatches so no two members edit the same files/modules at the same time; if work would collide, serialize it or assign one owner.',

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

@@ -118,6 +118,7 @@ export interface CreateWorkspaceBody {
 }
 export interface CreateWorkerBody {
     autostart?: boolean;
+    avatar?: string | null;
     command_preset_id?: string | null;
     description?: string;
     name: string;

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

@@ -340,6 +340,7 @@ export const teamRoutes = [
                 status,
             });
             sendJson(response, 202, {
+                delivery_state: result.deliveryState,
                 dispatch_id: result.dispatch?.id ?? null,
                 forward_error: result.forwardError,
                 forwarded: result.forwarded,
@@ -351,6 +352,7 @@ export const teamRoutes = [
         else {
             const result = store.reportTask(projectId, fromAgentId, reportInput);
             sendJson(response, 202, {
+                delivery_state: result.deliveryState,
                 dispatch_id: result.dispatch?.id ?? null,
                 forward_error: result.forwardError,
                 forwarded: result.forwarded,
@@ -379,6 +381,7 @@ export const teamRoutes = [
             text: resultText,
         });
         sendJson(response, 202, {
+            delivery_state: result.deliveryState,
             dispatch_id: result.dispatch?.id ?? null,
             forward_error: result.forwardError,
             forwarded: result.forwarded,

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

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

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

@@ -0,0 +1,112 @@
+import { normalizeWorkerAvatar } from '../shared/worker-avatar.js';
+import { resolveCommandPresetLaunchConfig, resolveStartupCommandLaunchConfig, } from './agent-launch-resolver.js';
+import { BadRequestError } from './http-errors.js';
+import { autostartAgent } from './orchestrator-autostart.js';
+import { getDefaultRoleDescription } from './role-templates.js';
+import { getRequiredParam, readJsonBody, route, sendJson } from './route-helpers.js';
+import { enrichTeamList } from './team-list-enrichment.js';
+import { serializeTeamListItem } from './team-list-serializer.js';
+import { requireUiTokenFromRequest } from './ui-auth-helpers.js';
+import { resolveWorkspaceUiLanguage } from './workspace-ui-language.js';
+const getRuntimePort = (request) => String(request.socket.localPort ?? '');
+const readWorkerAvatar = (value) => {
+    try {
+        return normalizeWorkerAvatar(value);
+    }
+    catch (error) {
+        throw new BadRequestError(error instanceof Error ? error.message : String(error));
+    }
+};
+const getSerializedWorker = (workspaceId, workerId, store) => {
+    const worker = store.listWorkers(workspaceId).find((item) => item.id === workerId);
+    if (!worker) {
+        throw new Error(`Worker not found: ${workerId}`);
+    }
+    const [enriched] = enrichTeamList(workspaceId, store, [worker]);
+    if (!enriched)
+        throw new Error(`Worker enrichment failed: ${workerId}`);
+    return serializeTeamListItem(enriched, undefined, { includeAvatar: true });
+};
+export const workerRoutes = [
+    route('POST', '/api/workspaces/:workspaceId/workers', async ({ params, request, response, store }) => {
+        const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Workspace id is required');
+        if (!workspaceId) {
+            return;
+        }
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const body = await readJsonBody(request);
+        const avatar = Object.hasOwn(body, 'avatar') ? readWorkerAvatar(body.avatar) : null;
+        const presetId = body.command_preset_id ?? null;
+        const startupCommand = typeof body.startup_command === 'string' ? body.startup_command : null;
+        const language = resolveWorkspaceUiLanguage(store.settings, workspaceId, body.ui_language);
+        const launchConfig = startupCommand?.trim()
+            ? resolveStartupCommandLaunchConfig(store.settings, startupCommand, presetId)
+            : presetId
+                ? resolveCommandPresetLaunchConfig(store.settings, presetId)
+                : undefined;
+        if (presetId && !startupCommand?.trim() && !launchConfig) {
+            throw new Error(`Command preset not found: ${presetId}`);
+        }
+        const worker = store.addWorker(workspaceId, {
+            ...body,
+            avatar,
+            description: typeof body.description === 'string'
+                ? body.description
+                : getDefaultRoleDescription(body.role, language),
+        });
+        if (launchConfig) {
+            try {
+                store.configureAgentLaunch(workspaceId, worker.id, launchConfig);
+            }
+            catch (error) {
+                store.deleteWorker(workspaceId, worker.id);
+                throw error;
+            }
+        }
+        const agentStart = body.autostart === true
+            ? await autostartAgent(store, workspaceId, worker.id, getRuntimePort(request), {
+                missingConfigError: 'No worker launch config available',
+            })
+            : { ok: false, error: null, run_id: null };
+        sendJson(response, 201, {
+            ...getSerializedWorker(workspaceId, worker.id, store),
+            agent_start: agentStart,
+        });
+    }),
+    route('DELETE', '/api/workspaces/:workspaceId/workers/:workerId', ({ params, request, response, store }) => {
+        const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Workspace id and worker id are required');
+        const workerId = getRequiredParam(response, params, 'workerId', 'Workspace id and worker id are required');
+        if (!workspaceId || !workerId) {
+            return;
+        }
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        store.deleteWorker(workspaceId, workerId);
+        response.statusCode = 204;
+        response.end();
+    }),
+    route('PATCH', '/api/workspaces/:workspaceId/workers/:workerId', async ({ params, request, response, store }) => {
+        const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Workspace id and worker id are required');
+        const workerId = getRequiredParam(response, params, 'workerId', 'Workspace id and worker id are required');
+        if (!workspaceId || !workerId) {
+            return;
+        }
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const body = await readJsonBody(request);
+        const hasName = Object.hasOwn(body, 'name');
+        const hasAvatar = Object.hasOwn(body, 'avatar');
+        if (!hasName && !hasAvatar) {
+            sendJson(response, 400, { error: 'name or avatar is required' });
+            return;
+        }
+        if (hasName && typeof body.name !== 'string') {
+            sendJson(response, 400, { error: 'name must be a string' });
+            return;
+        }
+        const avatar = hasAvatar ? readWorkerAvatar(body.avatar) : undefined;
+        store.updateWorkerProfile(workspaceId, workerId, {
+            ...(hasName ? { name: body.name } : {}),
+            ...(hasAvatar ? { avatar: avatar ?? null } : {}),
+        });
+        sendJson(response, 200, getSerializedWorker(workspaceId, workerId, store));
+    }),
+];

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

@@ -1,8 +1,6 @@
-import { resolveCommandPresetLaunchConfig, resolveStartupCommandLaunchConfig, } from './agent-launch-resolver.js';
 import { PtyInactiveError } from './http-errors.js';
-import { autostartAgent, autostartOrchestrator } from './orchestrator-autostart.js';
+import { autostartOrchestrator } from './orchestrator-autostart.js';
 import { seedOrchestratorLaunchConfig } from './orchestrator-launch.js';
-import { getDefaultRoleDescription } from './role-templates.js';
 import { getRequiredParam, readJsonBody, route, sendJson } from './route-helpers.js';
 import { authenticateCliAgent, requireCommandForRole } from './team-authz.js';
 import { enrichTeamList } from './team-list-enrichment.js';
@@ -15,7 +13,7 @@ import { resolveWorkspaceUiLanguage, writeWorkspaceUiLanguage } from './workspac
    into the team list payload. Display-only ages — no timeout or heartbeat is
    derived from them; `queued` rows age from createdAt (submittedAt is null
    until delivery). */
-const serializeTeamListWithOpenDispatches = (store, workspaceId) => {
+const serializeTeamListWithOpenDispatches = (store, workspaceId, options = {}) => {
     const now = Date.now();
     const workflowAgentId = getWorkflowAgentId(workspaceId);
     const openByWorker = new Map();
@@ -35,17 +33,7 @@ const serializeTeamListWithOpenDispatches = (store, workspaceId) => {
         });
         openByWorker.set(dispatch.toAgentId, list);
     }
-    return enrichTeamList(workspaceId, store, store.listWorkers(workspaceId)).map((worker) => serializeTeamListItem(worker, openByWorker.get(worker.id)));
-};
-const getSerializedWorker = (workspaceId, workerId, store) => {
-    const worker = store.listWorkers(workspaceId).find((item) => item.id === workerId);
-    if (!worker) {
-        throw new Error(`Worker not found: ${workerId}`);
-    }
-    const [enriched] = enrichTeamList(workspaceId, store, [worker]);
-    if (!enriched)
-        throw new Error(`Worker enrichment failed: ${workerId}`);
-    return serializeTeamListItem(enriched);
+    return enrichTeamList(workspaceId, store, store.listWorkers(workspaceId)).map((worker) => serializeTeamListItem(worker, openByWorker.get(worker.id), options));
 };
 const getRuntimePort = (request) => String(request.socket.localPort ?? '');
 export const workspaceRoutes = [
@@ -92,7 +80,7 @@ export const workspaceRoutes = [
             return;
         }
         requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
-        sendJson(response, 200, serializeTeamListWithOpenDispatches(store, workspaceId));
+        sendJson(response, 200, serializeTeamListWithOpenDispatches(store, workspaceId, { includeAvatar: true }));
     }),
     route('GET', '/api/workspaces/:workspaceId/team', ({ params, request, response, store }) => {
         const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Workspace id is required');
@@ -114,75 +102,6 @@ export const workspaceRoutes = [
         store.drainReportOutbox(workspaceId, agent.id);
         sendJson(response, 200, serializeTeamListWithOpenDispatches(store, workspaceId));
     }),
-    route('POST', '/api/workspaces/:workspaceId/workers', async ({ params, request, response, store }) => {
-        const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Workspace id is required');
-        if (!workspaceId) {
-            return;
-        }
-        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
-        const body = await readJsonBody(request);
-        const presetId = body.command_preset_id ?? null;
-        const startupCommand = typeof body.startup_command === 'string' ? body.startup_command : null;
-        const language = resolveWorkspaceUiLanguage(store.settings, workspaceId, body.ui_language);
-        const launchConfig = startupCommand?.trim()
-            ? resolveStartupCommandLaunchConfig(store.settings, startupCommand, presetId)
-            : presetId
-                ? resolveCommandPresetLaunchConfig(store.settings, presetId)
-                : undefined;
-        if (presetId && !startupCommand?.trim() && !launchConfig) {
-            throw new Error(`Command preset not found: ${presetId}`);
-        }
-        const worker = store.addWorker(workspaceId, {
-            ...body,
-            description: typeof body.description === 'string'
-                ? body.description
-                : getDefaultRoleDescription(body.role, language),
-        });
-        if (launchConfig) {
-            try {
-                store.configureAgentLaunch(workspaceId, worker.id, launchConfig);
-            }
-            catch (error) {
-                store.deleteWorker(workspaceId, worker.id);
-                throw error;
-            }
-        }
-        const agentStart = body.autostart === true
-            ? await autostartAgent(store, workspaceId, worker.id, getRuntimePort(request), {
-                missingConfigError: 'No worker launch config available',
-            })
-            : { ok: false, error: null, run_id: null };
-        sendJson(response, 201, {
-            ...getSerializedWorker(workspaceId, worker.id, store),
-            agent_start: agentStart,
-        });
-    }),
-    route('DELETE', '/api/workspaces/:workspaceId/workers/:workerId', ({ params, request, response, store }) => {
-        const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Workspace id and worker id are required');
-        const workerId = getRequiredParam(response, params, 'workerId', 'Workspace id and worker id are required');
-        if (!workspaceId || !workerId) {
-            return;
-        }
-        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
-        store.deleteWorker(workspaceId, workerId);
-        response.statusCode = 204;
-        response.end();
-    }),
-    route('PATCH', '/api/workspaces/:workspaceId/workers/:workerId', async ({ params, request, response, store }) => {
-        const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Workspace id and worker id are required');
-        const workerId = getRequiredParam(response, params, 'workerId', 'Workspace id and worker id are required');
-        if (!workspaceId || !workerId) {
-            return;
-        }
-        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
-        const body = await readJsonBody(request);
-        if (typeof body.name !== 'string') {
-            sendJson(response, 400, { error: 'name is required' });
-            return;
-        }
-        store.renameWorker(workspaceId, workerId, body.name);
-        sendJson(response, 200, getSerializedWorker(workspaceId, workerId, store));
-    }),
     route('POST', '/api/workspaces/:workspaceId/user-input', async ({ params, request, response, store }) => {
         const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Workspace id is required');
         if (!workspaceId) {

package/dist/src/server/routes.js

@@ -17,6 +17,7 @@ import { teamMemoryRoutes } from './routes-team-memory.js';
 import { teamRecallRoutes } from './routes-team-recall.js';
 import { uiRoutes } from './routes-ui.js';
 import { versionRoutes } from './routes-version.js';
+import { workerRoutes } from './routes-workers.js';
 import { workflowScheduleRoutes } from './routes-workflow-schedules.js';
 import { workflowRoutes } from './routes-workflows.js';
 import { workspaceMemoryRoutes } from './routes-workspace-memory.js';
@@ -25,6 +26,7 @@ import { workspaceUploadRoutes } from './routes-workspace-uploads.js';
 import { workspaceRoutes } from './routes-workspaces.js';
 const routes = [
     ...workspaceRoutes,
+    ...workerRoutes,
     ...scenarioRoutes,
     ...workspaceUploadRoutes,
     ...openWorkspaceRoutes,

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

@@ -34,6 +34,11 @@ export interface RuntimeStore {
     addWorker: (workspaceId: string, input: WorkerInput) => AgentSummary;
     addWorkerWithLaunch: (workspaceId: string, input: WorkerInput, launchConfig: AgentLaunchConfigInput) => AgentSummary;
     deleteWorker: (workspaceId: string, workerId: string) => void;
+    updateWorkerProfile: (workspaceId: string, workerId: string, input: {
+        avatar?: string | null;
+        name?: string;
+    }) => AgentSummary;
+    updateWorkerAvatar: (workspaceId: string, workerId: string, avatar: string | null) => AgentSummary;
     renameWorker: (workspaceId: string, workerId: string, name: string) => AgentSummary;
     recordUserInput: (workspaceId: string, orchestratorId: string, text: string) => void;
     deliverUserInput: (workspaceId: string, orchestratorId: string, text: string) => Promise<void>;

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

@@ -81,6 +81,8 @@ export const createRuntimeStore = (options = {}) => {
         },
         addWorker: (workspaceId, input) => services.workspaceStore.addWorker(workspaceId, input),
         addWorkerWithLaunch: workerMutations.addWorkerWithLaunch,
+        updateWorkerProfile: (workspaceId, workerId, input) => services.workspaceStore.updateWorkerProfile(workspaceId, workerId, input),
+        updateWorkerAvatar: (workspaceId, workerId, avatar) => services.workspaceStore.updateWorkerAvatar(workspaceId, workerId, avatar),
         renameWorker: (workspaceId, workerId, name) => services.workspaceStore.renameWorker(workspaceId, workerId, name),
         deleteWorker: workerMutations.deleteWorker,
         recordUserInput: services.teamOps.recordUserInput,

package/dist/src/server/sqlite-schema-v39.d.ts

@@ -0,0 +1,2 @@
+import type { Database } from 'better-sqlite3';
+export declare const applySchemaVersion39: (db: Database) => void;

package/dist/src/server/sqlite-schema-v39.js

@@ -0,0 +1,6 @@
+export const applySchemaVersion39 = (db) => {
+    const workerColumns = new Set(db.prepare('PRAGMA table_info(workers)').all().map((column) => column.name));
+    if (!workerColumns.has('avatar')) {
+        db.exec('ALTER TABLE workers ADD COLUMN avatar TEXT');
+    }
+};

package/dist/src/server/sqlite-schema.d.ts

@@ -1,3 +1,3 @@
 import type { Database } from 'better-sqlite3';
-export declare const CURRENT_SCHEMA_VERSION = 38;
+export declare const CURRENT_SCHEMA_VERSION = 39;
 export declare const initializeRuntimeDatabase: (db: Database) => void;

package/dist/src/server/sqlite-schema.js

@@ -31,7 +31,8 @@ import { applySchemaVersion35 } from './sqlite-schema-v35.js';
 import { applySchemaVersion36 } from './sqlite-schema-v36.js';
 import { applySchemaVersion37 } from './sqlite-schema-v37.js';
 import { applySchemaVersion38 } from './sqlite-schema-v38.js';
-export const CURRENT_SCHEMA_VERSION = 38;
+import { applySchemaVersion39 } from './sqlite-schema-v39.js';
+export const CURRENT_SCHEMA_VERSION = 39;
 // Idempotent column-add helper. SQLite doesn't have `ALTER TABLE … ADD COLUMN
 // IF NOT EXISTS`, so PRAGMA-check first. Safe to call on every init; required
 // for foreign-built DBs where the version-gated migration is skipped.
@@ -60,6 +61,7 @@ export const initializeRuntimeDatabase = (db) => {
       workspace_id TEXT NOT NULL,
       name TEXT NOT NULL,
       description TEXT,
+      avatar TEXT,
       last_session_id TEXT,
       role TEXT NOT NULL,
       created_at INTEGER NOT NULL
@@ -239,6 +241,7 @@ export const initializeRuntimeDatabase = (db) => {
     // migration leaves these absent. PRAGMA + ALTER here makes the writes safe.
     ensureColumn(db, 'workers', 'ephemeral', 'INTEGER NOT NULL DEFAULT 0');
     ensureColumn(db, 'workers', 'spawned_by', 'TEXT');
+    ensureColumn(db, 'workers', 'avatar', 'TEXT');
     ensureColumn(db, 'dispatches', 'workflow_run_id', 'TEXT');
     ensureColumn(db, 'dispatches', 'step_index', 'INTEGER');
     // M9 — phase + label on dispatches so the workflow UI can render the
@@ -449,4 +452,8 @@ export const initializeRuntimeDatabase = (db) => {
     if (!appliedVersions.has(38)) {
         db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(38, Date.now());
     }
+    applySchemaVersion39(db);
+    if (!appliedVersions.has(39)) {
+        db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(39, Date.now());
+    }
 };

package/dist/src/server/team-list-serializer.d.ts

@@ -1,2 +1,6 @@
 import type { TeamListItem, TeamListItemPayload, TeamListOpenDispatchPayload } from '../shared/types.js';
-export declare const serializeTeamListItem: ({ commandPresetId, ephemeral, id, lastPtyLine, name, pendingTaskCount, role, spawnedBy, status, }: TeamListItem, openDispatches?: TeamListOpenDispatchPayload[]) => TeamListItemPayload;
+type SerializeTeamListItemOptions = {
+    includeAvatar?: boolean;
+};
+export declare const serializeTeamListItem: ({ avatar, commandPresetId, ephemeral, id, lastPtyLine, name, pendingTaskCount, role, spawnedBy, status, }: TeamListItem, openDispatches?: TeamListOpenDispatchPayload[], options?: SerializeTeamListItemOptions) => TeamListItemPayload;
+export {};

package/dist/src/server/team-list-serializer.js

@@ -1,9 +1,10 @@
-export const serializeTeamListItem = ({ commandPresetId, ephemeral, id, lastPtyLine, name, pendingTaskCount, role, spawnedBy, status, }, openDispatches) => ({
+export const serializeTeamListItem = ({ avatar, commandPresetId, ephemeral, id, lastPtyLine, name, pendingTaskCount, role, spawnedBy, status, }, openDispatches, options = {}) => ({
     id,
     name,
     role,
     status,
     pending_task_count: pendingTaskCount,
+    ...(options.includeAvatar === true && avatar ? { avatar } : {}),
     last_pty_line: lastPtyLine ?? null,
     command_preset_id: commandPresetId ?? null,
     ...(ephemeral === true ? { ephemeral: true } : {}),

package/dist/src/server/team-memory-dream-prompt.js

@@ -1,3 +1,4 @@
+import { DREAM_MEMORY_BODY_MAX_CHARS, DREAM_MEMORY_MAX_ADDS_PER_RUN, MEMORY_PROCEDURE_REF_ID_MAX_CHARS, MEMORY_PROCEDURE_REF_TITLE_MAX_CHARS, MEMORY_TAG_MAX_CHARS, MEMORY_TAG_MAX_COUNT, } from '../shared/team-memory.js';
 import { escapeHiveEnvelopeAttribute, escapeHiveEnvelopeText } from './hive-envelope-escape.js';
 export const DREAM_PROMPT_MESSAGE_LIMIT = 200;
 export const DREAM_PROMPT_MEMORY_LIMIT = 100;
@@ -38,14 +39,25 @@ export const buildDreamPrompt = (input) => [
     'Read only the protocol messages and memory entries below.',
     'Return strict JSON only, with shape {"ops":[...]} and no prose.',
     '',
+    'Output contract (runtime-validated):',
+    '- Return exactly {"ops":[...]} as JSON. No markdown, no prose.',
+    `- Add no more than ${DREAM_MEMORY_MAX_ADDS_PER_RUN} memories per run.`,
+    `- For add/rewrite/merge, body is required and must be <= ${DREAM_MEMORY_BODY_MAX_CHARS} characters. Prefer one compact sentence.`,
+    `- If any proposed body would exceed ${DREAM_MEMORY_BODY_MAX_CHARS} characters, shorten it before returning JSON. Never emit an over-limit body.`,
+    `- tags must be an array of <= ${MEMORY_TAG_MAX_COUNT} non-empty strings, each <= ${MEMORY_TAG_MAX_CHARS} characters.`,
+    '- confidence, when present, must be a number from 0 to 1.',
+    '- sources, when present, must be [{"sequence": <positive integer>}] from the protocol window.',
+    `- procedure_ref.id must be <= ${MEMORY_PROCEDURE_REF_ID_MAX_CHARS} characters; procedure_ref.title, when present, must be <= ${MEMORY_PROCEDURE_REF_TITLE_MAX_CHARS} characters.`,
+    '- For rewrite/merge, omit kind, tags, confidence, and procedure_ref to preserve current values. Use procedure_ref:null only when intentionally clearing an existing ref; provide a structured procedure_ref when the resulting kind is procedure_ref.',
+    '',
     'Allowed ops:',
-    '- {"op":"add","kind":"fact|preference|decision|pitfall","body":"...","tags":[],"confidence":0.0-1.0,"sources":[{"sequence":123}]}',
-    '- {"op":"add","kind":"procedure_ref","body":"...","tags":[],"confidence":0.0-1.0,"sources":[{"sequence":123}],"procedure_ref":{"type":"workflow|skill|procedure|template|doc","id":"...","title":"..."}}',
-    '- {"op":"rewrite","id":"<memory-id>","body":"...","tags":[],"procedure_ref":null}',
+    `- {"op":"add","kind":"fact|preference|decision|pitfall","body":"<=${DREAM_MEMORY_BODY_MAX_CHARS} chars","tags":[],"confidence":0.0-1.0,"sources":[{"sequence":123}]}`,
+    `- {"op":"add","kind":"procedure_ref","body":"<=${DREAM_MEMORY_BODY_MAX_CHARS} chars","tags":[],"confidence":0.0-1.0,"sources":[{"sequence":123}],"procedure_ref":{"type":"workflow|skill|procedure|template|doc","id":"<=${MEMORY_PROCEDURE_REF_ID_MAX_CHARS} chars","title":"<=${MEMORY_PROCEDURE_REF_TITLE_MAX_CHARS} chars"}}`,
+    `- {"op":"rewrite","id":"<memory-id>","body":"<=${DREAM_MEMORY_BODY_MAX_CHARS} chars"}`,
     '- {"op":"archive","id":"<memory-id>","reason":"..."}',
-    '- {"op":"merge","into":"<memory-id>","from":["<memory-id>"],"body":"..."}',
+    `- {"op":"merge","into":"<memory-id>","from":["<memory-id>"],"body":"<=${DREAM_MEMORY_BODY_MAX_CHARS} chars"}`,
     '',
-    'Rules: add at most 10 entries; every body must be 500 characters or fewer; archive never deletes; if nothing is worth remembering, return {"ops":[]}.',
+    `Rules: add at most ${DREAM_MEMORY_MAX_ADDS_PER_RUN} entries; archive never deletes; if nothing is worth remembering, return {"ops":[]}.`,
     'Do not use kind "procedure_ref" for ordinary workflow advice, command sequences, or procedural lessons. Use fact, decision, preference, or pitfall instead.',
     'Use kind "procedure_ref" only when the memory points to a durable existing workflow/skill/procedure/template/doc identity, and always include procedure_ref.type plus procedure_ref.id. Keep body as a short reason to consult it.',
     'Use protocol evidence only: report text, dispatch status, user input, and artifacts. Do not trust self-praise without a concrete report or failure signal.',
@@ -88,6 +100,7 @@ export const buildDreamMaintenancePayload = (run) => [
     '- Members may run team memory dream show only when you explicitly assign Dream review; only the orchestrator may run team memory apply.',
     '- Do not edit .hive/memory.md directly and do not use team memory add/forget for this Dream run.',
     '- If nothing is worth remembering, apply {"ops":[]}.',
+    `- Follow the Dream output contract from dream show; every submitted body must be ${DREAM_MEMORY_BODY_MAX_CHARS} characters or fewer.`,
     '- The runtime will validate the run id, workspace, source window, operation shape, and touched memory ids transactionally.',
     '',
     '</hive-system-memory-maintenance>',

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

@@ -88,7 +88,9 @@ export interface CancelTaskInput {
     fromAgentId: string;
     reason: string;
 }
+export type ReportDeliveryState = 'delivered' | 'delivering' | 'queued' | 'failed';
 export interface ReportTaskResult {
+    deliveryState?: ReportDeliveryState;
     dispatch: DispatchRecord | null;
     forwardError: string | null;
     forwarded: boolean;
@@ -121,11 +123,13 @@ export declare const createTeamOperations: ({ agentRuntime, createDispatch, dele
         dispatch: null;
         forwardError: string | null;
         forwarded: boolean;
+        deliveryState?: ReportDeliveryState;
     };
     reportTask(workspaceId: string, workerId: string, input?: ReportTaskInput): {
         pendingWarning?: string;
         dispatch: DispatchRecord;
         forwardError: string | null;
         forwarded: boolean;
+        deliveryState?: ReportDeliveryState;
     };
 };