@tt-a1i/hive 1.7.0 → 2.0.2

package/dist/src/server/agent-manager-support.js

@@ -1,11 +1,47 @@
 import { execFile, execFileSync } from 'node:child_process';
+import { createRequire } from 'node:module';
+import { classifyCompletedRunStatus } from './agent-exit-classification.js';
 export const MAX_RUN_OUTPUT_LENGTH = 1_000_000;
 const FORCE_KILL_DELAY_MS = 750;
 const TASKKILL_TIMEOUT_MS = 3000;
 const PTY_READ_EOF_EXIT_GRACE_MS = 1000;
-const isPtyReadEofError = (error) => {
+const require = createRequire(import.meta.url);
+const childProcess = require('node:child_process');
+const isConptyConsoleListAgentPath = (modulePath) => {
+    const normalized = String(modulePath).replaceAll('\\', '/');
+    return (normalized.endsWith('/conpty_console_list_agent') ||
+        normalized.endsWith('/conpty_console_list_agent.js'));
+};
+export const withSilencedConptyConsoleListAgent = (platform, action) => {
+    if (platform !== 'win32')
+        return action();
+    const originalFork = childProcess.fork;
+    const patchedFork = (modulePath, argsOrOptions, options) => {
+        if (!isConptyConsoleListAgentPath(modulePath)) {
+            return Array.isArray(argsOrOptions)
+                ? originalFork.call(childProcess, modulePath, argsOrOptions, options)
+                : originalFork.call(childProcess, modulePath, argsOrOptions);
+        }
+        const forkOptions = Array.isArray(argsOrOptions) ? options : argsOrOptions;
+        const silentOptions = { ...(forkOptions ?? {}), silent: true };
+        const child = Array.isArray(argsOrOptions)
+            ? originalFork.call(childProcess, modulePath, argsOrOptions, silentOptions)
+            : originalFork.call(childProcess, modulePath, silentOptions);
+        child.stderr?.resume();
+        child.stdout?.resume();
+        return child;
+    };
+    childProcess.fork = patchedFork;
+    try {
+        return action();
+    }
+    finally {
+        childProcess.fork = originalFork;
+    }
+};
+const isPtyReadEofError = (error, platform = process.platform) => {
     const candidate = error;
-    return process.platform !== 'win32' && candidate?.code === 'EIO' && candidate.syscall === 'read';
+    return platform !== 'win32' && candidate?.code === 'EIO' && candidate.syscall === 'read';
 };
 const serializePtyInput = (input) => Buffer.isBuffer(input) ? input.toString('latin1') : input;
 const defaultExecRunner = (cmd, args, done) => {
@@ -71,17 +107,21 @@ export const toAgentRunSnapshot = (run) => ({
 export const finishAgentRun = (run, exitCode, ptyOutputBus) => {
     if (run.status === 'exited' || run.status === 'error')
         return;
-    run.status = exitCode === 0 ? 'exited' : 'error';
+    run.status = classifyCompletedRunStatus(exitCode);
     run.exitCode = exitCode;
-    run.onExit?.({ runId: run.runId, exitCode });
-    ptyOutputBus.clear(run.runId);
+    try {
+        run.onExit?.({ runId: run.runId, exitCode });
+    }
+    finally {
+        ptyOutputBus.clear(run.runId);
+    }
 };
-export const attachAgentPty = (run, pty, ptyOutputBus) => {
+export const attachAgentPty = (run, pty, ptyOutputBus, platform = process.platform, execRunner = defaultExecRunner) => {
     let stdinClosed = false;
     let forceKillTimer;
     let ptyReadEofTimer;
     const resolveProcessGroupId = () => {
-        if (process.platform === 'win32' || pty.pid <= 0)
+        if (platform === 'win32' || pty.pid <= 0)
             return null;
         try {
             const value = execFileSync('ps', ['-o', 'pgid=', '-p', String(pty.pid)], {
@@ -109,7 +149,7 @@ export const attachAgentPty = (run, pty, ptyOutputBus) => {
             throw error;
     };
     const killProcessGroup = (signal) => {
-        if (process.platform === 'win32' || processGroupId === null)
+        if (platform === 'win32' || processGroupId === null)
             return;
         try {
             process.kill(-processGroupId, signal);
@@ -120,14 +160,17 @@ export const attachAgentPty = (run, pty, ptyOutputBus) => {
     };
     const killPtyDirect = (signal) => {
         try {
-            pty.kill(signal);
+            if (platform === 'win32')
+                withSilencedConptyConsoleListAgent(platform, () => pty.kill());
+            else
+                pty.kill(signal);
         }
         catch (error) {
             ignoreMissingProcess(error);
         }
     };
     const killPty = (signal) => {
-        if (process.platform === 'win32') {
+        if (platform === 'win32') {
             // taskkill /pid <pid> /t /f walks the parent's process tree
             // BEFORE terminating it — so we have to run it while the parent
             // is still alive. Calling pty.kill() first (the previous
@@ -136,7 +179,7 @@ export const attachAgentPty = (run, pty, ptyOutputBus) => {
             // become orphans. taskkill /f also terminates the parent, so
             // pty.kill() is the fallback for the rare case where taskkill
             // is missing from PATH or refused (e.g. restricted PowerShell).
-            if (!taskkillProcessTree(pty.pid, process.platform, defaultExecRunner, () => killPtyDirect()))
+            if (!taskkillProcessTree(pty.pid, platform, execRunner, () => killPtyDirect()))
                 killPtyDirect();
         }
         else
@@ -185,11 +228,12 @@ export const attachAgentPty = (run, pty, ptyOutputBus) => {
         forceKillTimer = setTimeout(() => {
             forceKillTimer = undefined;
             try {
-                if (process.platform === 'win32') {
+                if (platform === 'win32') {
                     // Same ordering as killPty(): tree-kill before terminating the
                     // parent, so taskkill /T can still enumerate the process tree.
-                    // pty.kill() is the fallback for taskkill-missing hosts.
-                    if (!taskkillProcessTree(pty.pid, process.platform, defaultExecRunner, () => killPtyDirect()))
+                    // pty.kill() is the cleanup fallback for taskkill-missing hosts;
+                    // its noisy dependency helper is silenced in killPtyDirect().
+                    if (!taskkillProcessTree(pty.pid, platform, execRunner, () => killPtyDirect()))
                         killPtyDirect();
                 }
                 else
@@ -247,7 +291,7 @@ export const attachAgentPty = (run, pty, ptyOutputBus) => {
     pty.on?.('error', (error) => {
         if (stopped())
             return;
-        if (isPtyReadEofError(error)) {
+        if (isPtyReadEofError(error, platform)) {
             // Unix PTYs can surface a closed slave as read/EIO just before
             // node-pty delivers the real onExit event. Treat it as EOF, not
             // as the run's terminal status.

package/dist/src/server/agent-manager.d.ts

@@ -1,3 +1,4 @@
+import { type IWindowsPtyForkOptions } from 'node-pty';
 import { type PtyOutputBus } from './pty-output-bus.js';
 type RunStatus = 'starting' | 'running' | 'exited' | 'error';
 interface StartAgentInput {
@@ -45,6 +46,8 @@ interface AgentManager {
     removeRun: (runId: string) => void;
     stopRun: (runId: string) => void;
 }
+export declare const createSpawnEnv: (inputEnv?: NodeJS.ProcessEnv, platform?: NodeJS.Platform, parentEnv?: NodeJS.ProcessEnv) => NodeJS.ProcessEnv;
+export declare const buildAgentPtySpawnOptions: (cwd: string, env: NodeJS.ProcessEnv, platform?: NodeJS.Platform) => IWindowsPtyForkOptions;
 export declare const createAgentManager: ({ ptyOutputBus, }?: {
     ptyOutputBus?: PtyOutputBus;
 }) => AgentManager;

package/dist/src/server/agent-manager.js

@@ -4,14 +4,33 @@ import { resolveSpawnCommand } from './agent-command-resolver.js';
 import { attachAgentPty, toAgentRunSnapshot } from './agent-manager-support.js';
 import { createPtyOutputBus } from './pty-output-bus.js';
 const createRunId = () => randomUUID();
-const createSpawnEnv = (inputEnv) => {
-    const env = { ...process.env, ...inputEnv };
+const getWindowsEnvKey = (env, key) => {
+    if (Object.hasOwn(env, key))
+        return key;
+    return Object.keys(env)
+        .filter((item) => item.toLowerCase() === key.toLowerCase())
+        .at(-1);
+};
+export const createSpawnEnv = (inputEnv, platform = process.platform, parentEnv = process.env) => {
+    const env = { ...parentEnv };
+    for (const [key, value] of Object.entries(inputEnv ?? {})) {
+        const targetKey = platform === 'win32' ? (getWindowsEnvKey(env, key) ?? key) : key;
+        env[targetKey] = value;
+    }
     for (const key of Object.keys(env)) {
         if (env[key] === undefined)
             delete env[key];
     }
     return env;
 };
+export const buildAgentPtySpawnOptions = (cwd, env, platform = process.platform) => ({
+    cols: 80,
+    cwd,
+    env,
+    name: 'xterm-256color',
+    rows: 24,
+    ...(platform === 'win32' ? { useConpty: true } : {}),
+});
 export const createAgentManager = ({ ptyOutputBus = createPtyOutputBus(), } = {}) => {
     const runs = new Map();
     const getRunRecord = (runId) => {
@@ -54,11 +73,7 @@ export const createAgentManager = ({ ptyOutputBus = createPtyOutputBus(), } = {}
                 run.onExit = input.onExit;
             runs.set(runId, run);
             try {
-                attachAgentPty(run, spawn(spawnCommand.command, spawnCommand.args, {
-                    cwd: input.cwd,
-                    env,
-                    name: 'xterm-256color',
-                }), ptyOutputBus);
+                attachAgentPty(run, spawn(spawnCommand.command, spawnCommand.args, buildAgentPtySpawnOptions(input.cwd, env)), ptyOutputBus);
             }
             catch (error) {
                 runs.delete(runId);

package/dist/src/server/agent-run-bootstrap.d.ts

@@ -30,6 +30,7 @@ export declare const buildAgentRunBootstrap: (workspace: WorkspaceSummary, agent
             CODEX_HOME?: never;
             HIVE_GEMINI_HOME?: never;
             HIVE_OPENCODE_DB_PATH?: never;
+            HIVE_QWEN_HOME?: never;
         };
         knownSessionIds: Set<string>;
         root: string;
@@ -39,6 +40,7 @@ export declare const buildAgentRunBootstrap: (workspace: WorkspaceSummary, agent
             HIVE_CLAUDE_PROJECTS_DIR?: never;
             HIVE_GEMINI_HOME?: never;
             HIVE_OPENCODE_DB_PATH?: never;
+            HIVE_QWEN_HOME?: never;
         };
         knownSessionIds: Set<string>;
         root: string;
@@ -48,6 +50,7 @@ export declare const buildAgentRunBootstrap: (workspace: WorkspaceSummary, agent
             HIVE_CLAUDE_PROJECTS_DIR?: never;
             CODEX_HOME?: never;
             HIVE_OPENCODE_DB_PATH?: never;
+            HIVE_QWEN_HOME?: never;
         };
         knownSessionIds: Set<string>;
         root: string;
@@ -57,6 +60,17 @@ export declare const buildAgentRunBootstrap: (workspace: WorkspaceSummary, agent
             HIVE_CLAUDE_PROJECTS_DIR?: never;
             CODEX_HOME?: never;
             HIVE_GEMINI_HOME?: never;
+            HIVE_QWEN_HOME?: never;
+        };
+        knownSessionIds: Set<string>;
+        root: string;
+    } | {
+        env: {
+            HIVE_QWEN_HOME: string;
+            HIVE_CLAUDE_PROJECTS_DIR?: never;
+            CODEX_HOME?: never;
+            HIVE_GEMINI_HOME?: never;
+            HIVE_OPENCODE_DB_PATH?: never;
         };
         knownSessionIds: Set<string>;
         root: string;

package/dist/src/server/agent-run-bootstrap.js

@@ -1,6 +1,7 @@
 import { dirname, posix, resolve, sep, win32 } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { buildAgentLegacyIdentityMarker, buildAgentSessionBindingMarker, } from './agent-startup-instructions.js';
+import { getBuiltinCommandPresetByCommand } from './command-preset-defaults.js';
 import { withPresetResumeArgs } from './preset-launch-support.js';
 import { captureSessionIdForCapture, getSessionCaptureEnvironment, snapshotSessionIdsForCapture, } from './session-capture.js';
 const resolveHiveBinDir = () => {
@@ -12,6 +13,13 @@ const resolveHiveBinDir = () => {
 };
 const HIVE_BIN_DIR = resolveHiveBinDir();
 const SESSION_CAPTURE_TIMEOUT_MS = 30_000;
+const getWindowsEnvKey = (env, key) => {
+    if (Object.hasOwn(env, key))
+        return key;
+    return Object.keys(env)
+        .filter((item) => item.toLowerCase() === key.toLowerCase())
+        .at(-1);
+};
 /**
  * Builds a `{ <PATH-key>: <new-value> }` object for the spawn env override.
  * Critical on Windows: the OS env block reports PATH under its native casing
@@ -29,9 +37,7 @@ const SESSION_CAPTURE_TIMEOUT_MS = 30_000;
  * caller.
  */
 export const buildSpawnPathEnvEntry = (parentEnv, hiveBinDir, platform) => {
-    const existingKey = platform === 'win32'
-        ? Object.keys(parentEnv).find((key) => key.toLowerCase() === 'path')
-        : undefined;
+    const existingKey = platform === 'win32' ? getWindowsEnvKey(parentEnv, 'PATH') : undefined;
     const key = existingKey ?? 'PATH';
     const existingValue = existingKey ? parentEnv[existingKey] : parentEnv.PATH;
     // Target platform's delimiter — Windows uses `;`, POSIX `:` — independent
@@ -45,7 +51,8 @@ const resolveLaunchPreset = (config, getCommandPreset) => {
         return undefined;
     if (config.commandPresetId)
         return getCommandPreset(config.commandPresetId);
-    const implicitPreset = getCommandPreset(config.command);
+    const implicitBuiltin = getBuiltinCommandPresetByCommand(config.command);
+    const implicitPreset = getCommandPreset(implicitBuiltin?.id ?? config.command);
     if (!implicitPreset || implicitPreset.command !== config.command)
         return undefined;
     return {

package/dist/src/server/agent-run-exit-handler.js

@@ -1,6 +1,7 @@
+import { shouldClearResumedSessionOnExit } from './agent-exit-classification.js';
 import { completeLiveRun } from './agent-run-sync.js';
 const clearResumedSessionOnFailure = (context, exitCode) => {
-    if (exitCode !== 0 && context.startConfig.resumedSessionId) {
+    if (shouldClearResumedSessionOnExit(exitCode) && context.startConfig.resumedSessionId) {
         context.sessionStore.clearLastSessionId(context.workspace.id, context.agentId);
     }
 };
@@ -15,12 +16,17 @@ export const handleAgentRunExit = (context, { exitCode, endedAt, runId }) => {
         context.registry.clearPendingExitCode(runId);
         return false;
     }
-    completeLiveRun(liveRun, exitCode, endedAt, context.store);
-    clearResumedSessionOnFailure(context, exitCode);
     context.handledRunExits.add(runId);
-    context.tokenRegistry.revokeIfMatches(context.agentId, context.token);
-    context.onAgentExit(context.workspace.id, context.agentId);
-    context.registry.resolveExit(runId);
-    context.registry.clearPendingExitCode(runId);
-    return true;
+    try {
+        completeLiveRun(liveRun, exitCode, endedAt, context.store);
+        if (!liveRun.userStopped)
+            clearResumedSessionOnFailure(context, exitCode);
+        context.onAgentExit(context.workspace.id, context.agentId);
+        return true;
+    }
+    finally {
+        context.tokenRegistry.revokeIfMatches(context.agentId, context.token);
+        context.registry.resolveExit(runId);
+        context.registry.clearPendingExitCode(runId);
+    }
 };

package/dist/src/server/agent-run-starter.d.ts

@@ -9,6 +9,7 @@ import type { CommandPresetRecord } from './command-preset-store.js';
 import { type FeatureFlags } from './feature-flags.js';
 import type { LiveRunRegistry } from './live-run-registry.js';
 import type { RestartPolicy } from './restart-policy.js';
+import { type TeamMemoryInjectionService } from './team-memory-injection.js';
 interface AgentRunStarterInput {
     agentManager: AgentManager | undefined;
     registry: LiveRunRegistry;
@@ -23,6 +24,7 @@ interface AgentRunStarterInput {
      *  prompt (`workflowsEnabled` gates the `team workflow` line + authoring
      *  rule; `autostaffEnabled` gates the team-sizing rule). */
     getFlags?: () => FeatureFlags;
+    memoryInjection?: TeamMemoryInjectionService;
 }
-export declare const createAgentRunStarter: ({ agentManager, registry, onAgentExit, store, sessionStore, tokenRegistry, getCommandPreset, getAgent, restartPolicy, getFlags, }: AgentRunStarterInput) => (workspace: WorkspaceSummary, agentId: string, config: AgentLaunchConfigInput, hivePort: string) => Promise<LiveAgentRun>;
+export declare const createAgentRunStarter: ({ agentManager, registry, onAgentExit, store, sessionStore, tokenRegistry, getCommandPreset, getAgent, restartPolicy, getFlags, memoryInjection, }: AgentRunStarterInput) => (workspace: WorkspaceSummary, agentId: string, config: AgentLaunchConfigInput, hivePort: string) => Promise<LiveAgentRun>;
 export {};

package/dist/src/server/agent-run-starter.js

@@ -1,9 +1,11 @@
+import { classifyCompletedRunStatus, shouldClearResumedSessionOnExit, } from './agent-exit-classification.js';
 import { buildAgentRunBootstrap, startAgentRunCapture } from './agent-run-bootstrap.js';
 import { handleAgentRunExit } from './agent-run-exit-handler.js';
 import { buildAgentStartupInstructions } from './agent-startup-instructions.js';
 import { FEATURE_FLAGS_ALL_OFF } from './feature-flags.js';
 import { createPostStartInputWriter, isInteractiveAgentCommand } from './post-start-input-writer.js';
-export const createAgentRunStarter = ({ agentManager, registry, onAgentExit, store, sessionStore, tokenRegistry, getCommandPreset, getAgent, restartPolicy, getFlags, }) => async (workspace, agentId, config, hivePort) => {
+import { buildMemoryDigestSafely, logMemoryDigestInjection, rollbackMemoryDigestInjection, } from './team-memory-injection.js';
+export const createAgentRunStarter = ({ agentManager, registry, onAgentExit, store, sessionStore, tokenRegistry, getCommandPreset, getAgent, restartPolicy, getFlags, memoryInjection, }) => async (workspace, agentId, config, hivePort) => {
     if (!agentManager)
         throw new Error('Agent manager is required to start agents');
     const agent = getAgent?.(workspace.id, agentId);
@@ -74,8 +76,9 @@ export const createAgentRunStarter = ({ agentManager, registry, onAgentExit, sto
     registry.createExitEntry(run.runId);
     registry.add(liveRun);
     if (run.status === 'error') {
-        store.updatePersistedRun(run.runId, 'error', run.exitCode, Date.now());
-        if (startConfig.resumedSessionId) {
+        liveRun.status = classifyCompletedRunStatus(run.exitCode);
+        store.updatePersistedRun(run.runId, liveRun.status, run.exitCode, Date.now());
+        if (startConfig.resumedSessionId && shouldClearResumedSessionOnExit(run.exitCode)) {
             sessionStore.clearLastSessionId(workspace.id, agentId);
         }
         tokenRegistry.revokeIfMatches(agentId, token);
@@ -110,15 +113,29 @@ export const createAgentRunStarter = ({ agentManager, registry, onAgentExit, sto
                 workspace,
                 writeToRun: postStartWriter,
             });
-            if (!startConfig.resumedSessionId &&
-                !injectedRestartMessage &&
+            if (!injectedRestartMessage &&
                 agent &&
                 isInteractiveAgentCommand(startConfig.interactiveCommand ?? startConfig.command)) {
+                const memoryDigest = buildMemoryDigestSafely({
+                    contextType: 'startup',
+                    memoryInjection,
+                    workspaceId: workspace.id,
+                });
+                const injectionIds = logMemoryDigestInjection({
+                    agentId,
+                    contextType: 'startup',
+                    memoryDigest,
+                    memoryInjection,
+                    workspaceId: workspace.id,
+                });
+                const auditedMemoryDigest = injectionIds ? memoryDigest : null;
                 void postStartWriter(run.runId, buildAgentStartupInstructions({
                     agent,
+                    memoryDigest: auditedMemoryDigest?.text,
                     workspace,
                     flags: getFlags?.() ?? FEATURE_FLAGS_ALL_OFF,
                 })).catch(() => {
+                    rollbackMemoryDigestInjection({ injectionIds, memoryInjection });
                     // The agent may have exited before post-start guidance could be written.
                 });
             }

package/dist/src/server/agent-run-sync.js

@@ -1,24 +1,32 @@
+import { classifyCompletedRunStatus } from './agent-exit-classification.js';
 const MAX_RUN_OUTPUT_LENGTH = 1_000_000;
 const toPersistedStatus = (run) => {
+    if ('userStopped' in run &&
+        run.userStopped === true &&
+        (run.status === 'error' || run.status === 'exited')) {
+        return 'exited';
+    }
     if (run.status === 'error' || run.status === 'exited' || run.status === 'starting') {
         return run.status;
     }
-    return run.exitCode === null ? 'running' : run.exitCode === 0 ? 'exited' : 'error';
+    return run.exitCode === null ? 'running' : classifyCompletedRunStatus(run.exitCode);
 };
 export const syncPersistedRun = (run, snapshot, store) => {
-    const nextStatus = toPersistedStatus(snapshot);
+    const nextStatus = toPersistedStatus(run.userStopped ? { ...snapshot, userStopped: true } : snapshot);
     const output = snapshot.output.slice(-MAX_RUN_OUTPUT_LENGTH);
     if (run.status === nextStatus && run.exitCode === snapshot.exitCode && run.output === output) {
         return run;
     }
+    const endedAt = nextStatus === 'exited' || nextStatus === 'error' ? Date.now() : null;
+    store.updatePersistedRun(run.runId, nextStatus, snapshot.exitCode, endedAt);
     run.status = nextStatus;
     run.output = output;
     run.exitCode = snapshot.exitCode;
-    store.updatePersistedRun(run.runId, nextStatus, snapshot.exitCode, nextStatus === 'exited' || nextStatus === 'error' ? Date.now() : null);
     return run;
 };
 export const completeLiveRun = (run, exitCode, endedAt, store) => {
-    run.status = exitCode === 0 ? 'exited' : 'error';
+    const nextStatus = run.userStopped ? 'exited' : classifyCompletedRunStatus(exitCode);
+    store.updatePersistedRun(run.runId, nextStatus, exitCode, endedAt);
+    run.status = nextStatus;
     run.exitCode = exitCode;
-    store.updatePersistedRun(run.runId, run.status, exitCode, endedAt);
 };

package/dist/src/server/agent-runtime-types.d.ts

@@ -1,4 +1,5 @@
 import type { AgentRunSnapshot } from './agent-manager.js';
 export interface LiveAgentRun extends AgentRunSnapshot {
     startedAt: number;
+    userStopped?: boolean;
 }

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

@@ -5,5 +5,6 @@ import type { AgentRunStorePort, AgentSessionStorePort } from './agent-runtime-p
 import type { CommandPresetRecord } from './command-preset-store.js';
 import type { FeatureFlags } from './feature-flags.js';
 import { type RestartPolicy } from './restart-policy.js';
-export declare const createAgentRuntime: (agentManager: AgentManager | undefined, agentRunStore: AgentRunStorePort, sessionStore: AgentSessionStorePort, getCommandPreset: (id: string) => CommandPresetRecord | undefined, onAgentExit: (workspaceId: string, agentId: string) => void, restartPolicy?: RestartPolicy, getAgent?: (workspaceId: string, agentId: string) => AgentSummary | undefined, getFlags?: () => FeatureFlags) => AgentRuntime;
+import type { TeamMemoryInjectionService } from './team-memory-injection.js';
+export declare const createAgentRuntime: (agentManager: AgentManager | undefined, agentRunStore: AgentRunStorePort, sessionStore: AgentSessionStorePort, getCommandPreset: (id: string) => CommandPresetRecord | undefined, onAgentExit: (workspaceId: string, agentId: string) => void, restartPolicy?: RestartPolicy, getAgent?: (workspaceId: string, agentId: string) => AgentSummary | undefined, getFlags?: () => FeatureFlags, memoryInjection?: TeamMemoryInjectionService) => AgentRuntime;
 export type { AgentRuntime };

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

@@ -10,7 +10,7 @@ import { createAgentStdinDispatcher } from './agent-stdin-dispatcher.js';
 import { createAgentTokenRegistry } from './agent-tokens.js';
 import { createLiveRunRegistry } from './live-run-registry.js';
 import { createNoopRestartPolicy } from './restart-policy.js';
-export const createAgentRuntime = (agentManager, agentRunStore, sessionStore, getCommandPreset, onAgentExit, restartPolicy = createNoopRestartPolicy(), getAgent, getFlags) => {
+export const createAgentRuntime = (agentManager, agentRunStore, sessionStore, getCommandPreset, onAgentExit, restartPolicy = createNoopRestartPolicy(), getAgent, getFlags, memoryInjection) => {
     const registry = createLiveRunRegistry();
     const launchCache = createAgentLaunchCache(agentRunStore);
     const tokenRegistry = createAgentTokenRegistry();
@@ -30,6 +30,7 @@ export const createAgentRuntime = (agentManager, agentRunStore, sessionStore, ge
         registry,
         syncRun,
         ...(getFlags ? { getFlags } : {}),
+        ...(memoryInjection ? { memoryInjection } : {}),
     });
     const startLiveRun = createAgentRunStarter({
         agentManager,
@@ -42,6 +43,7 @@ export const createAgentRuntime = (agentManager, agentRunStore, sessionStore, ge
         getAgent,
         restartPolicy,
         ...(getFlags ? { getFlags } : {}),
+        ...(memoryInjection ? { memoryInjection } : {}),
     });
     return {
         async close() {
@@ -105,7 +107,12 @@ export const createAgentRuntime = (agentManager, agentRunStore, sessionStore, ge
             return startPromise;
         },
         stopAgentRun(runId) {
-            stopLiveRun(agentManager, registry, syncRun, runId, (stoppedRunId) => restartPolicy.markUserStopped(stoppedRunId));
+            stopLiveRun(agentManager, registry, syncRun, runId, (stoppedRunId) => {
+                const liveRun = registry.get(stoppedRunId);
+                if (liveRun)
+                    liveRun.userStopped = true;
+                restartPolicy.markUserStopped(stoppedRunId);
+            });
         },
         validateAgentToken: tokenRegistry.validate,
         writeReportPrompt(workspaceId, workerName, _workerId, text, artifacts, input = {}) {

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

@@ -8,8 +8,9 @@ export declare const buildAgentLegacyIdentityMarker: ({ agent, workspace, }: {
     agent: AgentSummary;
     workspace: WorkspaceSummary;
 }) => string;
-export declare const buildAgentStartupInstructions: ({ agent, workspace, flags, }: {
+export declare const buildAgentStartupInstructions: ({ agent, memoryDigest, workspace, flags, }: {
     agent: AgentSummary;
+    memoryDigest?: string | null | undefined;
     workspace: WorkspaceSummary;
     /** Live experimental flags. `workflowsEnabled` gates the `team workflow`
      *  command line + the workflow-authoring rule (so a fresh orchestrator isn't

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

@@ -1,9 +1,10 @@
+import { BUILTIN_COMMAND_PRESET_CLI_LIST } from './command-preset-defaults.js';
 import { FEATURE_FLAGS_ALL_OFF } from './feature-flags.js';
 import { getHiveTeamRules } from './hive-team-guidance.js';
 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 ${agent.name} (${agent.role}) in workspace ${workspace.name}.`;
-export const buildAgentStartupInstructions = ({ agent, workspace, flags = FEATURE_FLAGS_ALL_OFF, }) => {
+export const buildAgentStartupInstructions = ({ agent, memoryDigest, workspace, flags = FEATURE_FLAGS_ALL_OFF, }) => {
     const { workflowsEnabled } = flags;
     const lines = [
         '<hive-message kind="startup">',
@@ -18,15 +19,18 @@ export const buildAgentStartupInstructions = ({ agent, workspace, flags = FEATUR
         `Your role: ${agent.description}`,
         '',
     ];
+    if (memoryDigest) {
+        lines.push(memoryDigest, '');
+    }
     if (agent.role === 'orchestrator') {
-        lines.push('Your responsibilities:', '- Respond to the user directly; clarify the goal and break it into dispatchable tasks', `- Maintain ${TASKS_RELATIVE_PATH}`, '- Dispatch by worker name and drive the next step from each report', '', 'Available team commands:', '- team list', '- team send "<worker-name>" "<task>"', '- team spawn <role> [--name <n>] [--cli claude|codex|opencode|gemini|hermes] [--ephemeral]', '- team cancel --dispatch <id> "<reason>"', ...(workflowsEnabled
+        lines.push('Your responsibilities:', '- Respond to the user directly; clarify the goal and break it into dispatchable tasks', `- Maintain ${TASKS_RELATIVE_PATH}`, '- Dispatch by worker name and drive the next step from each report', '', 'Available team commands:', '- team list', '- team recall "<query>" [--limit <n>] [--window <n>]', '- team memory add "<body>" [--kind fact|preference|decision|pitfall|procedure_ref] [--tag <tag>]', '- team memory show <memory-id>', '- team memory search "<query>" [--limit <n>]', '- team memory forget <memory-id>', '- team send "<worker-name>" "<task>"', `- team spawn <role> [--name <n>] [--cli <${BUILTIN_COMMAND_PRESET_CLI_LIST}>] [--ephemeral]`, '- team cancel --dispatch <id> "<reason>"', ...(workflowsEnabled
             ? [
                 '- team workflow run --stdin   (fan-out / staged work — see .hive/PROTOCOL.md for the DSL)',
             ]
-            : []), '', 'Always dispatch by worker name, never by worker id.', 'Always cancel an open dispatch by its dispatch id.', '', 'Hive worker dispatch rules:', ...getHiveTeamRules(agent, flags));
+            : []), '', 'Always dispatch by worker name, never by worker id.', 'Always cancel an open dispatch by its dispatch id.', 'Search memory before adding: use `team memory search "<query>"` to avoid duplicates.', 'Use `team memory add` only for rare, evidence-backed workspace facts/decisions/pitfalls that should help future Hive agents across sessions.', 'Nothing worth saving is a normal outcome; do not add memory just to prove you used it.', 'Use `team memory forget` only to archive obsolete workspace memory; it does not physically delete evidence.', '', 'Hive worker dispatch rules:', ...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>]                       mid-task progress / standby / connected status', '- team status --stdin [--artifact <path>]                         same, body read from stdin', '- team list                                                       list the workspace workers (with status)', '- team --help                                                     command syntax only; NOT a way to report', '', '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`). `--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.', '', 'When a task is done you MUST run `team report "<result>"`.', 'Failure, blocked, or partial completion are also reported with `team report "<current state and reason>"`.', 'When no task is in progress, report connection / standby / blocked state with `team status "<state>"`.', 'Do not call team send; workers cannot dispatch to each other.', '', 'Hive worker boundaries:', ...getHiveTeamRules(agent, flags));
+        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>]                       mid-task progress / standby / connected status', '- 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 list                                                       list the workspace workers (with status)', '- team --help                                                     command syntax only; NOT a way to report', '', '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.', '', 'When a task is done you MUST run `team report "<result>"`.', 'Failure, blocked, or partial completion are also reported with `team report "<current state and reason>"`.', 'When no task is in progress, report connection / standby / blocked state with `team status "<state>"`.', 'Use `team recall "<query>"` when prior team messages or reports may contain useful evidence.', 'Use `team memory search "<query>"` to look up active durable workspace memory.', 'Include durable findings in `team report`; workers cannot add or forget memory.', 'Do not call team send; workers cannot dispatch to each other.', '', 'Hive worker boundaries:', ...getHiveTeamRules(agent, flags));
     }
     lines.push('', '</hive-message>', '');
     return lines.join('\n');

package/dist/src/server/agent-stdin-dispatcher.d.ts

@@ -3,12 +3,14 @@ import type { AgentLaunchConfigInput } from './agent-run-store.js';
 import type { LiveAgentRun } from './agent-runtime-types.js';
 import { type FeatureFlags } from './feature-flags.js';
 import type { LiveRunRegistry } from './live-run-registry.js';
+import { type TeamMemoryInjectionService } from './team-memory-injection.js';
 interface AgentStdinDispatcherInput {
     agentManager: AgentManager | undefined;
     getLaunchConfig: (workspaceId: string, agentId: string) => AgentLaunchConfigInput | undefined;
     getWorkspaceId: (agentId: string) => string | undefined;
     registry: LiveRunRegistry;
     syncRun: (run: LiveAgentRun) => LiveAgentRun;
+    memoryInjection?: TeamMemoryInjectionService;
     /** Resolves the live experimental flags. The orchestrator reminder tail
      *  appended to every injected message reads `workflowsEnabled` from it.
      *  Optional; omitted → all flags off. */
@@ -17,9 +19,9 @@ interface AgentStdinDispatcherInput {
 export declare const buildOrchestratorReportPayload: (workerName: string, text: string, artifacts: string[], flags?: FeatureFlags) => string;
 export declare const buildOrchestratorStatusPayload: (workerName: string, text: string, artifacts: string[], flags?: FeatureFlags) => string;
 export declare const buildOrchestratorUserInputPayload: (text: string, flags?: FeatureFlags) => string;
-export declare const buildWorkerDispatchPayload: (fromAgentName: string, workerDescription: string, dispatchId: string, text: string) => string;
+export declare const buildWorkerDispatchPayload: (fromAgentName: string, workerDescription: string, dispatchId: string, text: string, memoryDigest?: string | null) => string;
 export declare const buildWorkerCancelPayload: (dispatchId: string, reason: string) => string;
-export declare const createAgentStdinDispatcher: ({ agentManager, getLaunchConfig, getWorkspaceId, registry, syncRun, getFlags, }: AgentStdinDispatcherInput) => {
+export declare const createAgentStdinDispatcher: ({ agentManager, getLaunchConfig, getWorkspaceId, registry, syncRun, memoryInjection, getFlags, }: AgentStdinDispatcherInput) => {
     writeReportPrompt(workspaceId: string, workerName: string, text: string, artifacts: string[], input?: {
         requireActiveRun?: boolean;
     }): void;