@tt-a1i/hive 2.1.9 → 2.1.10

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 All notable user-facing changes will be documented in this file.
 
+## 2.1.10 - 2026-06-23
+
+Scenario teams and terminal delivery polish.
+
+- Starts members created from one-click scenarios immediately, so the team is
+  ready for the Orchestrator to assign work instead of sitting stopped.
+- Uses the shared member-name pool for scenario-created members, matching the
+  Add Member dialog and avoiding generated stem-only names.
+- Improves OpenCode dispatch delivery after startup by recognizing its completed
+  turn footer as a ready signal, while waiting briefly for the terminal output
+  to settle before injecting the next dispatch.
+- Adds an explicit accepted-dispatch status instruction to member tasks, making
+  it easier to see that a member received a dispatch before it starts working.
+- Keeps optimistic terminal panels tied to real run lifecycle events and
+  preserves Codex cursor-position repaint frames, improving terminal display
+  during editing and fast start/stop flows.
+
 ## 2.1.9 - 2026-06-23
 
 Lean Hive guidance and desktop terminal polish.

package/dist/src/server/agent-stdin-dispatcher.js

@@ -42,6 +42,7 @@ export const buildWorkerDispatchPayload = (fromAgentName, workerDescription, dis
     `Your role: ${escapeHiveEnvelopeText(workerDescription)}`,
     '',
     'You must:',
+    `- Immediately acknowledge receipt by running \`team status "accepted dispatch ${dispatchId}"\` before doing the task`,
     `- When the task is done, failed, blocked, or partially done, run \`team report "<result>" --dispatch ${dispatchId}\``,
     '- Do not do unrelated work; report as soon as you are done',
     '- Never stop to wait for terminal input — if you need a decision, report the question as blocked instead',

package/dist/src/server/post-start-input-writer.js

@@ -4,6 +4,7 @@ const READY_CHECK_INTERVAL_MS = 50;
 const READY_TIMEOUT_MS = 3000;
 const PROMPT_READY_HARD_TIMEOUT_MS = 30000;
 const PROMPT_READY_TAIL_CHARS = 8000;
+const OPENCODE_COMPLETION_READY_SETTLE_MS = 1000;
 const MIN_SUBMIT_AFTER_PASTE_DELAY_MS = 600;
 const MAX_SUBMIT_AFTER_PASTE_DELAY_MS = 1500;
 const PASTE_CHARS_PER_DELAY_MS = 4;
@@ -75,7 +76,8 @@ const hasHermesPromptReady = (output) => {
     const plain = getPlainTerminalTail(output);
     return /\bWelcome to Hermes Agent![\s\S]*❯/u.test(plain);
 };
-const hasOpencodePromptReady = (output) => /\bAsk anything\.\.\./u.test(getPlainTerminalTail(output));
+const hasOpencodeVisiblePromptReady = (output) => /\bAsk anything\.\.\./u.test(getPlainTerminalTail(output));
+const hasOpencodeCompletedTurnReady = (output) => /(?:^|\s)▣\s+Build\s+·/u.test(getLastNonEmptyTerminalLine(output));
 const hasGrokPromptReady = (output) => /\b(?:Enter:send|Composer\s+\S+)/u.test(output);
 const hasAgyPromptReady = (output) => /(?:^|\n)\s*>\s*\n\s*(?:[─-]{8,}|\?\s*for shortcuts)/u.test(getPlainTerminalOutput(output));
 const getLastNonEmptyTerminalLine = (output) => {
@@ -110,15 +112,24 @@ export const hasFirstRunSetupPrompt = (output) => {
     const recent = recentLines.join('\n');
     return SETUP_PROMPT_PATTERNS.some((pattern) => pattern.test(recent));
 };
-export const hasInteractivePromptReady = (output, command = '') => {
+const getInteractivePromptReadyState = (output, command = '') => {
     const commandName = getCommandName(command);
-    return (hasBarePromptLine(output) ||
+    if (hasBarePromptLine(output) ||
         (commandName === 'agy' && hasAgyPromptReady(output)) ||
         (commandName === 'grok' && hasGrokPromptReady(output)) ||
         (commandName === 'hermes' && hasHermesPromptReady(output)) ||
-        ((commandName === 'gemini' || commandName === 'qwen') && hasGeminiPromptReady(output)) ||
-        (commandName === 'opencode' && hasOpencodePromptReady(output)));
+        ((commandName === 'gemini' || commandName === 'qwen') && hasGeminiPromptReady(output))) {
+        return 'ready';
+    }
+    if (commandName === 'opencode') {
+        if (hasOpencodeVisiblePromptReady(output))
+            return 'ready';
+        if (hasOpencodeCompletedTurnReady(output))
+            return 'ready-after-settle';
+    }
+    return 'not-ready';
 };
+export const hasInteractivePromptReady = (output, command = '') => getInteractivePromptReadyState(output, command) !== 'not-ready';
 export const hasBracketedPasteAcknowledgement = (output, baselineLength) => {
     const outputAfterPaste = output.slice(baselineLength);
     const pasteEndIndex = outputAfterPaste.lastIndexOf(BRACKETED_PASTE_END);
@@ -282,6 +293,24 @@ export const createPostStartInputWriter = (agentManager, command) => {
         });
         const startedAt = Date.now();
         let isInitialAttempt = true;
+        let settleCandidate = null;
+        const isReadyToWrite = (output) => {
+            const promptReadyState = getInteractivePromptReadyState(output, command);
+            if (promptReadyState === 'ready') {
+                settleCandidate = null;
+                return true;
+            }
+            if (promptReadyState !== 'ready-after-settle') {
+                settleCandidate = null;
+                return false;
+            }
+            const tail = getPlainTerminalTail(output);
+            if (!settleCandidate || settleCandidate.tail !== tail) {
+                settleCandidate = { since: Date.now(), tail };
+                return false;
+            }
+            return Date.now() - settleCandidate.since >= OPENCODE_COMPLETION_READY_SETTLE_MS;
+        };
         const tryWrite = () => {
             let output;
             try {
@@ -297,7 +326,7 @@ export const createPostStartInputWriter = (agentManager, command) => {
                 return;
             }
             const firstRunSetupPromptVisible = hasFirstRunSetupPrompt(output);
-            if ((!firstRunSetupPromptVisible && hasInteractivePromptReady(output, command)) ||
+            if ((!firstRunSetupPromptVisible && isReadyToWrite(output)) ||
                 (!firstRunSetupPromptVisible &&
                     canTimeoutBeforePromptReady(command) &&
                     Date.now() - startedAt >= READY_TIMEOUT_MS)) {

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

@@ -4,23 +4,18 @@ import type { RuntimeStore } from './runtime-store-contract.js';
 import { type ScenarioPreset } from './scenario-presets.js';
 import { type CliAvailabilityProbe } from './spawn-cli-resolver.js';
 import { type UiLanguage } from './workspace-ui-language.js';
-export declare const scenarioRoutes: RouteDefinition[];
-/**
- * Materialize the scenario team and hand the goal to the orchestrator.
- * Exported for direct testing (the route harness has no PTY, so the
- * active-run gate above would mask this logic).
- *
- * Workers derive a FRESH launch config from the orchestrator's CLI brand via
- * the same resolver `team spawn` uses — never a clone of the orchestrator's
- * own config, which may carry session-resume arguments that would make every
- * worker resume the orchestrator's session.
- *
- * Worker creation is sequential and NOT transactional across workers: each
- * addWorkerWithLaunch is atomic, but a mid-loop failure (e.g. a name race)
- * leaves earlier workers in place and surfaces the error to the caller.
- */
-export declare const applyScenario: (store: RuntimeStore, workspaceId: string, scenario: ScenarioPreset, goal: string, isCommandAvailable?: CliAvailabilityProbe, language?: UiLanguage) => Array<{
+type CreatedScenarioWorker = {
     id: string;
     name: string;
     role: WorkerRole;
-}>;
+};
+type StartedScenarioWorker = CreatedScenarioWorker & {
+    start: {
+        ok: true;
+        run_id: string;
+    };
+};
+export declare const scenarioRoutes: RouteDefinition[];
+export declare const applyScenario: (store: RuntimeStore, workspaceId: string, scenario: ScenarioPreset, goal: string, isCommandAvailable?: CliAvailabilityProbe, language?: UiLanguage) => CreatedScenarioWorker[];
+export declare const applyAndStartScenario: (store: RuntimeStore, workspaceId: string, scenario: ScenarioPreset, goal: string, hivePort: string, isCommandAvailable?: CliAvailabilityProbe, language?: UiLanguage) => Promise<StartedScenarioWorker[]>;
+export {};

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

@@ -5,12 +5,13 @@ import { resolveDefaultSpawnCliLaunchConfig, } from './spawn-cli-resolver.js';
 import { requireUiTokenFromRequest } from './ui-auth-helpers.js';
 import { getOrchestratorId } from './workspace-store-support.js';
 import { resolveWorkspaceUiLanguage, writeWorkspaceUiLanguage, } from './workspace-ui-language.js';
+const getRuntimePort = (request) => String(request.socket.localPort ?? '');
 export const scenarioRoutes = [
     /**
-     * One-click team assembly: materialize a scenario preset's workers (each
-     * inheriting the orchestrator's launch config) and hand the user's goal to
-     * the orchestrator as a normal user message. Deliberately NOT dispatching —
-     * splitting the goal and calling `team send` stays the orchestrator's job.
+     * One-click team assembly: materialize a scenario preset's members, start
+     * their PTYs, then hand the user's goal to the orchestrator as a normal user
+     * message. Deliberately NOT dispatching — splitting the goal and calling
+     * `team send` stays the orchestrator's job.
      */
     route('POST', '/api/workspaces/:workspaceId/scenarios/:scenarioId/apply', async ({ params, request, response, store }) => {
         const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Workspace id and scenario id are required');
@@ -35,13 +36,12 @@ export const scenarioRoutes = [
         }
         const language = resolveWorkspaceUiLanguage(store.settings, workspaceId, body.locale);
         writeWorkspaceUiLanguage(store.settings, workspaceId, language);
-        // The kickoff is delivered to the orchestrator's live terminal and is NOT
-        // persisted for replay, so an offline orchestrator would silently lose the
-        // goal. Gate up front: no live run, no team assembly.
+        // The kickoff must land in the orchestrator's live terminal. Gate up
+        // front so a stopped orchestrator never gets a half-created scenario.
         if (!store.getActiveRunByAgentId(workspaceId, getOrchestratorId(workspaceId))) {
             throw new ConflictError('Start the Orchestrator first — the scenario goal is handed to its terminal');
         }
-        const created = applyScenario(store, workspaceId, scenario, goal, undefined, language);
+        const created = await applyAndStartScenario(store, workspaceId, scenario, goal, getRuntimePort(request), undefined, language);
         sendJson(response, 201, {
             created_workers: created,
             injected: true,
@@ -51,7 +51,7 @@ export const scenarioRoutes = [
 /**
  * Materialize the scenario team and hand the goal to the orchestrator.
  * Exported for direct testing (the route harness has no PTY, so the
- * active-run gate above would mask this logic).
+ * active-run/start behavior would mask this logic).
  *
  * Workers derive a FRESH launch config from the orchestrator's CLI brand via
  * the same resolver `team spawn` uses — never a clone of the orchestrator's
@@ -62,7 +62,7 @@ export const scenarioRoutes = [
  * addWorkerWithLaunch is atomic, but a mid-loop failure (e.g. a name race)
  * leaves earlier workers in place and surfaces the error to the caller.
  */
-export const applyScenario = (store, workspaceId, scenario, goal, isCommandAvailable, language = 'en') => {
+const createScenarioWorkers = (store, workspaceId, scenario, isCommandAvailable, language = 'en') => {
     const ports = {
         getCommandPreset: (id) => store.settings.getCommandPreset(id),
         getOrchestratorLaunchConfig: () => store.peekAgentLaunchConfig(workspaceId, getOrchestratorId(workspaceId)),
@@ -72,7 +72,7 @@ export const applyScenario = (store, workspaceId, scenario, goal, isCommandAvail
     const takenNames = new Set(store.listWorkers(workspaceId).map((worker) => worker.name));
     const created = [];
     for (const spec of scenario.workers) {
-        const name = buildScenarioWorkerName(spec, (candidate) => takenNames.has(candidate));
+        const name = buildScenarioWorkerName(spec, takenNames, { language });
         takenNames.add(name);
         const description = spec.descriptionOverride !== undefined
             ? getScenarioWorkerDescription(spec, language)
@@ -84,11 +84,35 @@ export const applyScenario = (store, workspaceId, scenario, goal, isCommandAvail
         }, launchConfig);
         created.push({ id: worker.id, name: worker.name, role: spec.role });
     }
-    store.recordUserInput(workspaceId, getOrchestratorId(workspaceId), buildScenarioKickoffMessage({
-        scenarioId: scenario.id,
-        goal,
-        language,
-        workers: created.map((worker) => ({ name: worker.name, role: worker.role })),
-    }));
     return created;
 };
+const deliverScenarioKickoff = async (store, workspaceId, scenario, goal, language, created) => {
+    await store.deliverUserInput(workspaceId, getOrchestratorId(workspaceId), buildScenarioKickoffText(scenario, goal, language, created));
+};
+const buildScenarioKickoffText = (scenario, goal, language, created) => buildScenarioKickoffMessage({
+    scenarioId: scenario.id,
+    goal,
+    language,
+    workers: created.map((worker) => ({ name: worker.name, role: worker.role })),
+});
+const recordScenarioKickoff = (store, workspaceId, scenario, goal, language, created) => {
+    store.recordUserInput(workspaceId, getOrchestratorId(workspaceId), buildScenarioKickoffText(scenario, goal, language, created));
+};
+export const applyScenario = (store, workspaceId, scenario, goal, isCommandAvailable, language = 'en') => {
+    const created = createScenarioWorkers(store, workspaceId, scenario, isCommandAvailable, language);
+    recordScenarioKickoff(store, workspaceId, scenario, goal, language, created);
+    return created;
+};
+const startScenarioWorkers = async (store, workspaceId, hivePort, created) => Promise.all(created.map(async (worker) => {
+    const run = await store.startAgent(workspaceId, worker.id, { hivePort });
+    if (run.status === 'error') {
+        throw new ConflictError(`Failed to start scenario member: ${worker.name}`);
+    }
+    return { ...worker, start: { ok: true, run_id: run.runId } };
+}));
+export const applyAndStartScenario = async (store, workspaceId, scenario, goal, hivePort, isCommandAvailable, language = 'en') => {
+    const created = createScenarioWorkers(store, workspaceId, scenario, isCommandAvailable, language);
+    const started = await startScenarioWorkers(store, workspaceId, hivePort, created);
+    await deliverScenarioKickoff(store, workspaceId, scenario, goal, language, created);
+    return started;
+};

package/dist/src/server/scenario-presets.d.ts

@@ -3,11 +3,14 @@ import type { WorkerRole } from '../shared/types.js';
 import type { UiLanguage } from '../shared/ui-language.js';
 export { getScenarioPreset, getScenarioWorkerDescription, SCENARIO_PRESETS, type ScenarioId, type ScenarioPreset, type ScenarioWorkerSpec, } from '../shared/scenario-presets.js';
 /**
- * `<stem>-<4 base36 chars>` — short, `team send`-safe (no spaces, lowercase),
- * and unlikely to collide. The caller passes an `isTaken` probe against the
- * live roster; on the (rare) collision we just roll again.
+ * Scenario member names come from the same role-flavored historical-figure
+ * pool the Add Member dialog uses. When a pool is exhausted in a busy
+ * workspace, append a short suffix instead of failing the whole scenario.
  */
-export declare const buildScenarioWorkerName: (spec: Pick<ScenarioWorkerSpec, "nameStem">, isTaken: (name: string) => boolean, maxAttempts?: number) => string;
+export declare const buildScenarioWorkerName: (spec: Pick<ScenarioWorkerSpec, "nameStem" | "role">, usedNames: ReadonlySet<string>, input?: {
+    language?: UiLanguage;
+    nextUint32?: () => number;
+}, maxAttempts?: number) => string;
 export interface ScenarioKickoffInput {
     scenarioId: string;
     goal: string;

package/dist/src/server/scenario-presets.js

@@ -1,15 +1,25 @@
 import { randomBytes } from 'node:crypto';
+import { generateWorkerName } from '../shared/random-worker-name.js';
 export { getScenarioPreset, getScenarioWorkerDescription, SCENARIO_PRESETS, } from '../shared/scenario-presets.js';
 /**
- * `<stem>-<4 base36 chars>` — short, `team send`-safe (no spaces, lowercase),
- * and unlikely to collide. The caller passes an `isTaken` probe against the
- * live roster; on the (rare) collision we just roll again.
+ * Scenario member names come from the same role-flavored historical-figure
+ * pool the Add Member dialog uses. When a pool is exhausted in a busy
+ * workspace, append a short suffix instead of failing the whole scenario.
  */
-export const buildScenarioWorkerName = (spec, isTaken, maxAttempts = 16) => {
+export const buildScenarioWorkerName = (spec, usedNames, input = {}, maxAttempts = 16) => {
+    const candidate = generateWorkerName({
+        role: spec.role,
+        usedNames,
+        ...(input.language !== undefined ? { language: input.language } : {}),
+        ...(input.nextUint32 !== undefined ? { nextUint32: input.nextUint32 } : {}),
+    });
+    if (!usedNames.has(candidate))
+        return candidate;
+    const base = candidate || spec.nameStem;
     for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
         const suffix = randomBytes(3).readUIntBE(0, 3).toString(36).padStart(4, '0').slice(-4);
-        const name = `${spec.nameStem}-${suffix}`;
-        if (!isTaken(name))
+        const name = `${base}-${suffix}`;
+        if (!usedNames.has(name))
             return name;
     }
     throw new Error(`Could not generate a unique member name for: ${spec.nameStem}`);

package/dist/src/shared/random-worker-name.d.ts

@@ -0,0 +1,9 @@
+import type { WorkerRole } from './types.js';
+import type { UiLanguage } from './ui-language.js';
+export interface GenerateWorkerNameOptions {
+    language?: UiLanguage;
+    role?: WorkerRole;
+    usedNames?: ReadonlySet<string>;
+    nextUint32?: () => number;
+}
+export declare const generateWorkerName: ({ language, role, usedNames, nextUint32, }?: GenerateWorkerNameOptions) => string;