npm - @tt-a1i/hive - Versions diffs - 2.1.4 → 2.1.6 - Mend

@tt-a1i/hive 2.1.4 → 2.1.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (71) hide show

package/CHANGELOG.md CHANGED Viewed

@@ -2,6 +2,37 @@
 All notable user-facing changes will be documented in this file.
+## 2.1.6 - 2026-06-21
+Team UX polish and release visibility.
+- Adds a global package-update prompt so running Hive can surface a newer npm
+  version without relying only on the topbar badge.
+- Makes worker startup handshakes explicit: newly started members now report a
+  ready status back to the Orchestrator after receiving Hive's injected startup
+  instructions, making failed starts easier to distinguish from idle workers.
+- Removes the Orchestrator pane stop button from the UI so users cannot
+  accidentally close the central coordinator from the pane chrome.
+- Reworks the Action Center entry into a dedicated drawer with live workspace
+  health, attention, recent activity, and worker selection instead of the old
+  compact popover.
+## 2.1.5 - 2026-06-21
+Ambient memory reliability and background consolidation.
+- Makes team memory quieter and more automatic by removing the visible
+  candidate-review surface from the Memory drawer while keeping active,
+  archived, and Dream audit history available when you look for it.
+- Adds user-scoped memory for lightweight personal preferences and working
+  style, without mixing those preferences into workspace project facts.
+- Adds structured procedure references so workflows, skills, and checklists can
+  be recalled as short references instead of long copied instructions.
+- Improves dispatch memory retrieval so unrelated worker-role matches do not
+  inject stale or cross-task memory into a new assignment.
+- Moves scheduled Dream consolidation into a background apply path with
+  transaction checks, source-window validation, failure isolation, and revert.
 ## 2.1.4 - 2026-06-21
 Quieter onboarding and team activity signals.

package/dist/src/cli/team.d.ts CHANGED Viewed

@@ -1,4 +1,4 @@
-import { type MemoryKind } from '../shared/team-memory.js';
+import { type MemoryKind, type MemoryProcedureRef, type MemoryScope } from '../shared/team-memory.js';
 interface ParsedCancelArgs {
     dispatchId: string;
     reason: string;
@@ -19,6 +19,8 @@ export declare const parseRecallArgs: (args: string[]) => {
 export interface ParsedMemoryAddArgs {
     body: string;
     kind: MemoryKind;
+    procedureRef: MemoryProcedureRef | null;
+    scope: MemoryScope;
     tags: string[];
 }
 export declare const parseMemoryAddArgs: (args: string[]) => ParsedMemoryAddArgs;
@@ -26,6 +28,7 @@ export declare const parseMemoryShowArgs: (args: string[]) => {
     memoryId: string;
 };
 export declare const parseMemorySearchArgs: (args: string[]) => {
+    scope: "workspace" | "user" | "all";
     limit?: number;
     query: string;
 };

package/dist/src/cli/team.js CHANGED Viewed

@@ -1,7 +1,7 @@
 import { fileURLToPath } from 'node:url';
 import { BUILTIN_COMMAND_PRESET_CLI_LIST } from '../server/command-preset-defaults.js';
 import { sameFilesystemPath } from '../server/path-canonicalization.js';
-import { isMemoryKind, MEMORY_BODY_MAX_CHARS, MEMORY_KINDS, MEMORY_QUERY_MAX_CHARS, MEMORY_SEARCH_MAX_LIMIT, MEMORY_TAG_MAX_CHARS, MEMORY_TAG_MAX_COUNT, } from '../shared/team-memory.js';
+import { isMemoryKind, isMemoryProcedureRefType, isMemoryScope, MEMORY_BODY_MAX_CHARS, MEMORY_KINDS, MEMORY_PROCEDURE_REF_ID_MAX_CHARS, MEMORY_PROCEDURE_REF_TITLE_MAX_CHARS, MEMORY_PROCEDURE_REF_TYPES, MEMORY_QUERY_MAX_CHARS, MEMORY_SCOPES, MEMORY_SEARCH_MAX_LIMIT, MEMORY_TAG_MAX_CHARS, MEMORY_TAG_MAX_COUNT, } from '../shared/team-memory.js';
 import { RECALL_QUERY_MAX_CHARS } from '../shared/team-recall.js';
 const REQUIRED_ENV_KEYS = [
     'HIVE_PORT',
@@ -14,9 +14,9 @@ const TEAM_USAGE = [
     '  team list',
     '  team next   (tasks in .hive/tasks.md that are unblocked now — those whose [needs: #n] deps are all done)',
     '  team recall "<query>" [--limit <n>] [--window <n>]',
-    '  team memory add "<body>" [--kind fact|preference|decision|pitfall|procedure_ref] [--tag <tag>]',
+    '  team memory add "<body>" [--kind fact|preference|decision|pitfall|procedure_ref] [--scope workspace|user] [--tag <tag>] [--ref-type workflow|skill|procedure|template|doc --ref-id <id> [--ref-title <title>]]',
     '  team memory show <memory-id>',
-    '  team memory search "<query>" [--limit <n>]',
+    '  team memory search "<query>" [--limit <n>] [--scope workspace|user|all]',
     '  team memory dream show <dream-run-id>',
     '  team memory apply --run <dream-run-id> --stdin',
     '  team memory forget <memory-id>',
@@ -107,9 +107,9 @@ const REPORT_USAGE = 'Usage: team report (<result> | --stdin) [--dispatch <dispa
 const STATUS_USAGE = 'Usage: team status (<current status> | --stdin) [--artifact <path>]';
 const CANCEL_USAGE = 'Usage: team cancel --dispatch <dispatch-id> <reason>';
 const RECALL_USAGE = 'Usage: team recall "<query>" [--limit <n>] [--window <n>]';
-const MEMORY_ADD_USAGE = 'Usage: team memory add "<body>" [--kind fact|preference|decision|pitfall|procedure_ref] [--tag <tag>]';
+const MEMORY_ADD_USAGE = 'Usage: team memory add "<body>" [--kind fact|preference|decision|pitfall|procedure_ref] [--scope workspace|user] [--tag <tag>] [--ref-type workflow|skill|procedure|template|doc --ref-id <id> [--ref-title <title>]]';
 const MEMORY_SHOW_USAGE = 'Usage: team memory show <memory-id>';
-const MEMORY_SEARCH_USAGE = 'Usage: team memory search "<query>" [--limit <n>]';
+const MEMORY_SEARCH_USAGE = 'Usage: team memory search "<query>" [--limit <n>] [--scope workspace|user|all]';
 const MEMORY_DREAM_SHOW_USAGE = 'Usage: team memory dream show <dream-run-id>';
 const MEMORY_APPLY_USAGE = 'Usage: team memory apply --run <dream-run-id> --stdin';
 const MEMORY_FORGET_USAGE = 'Usage: team memory forget <memory-id>';
@@ -256,6 +256,10 @@ export const parseMemoryAddArgs = (args) => {
     const positionals = [];
     const tags = [];
     let kind = 'fact';
+    let procedureRefId;
+    let procedureRefTitle = null;
+    let procedureRefType;
+    let scope = 'workspace';
     for (let index = 0; index < args.length; index += 1) {
         const arg = args[index];
         if (arg === undefined)
@@ -272,6 +276,58 @@ export const parseMemoryAddArgs = (args) => {
             index += 1;
             continue;
         }
+        if (arg === '--scope') {
+            const next = args[index + 1];
+            if (next === undefined || next.startsWith('--')) {
+                throw new Error(`--scope requires a value\n\n${MEMORY_ADD_USAGE}`);
+            }
+            if (!isMemoryScope(next)) {
+                throw new Error(`--scope must be one of: ${MEMORY_SCOPES.join(', ')}\n\n${MEMORY_ADD_USAGE}`);
+            }
+            scope = next;
+            index += 1;
+            continue;
+        }
+        if (arg === '--ref-type') {
+            const next = args[index + 1];
+            if (next === undefined || next.startsWith('--')) {
+                throw new Error(`--ref-type requires a value\n\n${MEMORY_ADD_USAGE}`);
+            }
+            if (!isMemoryProcedureRefType(next)) {
+                throw new Error(`--ref-type must be one of: ${MEMORY_PROCEDURE_REF_TYPES.join(', ')}\n\n${MEMORY_ADD_USAGE}`);
+            }
+            procedureRefType = next;
+            index += 1;
+            continue;
+        }
+        if (arg === '--ref-id') {
+            const next = args[index + 1];
+            if (next === undefined || next.startsWith('--')) {
+                throw new Error(`--ref-id requires a value\n\n${MEMORY_ADD_USAGE}`);
+            }
+            const refId = next.trim();
+            if (!refId)
+                throw new Error(`--ref-id requires a non-empty value\n\n${MEMORY_ADD_USAGE}`);
+            if ([...refId].length > MEMORY_PROCEDURE_REF_ID_MAX_CHARS) {
+                throw new Error(`--ref-id must be ${MEMORY_PROCEDURE_REF_ID_MAX_CHARS} characters or fewer\n\n${MEMORY_ADD_USAGE}`);
+            }
+            procedureRefId = refId;
+            index += 1;
+            continue;
+        }
+        if (arg === '--ref-title') {
+            const next = args[index + 1];
+            if (next === undefined || next.startsWith('--')) {
+                throw new Error(`--ref-title requires a value\n\n${MEMORY_ADD_USAGE}`);
+            }
+            const refTitle = next.trim();
+            if ([...refTitle].length > MEMORY_PROCEDURE_REF_TITLE_MAX_CHARS) {
+                throw new Error(`--ref-title must be ${MEMORY_PROCEDURE_REF_TITLE_MAX_CHARS} characters or fewer\n\n${MEMORY_ADD_USAGE}`);
+            }
+            procedureRefTitle = refTitle || null;
+            index += 1;
+            continue;
+        }
         if (arg === '--tag') {
             const next = args[index + 1];
             if (next === undefined || next.startsWith('--')) {
@@ -307,7 +363,23 @@ export const parseMemoryAddArgs = (args) => {
     if ([...body].length > MEMORY_BODY_MAX_CHARS) {
         throw new Error(`body must be ${MEMORY_BODY_MAX_CHARS} characters or fewer\n\n${MEMORY_ADD_USAGE}`);
     }
-    return { body, kind, tags };
+    if ((procedureRefType || procedureRefId || procedureRefTitle) &&
+        (!procedureRefType || !procedureRefId)) {
+        throw new Error(`--ref-type and --ref-id must be provided together\n\n${MEMORY_ADD_USAGE}`);
+    }
+    const procedureRef = procedureRefType && procedureRefId
+        ? { id: procedureRefId, title: procedureRefTitle, type: procedureRefType }
+        : null;
+    if (kind === 'procedure_ref' && !procedureRef) {
+        throw new Error(`--kind procedure_ref requires --ref-type and --ref-id\n\n${MEMORY_ADD_USAGE}`);
+    }
+    return {
+        body,
+        kind,
+        procedureRef,
+        scope,
+        tags,
+    };
 };
 export const parseMemoryShowArgs = (args) => {
     if (args.length !== 1 || !args[0] || args[0].startsWith('--')) {
@@ -318,6 +390,7 @@ export const parseMemoryShowArgs = (args) => {
 export const parseMemorySearchArgs = (args) => {
     const positionals = [];
     let limit;
+    let scope = 'workspace';
     for (let index = 0; index < args.length; index += 1) {
         const arg = args[index];
         if (arg === undefined)
@@ -335,6 +408,18 @@ export const parseMemorySearchArgs = (args) => {
             index += 1;
             continue;
         }
+        if (arg === '--scope') {
+            const next = args[index + 1];
+            if (next === undefined || next.startsWith('--')) {
+                throw new Error(`--scope requires a value\n\n${MEMORY_SEARCH_USAGE}`);
+            }
+            if (next !== 'all' && !isMemoryScope(next)) {
+                throw new Error(`--scope must be workspace, user, or all\n\n${MEMORY_SEARCH_USAGE}`);
+            }
+            scope = next;
+            index += 1;
+            continue;
+        }
         if (arg.startsWith('--')) {
             throw new Error(`Unknown argument: ${arg}\n\n${MEMORY_SEARCH_USAGE}`);
         }
@@ -353,6 +438,7 @@ export const parseMemorySearchArgs = (args) => {
     return {
         query,
         ...(limit !== undefined ? { limit } : {}),
+        scope,
     };
 };
 export const parseMemoryDreamShowArgs = (args) => {
@@ -515,6 +601,8 @@ export const runTeamCommand = async (argv) => {
                 token: env.HIVE_AGENT_TOKEN,
                 body: memory.body,
                 kind: memory.kind,
+                procedure_ref: memory.procedureRef,
+                scope: memory.scope,
                 tags: memory.tags,
             });
             console.log(JSON.stringify(await response.json()));
@@ -541,6 +629,7 @@ export const runTeamCommand = async (argv) => {
                 token: env.HIVE_AGENT_TOKEN,
                 query: memory.query,
                 ...(memory.limit !== undefined ? { limit: memory.limit } : {}),
+                scope: memory.scope,
             });
             console.log(JSON.stringify(await response.json()));
             return;

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

@@ -8,6 +8,7 @@ export declare const buildAgentLegacyIdentityMarker: ({ agent, workspace, }: {
     agent: AgentSummary;
     workspace: WorkspaceSummary;
 }) => string;
+export declare const WORKER_STARTUP_READY_STATUS = "ready: startup prompt received; Hive CLI channel OK; waiting for dispatch.";
 export declare const buildAgentStartupInstructions: ({ agent, memoryDigest, workspace, flags, }: {
     agent: AgentSummary;
     memoryDigest?: string | null | undefined;

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

@@ -5,6 +5,7 @@ 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 ${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 buildAgentStartupInstructions = ({ agent, memoryDigest, workspace, flags = FEATURE_FLAGS_ALL_OFF, }) => {
     const { workflowsEnabled } = flags;
     const lines = [
@@ -24,7 +25,7 @@ export const buildAgentStartupInstructions = ({ agent, memoryDigest, workspace,
         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} (GFM task list; mark dependencies with a trailing \`[needs: #2, #5]\` — 1-based positions; \`team next\` lists the tasks unblocked right now)`, '- Dispatch by worker name and drive the next step from each report', '', 'Available team commands:', '- team list', '- team next', '- 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 dream show <dream-run-id>', '- team memory apply --run <dream-run-id> --stdin', '- team memory forget <memory-id>', '- team send "<worker-name>" "<task>"', `- team spawn <role> [--name <n>] [--cli <${BUILTIN_COMMAND_PRESET_CLI_LIST}>] [--ephemeral]`, '- team dismiss <worker-name>', '- 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} (GFM task list; mark dependencies with a trailing \`[needs: #2, #5]\` — 1-based positions; \`team next\` lists the tasks unblocked right now)`, '- Dispatch by worker name and drive the next step from each report', '', 'Available team commands:', '- team list', '- team next', '- team recall "<query>" [--limit <n>] [--window <n>]', '- team memory add "<body>" [--kind fact|preference|decision|pitfall|procedure_ref] [--scope workspace|user] [--tag <tag>] [--ref-type workflow|skill|procedure|template|doc --ref-id <id> [--ref-title <title>]]', '- team memory show <memory-id>', '- team memory search "<query>" [--limit <n>] [--scope workspace|user|all]', '- team memory dream show <dream-run-id>', '- team memory apply --run <dream-run-id> --stdin', '- team memory forget <memory-id>', '- team send "<worker-name>" "<task>"', `- team spawn <role> [--name <n>] [--cli <${BUILTIN_COMMAND_PRESET_CLI_LIST}>] [--ephemeral]`, '- team dismiss <worker-name>', '- team cancel --dispatch <id> "<reason>"', ...(workflowsEnabled
             ? [
                 '- team workflow run --stdin   (fan-out / staged work — see .hive/PROTOCOL.md for the DSL)',
             ]
@@ -37,7 +38,7 @@ 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', '', '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 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>]                       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 worker boundaries:', ...getHiveTeamRules(agent, flags));
     }
     lines.push('', '</hive-message>', '');
     return lines.join('\n');

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

@@ -105,7 +105,7 @@ const WORKER_RULES = [
     'When an assigned task is done, blocked, or has failed, you MUST report to the Orchestrator with `team report`.',
     'Assume no one is watching your terminal: the user converses with the Orchestrator, not with you. Never stop to wait for terminal input — if you need a decision or are missing information, `team report` the question as blocked and let the Orchestrator decide.',
     'If you never report, your status stays `working` forever (Hive has no timeout detection) and your work counts as not done.',
-    '`team status` may be sent at any time (mid-task progress or standby); it NEVER closes a dispatch — only `team report` (or an orchestrator `team cancel`) does.',
+    '`team status` may be sent at startup or any time afterward (ready / progress / standby); it NEVER closes a dispatch — only `team report` (or an orchestrator `team cancel`) does.',
     'Use `team recall "<query>"` when prior team messages or reports may contain useful evidence.',
     'Use `team memory search "<query>"` to inspect active workspace memory. Include durable findings in `team report`. If the Orchestrator explicitly assigns Dream review, you may run `team memory dream show <dream-run-id>` and propose ops in `team report`; workers cannot apply, add, or forget memory.',
     '`team --help` only prints command syntax — it is NOT a way to report; its output never reaches the Orchestrator. You still owe a real `team report` / `team status` afterward.',
@@ -320,9 +320,9 @@ export const buildProtocolDoc = (cliPolicy = DEFAULT_WORKFLOW_CLI_POLICY, flags
         '- `team list` — show workspace members and their status; each worker lists its open dispatches (id, age, queued/submitted) — use those ids for `team cancel`',
         '- `team next` — tasks in `.hive/tasks.md` that are unblocked right now (mark dependencies with a trailing `[needs: #2, #5]` — 1-based task positions; `team next` returns only tasks whose deps are all done)',
         '- `team recall "<query>" [--limit <n>] [--window <n>]` — search prior team messages/reports in this workspace',
-        '- `team memory add "<body>" [--kind fact|preference|decision|pitfall|procedure_ref] [--tag <tag>]` — save durable workspace memory (orchestrator entries become active)',
+        '- `team memory add "<body>" [--kind fact|preference|decision|pitfall|procedure_ref] [--scope workspace|user] [--tag <tag>] [--ref-type workflow|skill|procedure|template|doc --ref-id <id> [--ref-title <title>]]` — save durable workspace/user memory (orchestrator entries become active)',
         '- `team memory show <memory-id>` — inspect a memory entry and evidence snapshots',
-        '- `team memory search "<query>" [--limit <n>]` — search active workspace memory',
+        '- `team memory search "<query>" [--limit <n>] [--scope workspace|user|all]` — search active memory',
         '- `team memory dream show <dream-run-id>` — inspect the bounded input for a pending memory maintenance run',
         '- `team memory apply --run <dream-run-id> --stdin` — apply strict JSON Dream ops for a pending maintenance run',
         '- `team memory forget <memory-id>` — archive obsolete memory (orchestrator only; does not physically delete evidence)',
@@ -341,7 +341,7 @@ export const buildProtocolDoc = (cliPolicy = DEFAULT_WORKFLOW_CLI_POLICY, flags
         '- `team memory dream show <dream-run-id>` — inspect a pending Dream run only when the orchestrator assigns memory review; propose ops in `team report`, never apply',
         '- `team report "<result>" --dispatch <id>` — report task outcome',
         '- `team report --stdin --dispatch <id>` — same, body from stdin (pipe content in via your shell — POSIX heredoc, Windows cmd `type file |`, PowerShell `Get-Content -Raw -Encoding utf8 file |`, or portable stdin redirection `< file`)',
-        '- `team status "<state>"` — update orchestrator when no dispatch is active',
+        '- `team status "<state>"` — send startup readiness, progress, or standby; never closes a dispatch',
         '',
         '## `team` CLI — sentinel',
         '',

package/dist/src/server/routes-team-memory.js CHANGED Viewed

@@ -1,4 +1,4 @@
-import { isMemoryKind, MEMORY_BODY_MAX_CHARS, MEMORY_KINDS, MEMORY_QUERY_MAX_CHARS, MEMORY_SEARCH_MAX_LIMIT, MEMORY_TAG_MAX_CHARS, MEMORY_TAG_MAX_COUNT, } from '../shared/team-memory.js';
+import { isMemoryKind, isMemoryProcedureRefType, isMemoryScope, MEMORY_BODY_MAX_CHARS, MEMORY_KINDS, MEMORY_PROCEDURE_REF_ID_MAX_CHARS, MEMORY_PROCEDURE_REF_TITLE_MAX_CHARS, MEMORY_PROCEDURE_REF_TYPES, MEMORY_QUERY_MAX_CHARS, MEMORY_SCOPES, MEMORY_SEARCH_MAX_LIMIT, MEMORY_TAG_MAX_CHARS, MEMORY_TAG_MAX_COUNT, } from '../shared/team-memory.js';
 import { BadRequestError } from './http-errors.js';
 import { readJsonBody, route, sendJson } from './route-helpers.js';
 import { authenticateCliAgent, requireCommandForRole } from './team-authz.js';
@@ -42,6 +42,49 @@ const parseKind = (value) => {
     }
     return value;
 };
+const parseScope = (value) => {
+    if (value === undefined)
+        return 'workspace';
+    if (!isMemoryScope(value)) {
+        throw new BadRequestError(`scope must be one of: ${MEMORY_SCOPES.join(', ')}`);
+    }
+    return value;
+};
+const parseSearchScopes = (value) => {
+    if (value === undefined)
+        return ['workspace'];
+    if (value === 'all')
+        return ['workspace', 'user'];
+    if (isMemoryScope(value))
+        return [value];
+    throw new BadRequestError(`scope must be workspace, user, or all`);
+};
+const parseProcedureRef = (value) => {
+    if (value === undefined || value === null)
+        return null;
+    if (typeof value !== 'object' || Array.isArray(value)) {
+        throw new BadRequestError('procedure_ref must be an object');
+    }
+    const record = value;
+    if (!isMemoryProcedureRefType(record.type)) {
+        throw new BadRequestError(`procedure_ref.type must be one of: ${MEMORY_PROCEDURE_REF_TYPES.join(', ')}`);
+    }
+    if (typeof record.id !== 'string' || !record.id.trim()) {
+        throw new BadRequestError('procedure_ref.id must be a non-empty string');
+    }
+    const id = record.id.trim();
+    if ([...id].length > MEMORY_PROCEDURE_REF_ID_MAX_CHARS) {
+        throw new BadRequestError(`procedure_ref.id must be ${MEMORY_PROCEDURE_REF_ID_MAX_CHARS} characters or fewer`);
+    }
+    if (record.title !== undefined && record.title !== null && typeof record.title !== 'string') {
+        throw new BadRequestError('procedure_ref.title must be a string');
+    }
+    const title = typeof record.title === 'string' ? record.title.trim() || null : null;
+    if (title !== null && [...title].length > MEMORY_PROCEDURE_REF_TITLE_MAX_CHARS) {
+        throw new BadRequestError(`procedure_ref.title must be ${MEMORY_PROCEDURE_REF_TITLE_MAX_CHARS} characters or fewer`);
+    }
+    return { id, title, type: record.type };
+};
 const parseTags = (value) => {
     if (value === undefined)
         return [];
@@ -83,6 +126,11 @@ export const teamMemoryRoutes = [
         const body = await readJsonBody(request);
         const { agent, workspaceId } = authenticateMemoryRequest(body, store);
         requireCommandForRole(agent, 'memory_add');
+        const kind = parseKind(body.kind);
+        const procedureRef = parseProcedureRef(body.procedure_ref);
+        if (kind === 'procedure_ref' && procedureRef === null) {
+            throw new BadRequestError('procedure_ref is required when kind is procedure_ref');
+        }
         const memory = store.addMemoryEntry({
             actor: {
                 id: agent.id,
@@ -90,7 +138,9 @@ export const teamMemoryRoutes = [
                 role: agent.role,
             },
             body: requireMemoryBody(body.body),
-            kind: parseKind(body.kind),
+            kind,
+            procedureRef,
+            scope: parseScope(body.scope),
             tags: parseTags(body.tags),
             workspaceId,
         });
@@ -121,6 +171,7 @@ export const teamMemoryRoutes = [
         const limit = parseLimit(body.limit);
         const results = store.searchMemoryEntries(workspaceId, requireMemoryQuery(body.query), {
             ...(limit !== undefined ? { limit } : {}),
+            scopes: parseSearchScopes(body.scope),
         });
         sendJson(response, 200, {
             ok: true,

package/dist/src/server/routes-workspace-memory.js CHANGED Viewed

@@ -1,4 +1,4 @@
-import { MEMORY_QUERY_MAX_CHARS, MEMORY_SEARCH_MAX_LIMIT } from '../shared/team-memory.js';
+import { isMemoryScope, MEMORY_QUERY_MAX_CHARS, MEMORY_SEARCH_MAX_LIMIT, } from '../shared/team-memory.js';
 import { BadRequestError } from './http-errors.js';
 import { getRequiredParam, readJsonBody, route, sendJson } from './route-helpers.js';
 import { readWorkspaceMemoryDreamEnabled, readWorkspaceMemoryEnabled, serializeWorkspaceMemoryDreamEnabled, serializeWorkspaceMemoryEnabled, workspaceMemoryDreamEnabledKey, workspaceMemoryEnabledKey, } from './team-memory-feature.js';
@@ -30,6 +30,15 @@ const parseQuery = (value) => {
     }
     return query;
 };
+const parseScopes = (value) => {
+    if (value === null)
+        return ['workspace'];
+    if (value === 'all')
+        return ['workspace', 'user'];
+    if (isMemoryScope(value))
+        return [value];
+    throw new BadRequestError('scope must be workspace, user, or all');
+};
 const requireBoolean = (value, field) => {
     if (typeof value !== 'boolean')
         throw new BadRequestError(`${field} must be a boolean`);
@@ -69,13 +78,15 @@ export const workspaceMemoryRoutes = [
         const statuses = parseStatuses(url.searchParams.get('status'));
         const limit = parseLimit(url.searchParams.get('limit'));
         const query = parseQuery(url.searchParams.get('query'));
+        const scopes = parseScopes(url.searchParams.get('scope'));
         const memories = query
             ? store.searchMemoryEntries(workspaceId, query, {
                 includeDisabled: true,
                 limit,
+                scopes,
                 statuses,
             })
-            : store.listMemoryEntries(workspaceId, { limit, statuses });
+            : store.listMemoryEntries(workspaceId, { limit, scopes, statuses });
         sendJson(response, 200, { memories: memories.map(serializeMemoryEntry), ok: true });
     }),
     route('GET', '/api/ui/workspaces/:workspaceId/memory/injections', ({ params, request, response, store }) => {
@@ -109,6 +120,24 @@ export const workspaceMemoryRoutes = [
             ok: true,
         });
     }),
+    route('GET', '/api/ui/workspaces/:workspaceId/memory/diagnostics', ({ params, request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
+        const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Missing workspaceId');
+        if (!workspaceId)
+            return;
+        if (!requireWorkspace(response, store, workspaceId))
+            return;
+        const url = new URL(request.url ?? '/', 'http://127.0.0.1');
+        sendJson(response, 200, {
+            diagnostics: store.getMemoryDiagnostics({
+                query: parseQuery(url.searchParams.get('query')) || null,
+                taskText: parseQuery(url.searchParams.get('task_text')) || null,
+                workerDescription: parseQuery(url.searchParams.get('worker_description')) || null,
+                workspaceId,
+            }),
+            ok: true,
+        });
+    }),
     route('PUT', '/api/ui/workspaces/:workspaceId/memory/settings', async ({ params, request, response, store }) => {
         requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
         const workspaceId = getRequiredParam(response, params, 'workspaceId', 'Missing workspaceId');

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

@@ -13,6 +13,7 @@ import type { RemotePairing } from './remote-pairing.js';
 import type { RemoteTunnel, TunnelStatus } from './remote-tunnel.js';
 import type { MemoryDreamInput } from './runtime-store-dream.js';
 import type { SettingsStore } from './settings-store.js';
+import type { BuildMemoryDiagnosticsInput, MemoryDiagnostics } from './team-memory-diagnostics.js';
 import type { DreamRunRecord } from './team-memory-dream-store.js';
 import type { AddMemoryEntryInput, LogMemoryInjectionsInput, MemoryEntryWithSources, MemoryInjectionWithMemory, MemoryListOptions, MemorySearchOptions, MemorySearchResult } from './team-memory-store.js';
 import type { CancelTaskInput, DispatchTaskInput, ReportTaskInput, ReportTaskResult, StatusTaskInput } from './team-operations.js';
@@ -80,6 +81,7 @@ export interface RuntimeStore {
     approveMemoryCandidate: (workspaceId: string, memoryId: string) => MemoryEntryWithSources;
     archiveMemoryEntry: (workspaceId: string, memoryId: string) => MemoryEntryWithSources;
     getMemoryEntry: (workspaceId: string, memoryId: string) => MemoryEntryWithSources | undefined;
+    getMemoryDiagnostics: (input: BuildMemoryDiagnosticsInput) => MemoryDiagnostics;
     listMemoryEntries: (workspaceId: string, options?: MemoryListOptions) => MemoryEntryWithSources[];
     listMemoryInjectionsForDispatch: (workspaceId: string, dispatchId: string) => MemoryInjectionWithMemory[];
     logMemoryInjections: (input: LogMemoryInjectionsInput) => string[];

package/dist/src/server/runtime-store-dream.d.ts CHANGED Viewed

@@ -1,9 +1,7 @@
+import { type MemoryDreamInput } from './team-memory-dream-input.js';
 import { type DreamMessageInput, type DreamRunRecord } from './team-memory-dream-store.js';
 import type { MemoryEntryWithSources } from './team-memory-store.js';
-export interface MemoryDreamInput {
-    prompt: string;
-    run: DreamRunRecord;
-}
+export type { MemoryDreamInput } from './team-memory-dream-input.js';
 interface RuntimeStoreDreamServices {
     teamMemoryDreamRunner: {
         runManual: (workspaceId: string) => Promise<DreamRunRecord>;
@@ -33,4 +31,3 @@ export declare const createRuntimeStoreDreamMethods: (services: RuntimeStoreDrea
     runMemoryDream(workspaceId: string): Promise<DreamRunRecord>;
     tickMemoryDreamScheduler(now?: number): Promise<void>;
 };
-export {};

package/dist/src/server/runtime-store-dream.js CHANGED Viewed

@@ -1,4 +1,4 @@
-import { buildDreamPrompt, DREAM_PROMPT_MEMORY_LIMIT, DREAM_PROMPT_MESSAGE_LIMIT, } from './team-memory-dream-prompt.js';
+import { buildMemoryDreamInput } from './team-memory-dream-input.js';
 import { DREAM_STALE_ERROR, DreamRunNotFoundError, DreamRunValidationError, } from './team-memory-dream-store.js';
 const shouldExportStaleRun = (run) => run.status === 'failed' && run.error === DREAM_STALE_ERROR;
 export const createRuntimeStoreDreamMethods = (services) => ({
@@ -31,17 +31,7 @@ export const createRuntimeStoreDreamMethods = (services) => ({
                 services.teamMemoryExport.schedule(workspaceId);
             throw new DreamRunValidationError('Dream run is no longer running');
         }
-        const messages = services.teamMemoryDreamStore
-            .listInputMessages(workspaceId, run.inputSeqFrom, run.inputSeqTo)
-            .slice(-DREAM_PROMPT_MESSAGE_LIMIT);
-        const memories = services.teamMemoryStore
-            .listAllEntries(workspaceId)
-            .filter((memory) => memory.status === 'active' && memory.updatedAt <= run.startedAt)
-            .slice(0, DREAM_PROMPT_MEMORY_LIMIT);
-        return {
-            prompt: buildDreamPrompt({ memories, messages, workspaceId }),
-            run,
-        };
+        return buildMemoryDreamInput(services, workspaceId, run);
     },
     listMemoryDreamRuns(workspaceId, limit) {
         const runs = services.teamMemoryDreamStore.listRuns(workspaceId, limit);

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

@@ -15,10 +15,12 @@ import { createSentinelHeartbeatService } from './sentinel-heartbeat.js';
 import { createSettingsStore } from './settings-store.js';
 import { createTasksFileService } from './tasks-file.js';
 import { createTasksFileWatcher } from './tasks-file-watcher.js';
+import { createTeamMemoryDiagnostics } from './team-memory-diagnostics.js';
 import { createTeamMemoryDreamRunner } from './team-memory-dream-runner.js';
 import { createTeamMemoryDreamScheduler } from './team-memory-dream-scheduler.js';
 import { createTeamMemoryDreamStore } from './team-memory-dream-store.js';
 import { createTeamMemoryExportService } from './team-memory-export.js';
+import { createLocalTeamMemoryProvider } from './team-memory-provider.js';
 import { createTeamMemoryStore } from './team-memory-store.js';
 import { createTeamOperations } from './team-operations.js';
 import { createTeamRecallStore } from './team-recall-store.js';
@@ -52,8 +54,10 @@ export interface RuntimeStoreServices {
     sentinelHeartbeat: ReturnType<typeof createSentinelHeartbeatService>;
     protocolEventStats: ReturnType<typeof createProtocolEventStats>;
     teamMemoryDreamStore: ReturnType<typeof createTeamMemoryDreamStore>;
+    teamMemoryDiagnostics: ReturnType<typeof createTeamMemoryDiagnostics>;
     teamMemoryStore: ReturnType<typeof createTeamMemoryStore>;
     teamMemoryExport: ReturnType<typeof createTeamMemoryExportService>;
+    teamMemoryProvider: ReturnType<typeof createLocalTeamMemoryProvider>;
     teamRecallStore: ReturnType<typeof createTeamRecallStore>;
     teamOps: ReturnType<typeof createTeamOperations>;
     uiAuth: ReturnType<typeof createUiAuth>;

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

@@ -21,11 +21,15 @@ import { createSentinelHeartbeatService } from './sentinel-heartbeat.js';
 import { createSettingsStore } from './settings-store.js';
 import { createTasksFileService } from './tasks-file.js';
 import { createTasksFileWatcher } from './tasks-file-watcher.js';
+import { createTeamMemoryDiagnostics } from './team-memory-diagnostics.js';
 import { createWorkspaceMemoryDigestProvider } from './team-memory-digest.js';
+import { createDreamCliExecutor } from './team-memory-dream-cli.js';
+import { buildMemoryDreamInput } from './team-memory-dream-input.js';
 import { createTeamMemoryDreamRunner } from './team-memory-dream-runner.js';
 import { createTeamMemoryDreamScheduler } from './team-memory-dream-scheduler.js';
 import { createTeamMemoryDreamStore } from './team-memory-dream-store.js';
 import { createTeamMemoryExportService, MEMORY_EXPORT_DREAM_CHANGELOG_LIMIT, } from './team-memory-export.js';
+import { createLocalTeamMemoryProvider } from './team-memory-provider.js';
 import { createTeamMemoryStore } from './team-memory-store.js';
 import { createTeamOperations } from './team-operations.js';
 import { createTeamRecallStore } from './team-recall-store.js';
@@ -87,8 +91,15 @@ export const createRuntimeStoreServices = (options = {}) => {
     const agentSessionStore = createAgentSessionStore(db);
     const settings = createSettingsStore(db);
     const getFlags = () => readFeatureFlags(settings);
-    const memoryDigestProvider = createWorkspaceMemoryDigestProvider({
+    const teamMemoryProvider = createLocalTeamMemoryProvider({ memoryStore: teamMemoryStore });
+    const teamMemoryDreamCli = createDreamCliExecutor();
+    const teamMemoryDiagnostics = createTeamMemoryDiagnostics({
+        dreamStore: teamMemoryDreamStore,
+        memoryProvider: teamMemoryProvider,
         memoryStore: teamMemoryStore,
+    });
+    const memoryDigestProvider = createWorkspaceMemoryDigestProvider({
+        memoryStore: teamMemoryProvider,
         settings,
     });
     const memoryInjection = {
@@ -194,10 +205,16 @@ export const createRuntimeStoreServices = (options = {}) => {
         }
     }, restartPolicy, (workspaceId, agentId) => workspaceStore.getAgent(workspaceId, agentId), getFlags, memoryInjection);
     const teamMemoryDreamRunner = createTeamMemoryDreamRunner({
+        applyScheduledRun: teamMemoryDreamStore.applyAndCompleteRun,
+        buildScheduledInput: (workspaceId, run) => buildMemoryDreamInput({ teamMemoryDreamStore, teamMemoryStore }, workspaceId, run),
         dreamStore: teamMemoryDreamStore,
         deliverToOrchestrator: (workspaceId, text) => agentRuntime.deliverSystemMessageToAgent(workspaceId, getOrchestratorId(workspaceId), text, {
             requireActiveRun: true,
         }),
+        executeScheduledDream: ({ prompt, workspaceId }) => teamMemoryDreamCli.execute({
+            cwd: workspaceStore.getWorkspaceSnapshot(workspaceId).summary.path,
+            prompt,
+        }),
         scheduleExport: teamMemoryExport.schedule,
     });
     const teamMemoryDreamScheduler = createTeamMemoryDreamScheduler({
@@ -294,7 +311,9 @@ export const createRuntimeStoreServices = (options = {}) => {
         sentinelHeartbeat,
         protocolEventStats,
         teamMemoryDreamStore,
+        teamMemoryDiagnostics,
         teamMemoryExport,
+        teamMemoryProvider,
         teamMemoryStore,
         teamRecallStore,
         teamOps,
@@ -392,6 +411,7 @@ export const createRuntimeStoreLifecycle = ({ agentManager, services, }) => {
                 // runner's `await agent(...)` rejects with a clear shutdown error
                 // instead of hanging on a Promise that can never resolve.
                 services.sentinelHeartbeat.close();
+                await services.teamMemoryDreamScheduler.close();
                 services.workflowDispatchAwaiter.cancelAll('runtime closing');
                 services.shellRuntime.close();
                 await services.teamMemoryExport.close();