@tt-a1i/hive 1.4.4 → 1.5.0

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

@@ -1,91 +1,180 @@
-import { buildWorkerReminderTail, ORCHESTRATOR_REMINDER_TAIL } from './hive-team-guidance.js';
+import { buildOrchestratorReminderTail, buildWorkerReminderTail } from './hive-team-guidance.js';
 import { PtyInactiveError } from './http-errors.js';
 import { createPostStartInputWriter } from './post-start-input-writer.js';
-export const buildOrchestratorReportPayload = (workerName, text, artifacts) => {
-    const lines = [`[Hive 系统消息：来自 @${workerName} 的汇报]`, text];
+export const buildOrchestratorReportPayload = (workerName, text, artifacts, workflowsEnabled = false) => {
+    const lines = [`<hive-message kind="report" from="@${workerName}">`, text];
     for (const artifact of artifacts)
         lines.push(`artifact: ${artifact}`);
-    lines.push('', ORCHESTRATOR_REMINDER_TAIL, '');
+    lines.push('</hive-message>', '', buildOrchestratorReminderTail(workflowsEnabled), '');
     return lines.join('\n');
 };
-export const buildOrchestratorStatusPayload = (workerName, text, artifacts) => {
-    const lines = [`[Hive 系统消息：来自 @${workerName} 的状态更新]`, text];
+export const buildOrchestratorStatusPayload = (workerName, text, artifacts, workflowsEnabled = false) => {
+    const lines = [`<hive-message kind="status" from="@${workerName}">`, text];
     for (const artifact of artifacts)
         lines.push(`artifact: ${artifact}`);
-    lines.push('', ORCHESTRATOR_REMINDER_TAIL, '');
+    lines.push('</hive-message>', '', buildOrchestratorReminderTail(workflowsEnabled), '');
     return lines.join('\n');
 };
-export const buildOrchestratorUserInputPayload = (text) => [text, '', ORCHESTRATOR_REMINDER_TAIL, ''].join('\n');
+export const buildOrchestratorUserInputPayload = (text, workflowsEnabled = false) => [text, '', buildOrchestratorReminderTail(workflowsEnabled), ''].join('\n');
 export const buildWorkerDispatchPayload = (fromAgentName, workerDescription, dispatchId, text) => [
-    `[Hive 系统消息：来自 @${fromAgentName} 的派单]`,
+    `<hive-message kind="dispatch" from="@${fromAgentName}">`,
     '',
-    `你的角色：${workerDescription}`,
+    `Your role: ${workerDescription}`,
     '',
-    '你必须遵守：',
-    `- 完成、失败、阻塞或部分完成后，执行 \`team report "<result>" --dispatch ${dispatchId}\``,
-    '- 不要做无关的事，做完就 report',
+    'You must:',
+    `- 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',
     '',
     `dispatch_id: ${dispatchId}`,
     '',
-    '任务内容：',
+    'Task:',
     text,
+    '</hive-message>',
     '',
     buildWorkerReminderTail(dispatchId),
     '',
 ].join('\n');
 export const buildWorkerCancelPayload = (dispatchId, reason) => [
-    `[Hive 系统消息：dispatch ${dispatchId} 已取消]`,
+    `<hive-message kind="cancel" dispatch="${dispatchId}">`,
     '',
-    '请停止执行这条派单，不要再为它调用 team report。',
+    'Stop working on this dispatch and do not call team report for it.',
     '',
-    '取消原因：',
+    'Cancellation reason:',
     reason,
+    '</hive-message>',
     '',
 ].join('\n');
-export const createAgentStdinDispatcher = ({ agentManager, getLaunchConfig, getWorkspaceId, registry, syncRun, }) => {
-    const writeToActiveAgentRun = (workspaceId, agentId, text, input = {}) => {
-        const run = registry
-            .list()
-            .filter((item) => item.agentId === agentId && getWorkspaceId(item.agentId) === workspaceId)
-            .sort((left, right) => right.startedAt - left.startedAt)
-            .find((item) => {
-            const status = syncRun(item).status;
-            return status === 'starting' || status === 'running';
-        });
-        if (!run) {
+export const createAgentStdinDispatcher = ({ agentManager, getLaunchConfig, getWorkspaceId, registry, syncRun, getWorkflowsEnabled, }) => {
+    const workflowsEnabled = () => getWorkflowsEnabled?.() ?? false;
+    const chains = new Map();
+    const getChain = (agentId) => {
+        let chain = chains.get(agentId);
+        if (!chain) {
+            chain = { busy: false, queue: [] };
+            chains.set(agentId, chain);
+        }
+        return chain;
+    };
+    const resolveActiveRun = (workspaceId, agentId) => registry
+        .list()
+        .filter((item) => item.agentId === agentId && getWorkspaceId(item.agentId) === workspaceId)
+        .sort((left, right) => right.startedAt - left.startedAt)
+        .find((item) => {
+        const status = syncRun(item).status;
+        return status === 'starting' || status === 'running';
+    });
+    // Synchronously enforce requireActiveRun (so writeSendPrompt still throws in
+    // the caller's stack when there is no live run), then return a thunk that
+    // re-resolves the run at EXECUTION time and performs the actual write,
+    // returning a promise that settles when the paste→submit sequence is done.
+    const prepareWrite = (workspaceId, agentId, text, input) => {
+        if (!resolveActiveRun(workspaceId, agentId)) {
             if (input.requireActiveRun) {
                 throw new PtyInactiveError(`No active run for agent: ${agentId}`);
             }
-            return;
+            return () => Promise.resolve();
         }
-        try {
-            const config = getLaunchConfig(workspaceId, agentId);
-            if (agentManager && config) {
-                createPostStartInputWriter(agentManager, config.interactiveCommand ?? config.command)(run.runId, text);
+        return () => {
+            const run = resolveActiveRun(workspaceId, agentId);
+            if (!run) {
+                if (input.requireActiveRun) {
+                    throw new PtyInactiveError(`No active run for agent: ${agentId}`);
+                }
+                return Promise.resolve();
             }
-            else {
+            try {
+                const config = getLaunchConfig(workspaceId, agentId);
+                if (agentManager && config) {
+                    return (createPostStartInputWriter(agentManager, config.interactiveCommand ?? config.command)(run.runId, text).catch((error) => {
+                        throw new PtyInactiveError(error instanceof Error ? error.message : String(error));
+                    }) ?? Promise.resolve());
+                }
                 agentManager?.writeInput(run.runId, text);
+                return Promise.resolve();
             }
+            catch (error) {
+                throw new PtyInactiveError(error instanceof Error ? error.message : String(error));
+            }
+        };
+    };
+    const settle = (agentId, promise) => promise.finally(() => {
+        const chain = chains.get(agentId);
+        if (!chain)
+            return;
+        chain.busy = false;
+        drain(agentId);
+    });
+    const runQueuedWrite = (agentId, write) => {
+        try {
+            void settle(agentId, write.run()).then(write.resolve, write.reject);
+        }
+        catch (error) {
+            write.reject(error);
+            const chain = chains.get(agentId);
+            if (chain)
+                chain.busy = false;
+            drain(agentId);
+        }
+    };
+    function drain(agentId) {
+        const chain = chains.get(agentId);
+        if (!chain)
+            return;
+        if (chain.busy)
+            return;
+        const next = chain.queue.shift();
+        if (!next) {
+            chains.delete(agentId);
+            return;
+        }
+        chain.busy = true;
+        runQueuedWrite(agentId, next);
+    }
+    const writeToActiveAgentRun = (workspaceId, agentId, text, input = {}) => {
+        const thunk = prepareWrite(workspaceId, agentId, text, input);
+        const chain = getChain(agentId);
+        if (chain.busy) {
+            return new Promise((resolve, reject) => {
+                chain.queue.push({ reject, resolve, run: thunk });
+            });
+        }
+        chain.busy = true;
+        try {
+            return settle(agentId, thunk()); // uncontended: run now; immediate failures still throw
         }
         catch (error) {
-            throw new PtyInactiveError(error instanceof Error ? error.message : String(error));
+            chain.busy = false;
+            drain(agentId);
+            throw error;
         }
     };
+    const swallowQueuedFailure = (promise) => {
+        void promise.catch(() => {
+            // Deferred prompt writes can fail if the PTY exits while queued. Calls
+            // that require foreground error reporting use writeSendPrompt's promise.
+        });
+    };
     return {
         writeReportPrompt(workspaceId, workerName, text, artifacts, input = {}) {
-            writeToActiveAgentRun(workspaceId, `${workspaceId}:orchestrator`, buildOrchestratorReportPayload(workerName, text, artifacts), input);
+            swallowQueuedFailure(writeToActiveAgentRun(workspaceId, `${workspaceId}:orchestrator`, buildOrchestratorReportPayload(workerName, text, artifacts, workflowsEnabled()), input));
         },
         writeStatusPrompt(workspaceId, workerName, text, artifacts, input = {}) {
-            writeToActiveAgentRun(workspaceId, `${workspaceId}:orchestrator`, buildOrchestratorStatusPayload(workerName, text, artifacts), input);
+            swallowQueuedFailure(writeToActiveAgentRun(workspaceId, `${workspaceId}:orchestrator`, buildOrchestratorStatusPayload(workerName, text, artifacts, workflowsEnabled()), input));
         },
         writeSendPrompt(workspaceId, workerId, dispatchId, fromAgentName, workerDescription, text) {
-            writeToActiveAgentRun(workspaceId, workerId, buildWorkerDispatchPayload(fromAgentName, workerDescription, dispatchId, text), { requireActiveRun: true });
+            return writeToActiveAgentRun(workspaceId, workerId, buildWorkerDispatchPayload(fromAgentName, workerDescription, dispatchId, text), { requireActiveRun: true });
         },
         writeCancelPrompt(workspaceId, workerId, dispatchId, reason, input = {}) {
-            writeToActiveAgentRun(workspaceId, workerId, buildWorkerCancelPayload(dispatchId, reason), input);
+            swallowQueuedFailure(writeToActiveAgentRun(workspaceId, workerId, buildWorkerCancelPayload(dispatchId, reason), input));
         },
         writeUserInputPrompt(workspaceId, text) {
-            writeToActiveAgentRun(workspaceId, `${workspaceId}:orchestrator`, buildOrchestratorUserInputPayload(text));
+            swallowQueuedFailure(writeToActiveAgentRun(workspaceId, `${workspaceId}:orchestrator`, buildOrchestratorUserInputPayload(text, workflowsEnabled())));
+        },
+        /** Generic: deliver an opaque text block to a specific agent's PTY.
+         *  Used by the workflow runner to notify the triggering orchestrator
+         *  when a run finishes (mirrors Claude Code's <task-notification>). */
+        writeSystemMessageToAgent(workspaceId, agentId, text) {
+            swallowQueuedFailure(writeToActiveAgentRun(workspaceId, agentId, text));
         },
     };
 };

package/dist/src/server/cron-util.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Validate a 5-field cron string and return its next fire time (ms-epoch).
+ * Throws BadRequestError on an unparseable expression. Shared by the UI
+ * schedule PATCH route and the agent `team workflow schedule` route so cron
+ * validation behaves identically on both paths. UTC, like the scheduler.
+ */
+export declare const validateCronNextRunAt: (cron: string) => number;

package/dist/src/server/cron-util.js

@@ -0,0 +1,19 @@
+import { CronExpressionParser } from 'cron-parser';
+import { BadRequestError } from './http-errors.js';
+/**
+ * Validate a 5-field cron string and return its next fire time (ms-epoch).
+ * Throws BadRequestError on an unparseable expression. Shared by the UI
+ * schedule PATCH route and the agent `team workflow schedule` route so cron
+ * validation behaves identically on both paths. UTC, like the scheduler.
+ */
+export const validateCronNextRunAt = (cron) => {
+    try {
+        return CronExpressionParser.parse(cron, { currentDate: new Date(), tz: 'UTC' })
+            .next()
+            .toDate()
+            .getTime();
+    }
+    catch (error) {
+        throw new BadRequestError(`Invalid cron expression: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};

package/dist/src/server/dispatch-ledger-store.d.ts

@@ -6,19 +6,27 @@ export interface DispatchRecord {
     deliveredAt: number | null;
     fromAgentId: string | null;
     id: string;
+    label: string | null;
+    phase: string | null;
     reportedAt: number | null;
     reportText: string | null;
     sequence: number | null;
     status: DispatchStatus;
+    stepIndex: number | null;
     submittedAt: number | null;
     text: string;
     toAgentId: string;
+    workflowRunId: string | null;
     workspaceId: string;
 }
 interface CreateDispatchInput {
     fromAgentId?: string;
+    label?: string;
+    phase?: string;
+    stepIndex?: number;
     text: string;
     toAgentId: string;
+    workflowRunId?: string;
     workspaceId: string;
 }
 interface ReportDispatchInput {
@@ -50,6 +58,12 @@ export declare const createDispatchLedgerStore: (db: Database) => {
         worker_id: string;
         workspace_id: string;
     }>;
+    listOpenDispatchIdsForRun: (runId: string) => string[];
+    listOpenWorkflowDispatchesForWorker: (workspaceId: string, workerId: string) => Array<{
+        dispatchId: string;
+        runId: string;
+    }>;
+    listWorkflowRunDispatches: (runId: string) => DispatchRecord[];
     listWorkspaceDispatches: (workspaceId: string, options?: ListDispatchesOptions) => DispatchRecord[];
     markCancelled: (input: CancelDispatchInput) => {
         reportedAt: number;
@@ -60,10 +74,14 @@ export declare const createDispatchLedgerStore: (db: Database) => {
         deliveredAt: number | null;
         fromAgentId: string | null;
         id: string;
+        label: string | null;
+        phase: string | null;
         sequence: number | null;
+        stepIndex: number | null;
         submittedAt: number | null;
         text: string;
         toAgentId: string;
+        workflowRunId: string | null;
         workspaceId: string;
     } | undefined;
     markReportedByWorker: (input: ReportDispatchInput) => {
@@ -75,10 +93,14 @@ export declare const createDispatchLedgerStore: (db: Database) => {
         deliveredAt: number | null;
         fromAgentId: string | null;
         id: string;
+        label: string | null;
+        phase: string | null;
         sequence: number | null;
+        stepIndex: number | null;
         submittedAt: number | null;
         text: string;
         toAgentId: string;
+        workflowRunId: string | null;
         workspaceId: string;
     } | undefined;
     markSubmitted: (dispatchId: string) => void;

package/dist/src/server/dispatch-ledger-store.js

@@ -18,13 +18,17 @@ const toRecord = (row) => ({
     deliveredAt: row.delivered_at,
     fromAgentId: row.from_agent_id,
     id: row.id,
+    label: row.label ?? null,
+    phase: row.phase ?? null,
     reportedAt: row.reported_at,
     reportText: row.report_text,
     sequence: row.sequence,
     status: row.status,
+    stepIndex: row.step_index,
     submittedAt: row.submitted_at,
     text: row.text,
     toAgentId: row.to_agent_id,
+    workflowRunId: row.workflow_run_id,
     workspaceId: row.workspace_id,
 });
 export const createDispatchLedgerStore = (db) => {
@@ -35,13 +39,17 @@ export const createDispatchLedgerStore = (db) => {
             deliveredAt: null,
             fromAgentId: input.fromAgentId ?? null,
             id: randomUUID(),
+            label: input.label ?? null,
+            phase: input.phase ?? null,
             reportedAt: null,
             reportText: null,
             sequence: null,
             status: 'queued',
+            stepIndex: input.stepIndex ?? null,
             submittedAt: null,
             text: input.text,
             toAgentId: input.toAgentId,
+            workflowRunId: input.workflowRunId ?? null,
             workspaceId: input.workspaceId,
         };
         db.prepare(`INSERT INTO dispatches (
@@ -56,8 +64,12 @@ export const createDispatchLedgerStore = (db) => {
         submitted_at,
         reported_at,
         report_text,
-        artifacts
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(record.id, record.workspaceId, record.fromAgentId, record.toAgentId, record.text, record.status, record.createdAt, record.deliveredAt, record.submittedAt, record.reportedAt, record.reportText, JSON.stringify(record.artifacts));
+        artifacts,
+        workflow_run_id,
+        step_index,
+        phase,
+        label
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(record.id, record.workspaceId, record.fromAgentId, record.toAgentId, record.text, record.status, record.createdAt, record.deliveredAt, record.submittedAt, record.reportedAt, record.reportText, JSON.stringify(record.artifacts), record.workflowRunId, record.stepIndex, record.phase, record.label);
         return record;
     };
     const deleteDispatch = (dispatchId) => {
@@ -175,8 +187,41 @@ export const createDispatchLedgerStore = (db) => {
         db.prepare('DELETE FROM dispatches WHERE workspace_id = ?').run(workspaceId);
     };
     const deleteWorkerDispatches = (workspaceId, workerId) => {
-        db.prepare('DELETE FROM dispatches WHERE workspace_id = ? AND to_agent_id = ?').run(workspaceId, workerId);
+        // Preserve workflow-run dispatch history (`workflow_run_id IS NOT NULL`)
+        // so the UI's run-detail timeline can still show what each ephemeral
+        // worker did after the worker itself is dismissed. Orchestrator-issued
+        // dispatches are tied to the worker identity and are dropped with it.
+        db.prepare(`DELETE FROM dispatches
+       WHERE workspace_id = ? AND to_agent_id = ? AND workflow_run_id IS NULL`).run(workspaceId, workerId);
     };
+    // Every dispatch fired by a workflow run carries the run id (M1-B added the
+    // column; M2-C plumbs it through). This is the timeline query the UI uses to
+    // explode a run row into per-worker activity.
+    const listWorkflowRunDispatches = (runId) => {
+        const rows = db
+            .prepare('SELECT * FROM dispatches WHERE workflow_run_id = ? ORDER BY sequence, created_at')
+            .all(runId);
+        return rows.map(toRecord);
+    };
+    // Open dispatch ids tied to a workflow run — drives the runner's stop path
+    // (each id gets a notifyCancel so the runner's await rejects).
+    const listOpenDispatchIdsForRun = (runId) => db
+        .prepare(`SELECT id FROM dispatches
+           WHERE workflow_run_id = ? AND status IN ('queued', 'submitted')`)
+        .all(runId).map((row) => row.id);
+    // Open workflow-tagged dispatches addressed to a specific worker. Drives the
+    // PTY-exit cancel path (TIER 1 #1): when a workflow-spawned worker dies
+    // without calling `team report`, the runner's `awaitReport` would otherwise
+    // hang for DEFAULT_TIMEOUT_MS (10 min). The exit handler enumerates these
+    // and `notifyCancel`s each so the surrounding `agent()`/`parallel`/`pipeline`
+    // sees an immediate reject.
+    const listOpenWorkflowDispatchesForWorker = (workspaceId, workerId) => db
+        .prepare(`SELECT id, workflow_run_id FROM dispatches
+           WHERE workspace_id = ?
+             AND to_agent_id = ?
+             AND workflow_run_id IS NOT NULL
+             AND status IN ('queued', 'submitted')`)
+        .all(workspaceId, workerId).map((row) => ({ dispatchId: row.id, runId: row.workflow_run_id }));
     return {
         createDispatch,
         deleteDispatch,
@@ -185,6 +230,9 @@ export const createDispatchLedgerStore = (db) => {
         findOpenDispatch,
         findOpenDispatchById,
         listOpenDispatchKinds,
+        listOpenDispatchIdsForRun,
+        listOpenWorkflowDispatchesForWorker,
+        listWorkflowRunDispatches,
         listWorkspaceDispatches,
         markCancelled,
         markReportedByWorker,

package/dist/src/server/env-sync-message.js

@@ -4,7 +4,7 @@ import { TASKS_RELATIVE_PATH } from './tasks-file.js';
 const TASKS_HEAD_LIMIT = 1024;
 const formatWorkers = (workers) => {
     if (workers.length === 0)
-        return ['- 当前没有其他 worker'];
+        return ['- (no other workers)'];
     return workers.map((worker) => `- ${worker.name} (${worker.role}, ${worker.status}, pending_task_count: ${worker.pendingTaskCount})`);
 };
 const formatRestartWindow = (messages) => {
@@ -12,18 +12,18 @@ const formatRestartWindow = (messages) => {
         return message.type === 'send';
     });
     if (sends.length === 0)
-        return ['- 重启期间未派新单'];
+        return ['- no new dispatches during the restart'];
     return sends.slice(-5).map((message) => `- send -> ${message.to}: ${message.text}`);
 };
 export const buildEnvSyncMessage = ({ agent, tasksContent, workers, workspace, restartWindowMessages, }) => wrapSystemMessage([
-    '你刚被 Hive 重启了。期间环境变化：',
-    `- 当前 workspace: ${workspace.name}`,
-    '- 现有 worker:',
+    'Hive just restarted you. Environment changes during the restart:',
+    `- Current workspace: ${workspace.name}`,
+    '- Existing workers:',
     ...formatWorkers(workers),
-    `- ${TASKS_RELATIVE_PATH} 当前内容:`,
-    tasksContent.slice(0, TASKS_HEAD_LIMIT) || '(空)',
+    `- Current ${TASKS_RELATIVE_PATH} contents:`,
+    tasksContent.slice(0, TASKS_HEAD_LIMIT) || '(empty)',
     ...formatRestartWindow(restartWindowMessages),
-    agent.role === 'orchestrator' ? '- Hive worker 派单规则:' : '- Hive worker 边界:',
+    agent.role === 'orchestrator' ? '- Hive worker dispatch rules:' : '- Hive worker boundaries:',
     ...getHiveTeamRules(agent).map((rule) => `  - ${rule}`),
-    `请继续。如果不确定，用 team list / Read ${TASKS_RELATIVE_PATH} 自查或问 user。`,
+    `Continue. If unsure, run team list / Read ${TASKS_RELATIVE_PATH} to self-check, or ask the user.`,
 ].join('\n'));

package/dist/src/server/fs-pick-folder.js

@@ -112,7 +112,11 @@ const windowsPick = async (run) => {
   
        `Add-Type -AssemblyName System.Drawing` is required because Point /
        Size live in System.Drawing.dll, not System.Windows.Forms.dll. */
+    // PS 5.1 on zh-CN Windows defaults [Console]::OutputEncoding to cp936/GBK;
+    // Node decodes stdout as UTF-8 and CJK paths arrive mojibake'd. Force UTF-8
+    // before any output. No-op on PS 7+ which already defaults to UTF-8.
     const script = [
+        '[Console]::OutputEncoding = [System.Text.Encoding]::UTF8',
         'Add-Type -AssemblyName System.Windows.Forms',
         'Add-Type -AssemblyName System.Drawing',
         '$owner = New-Object System.Windows.Forms.Form',

package/dist/src/server/fs-sandbox.js

@@ -1,5 +1,6 @@
 import { homedir } from 'node:os';
 import { isAbsolute, relative, resolve, sep } from 'node:path';
+import { realpathNative } from './path-canonicalization.js';
 /**
  * Root directory the FS-browse API is allowed to reveal. We sandbox to
  * `$HOME` (override via `HIVE_FS_BROWSE_ROOT` for tests). Anything outside
@@ -7,7 +8,19 @@ import { isAbsolute, relative, resolve, sep } from 'node:path';
  */
 export const getFsBrowseRoot = () => {
     const override = process.env.HIVE_FS_BROWSE_ROOT;
-    return override && override.length > 0 ? resolve(override) : resolve(homedir());
+    const root = override && override.length > 0 ? resolve(override) : resolve(homedir());
+    try {
+        return realpathNative(root);
+    }
+    catch {
+        return root;
+    }
+};
+const isResolvedPathWithinRoot = (rootPath, candidatePath) => {
+    if (candidatePath === rootPath)
+        return true;
+    const rel = relative(rootPath, candidatePath);
+    return rel !== '..' && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
 };
 /**
  * True when `candidatePath` is `rootPath` itself or a descendant of it.
@@ -16,10 +29,26 @@ export const getFsBrowseRoot = () => {
  * isPathWithinRoot so the semantics match a project we already trust.
  */
 export const isPathWithinRoot = (rootPath, candidatePath) => {
-    const resolvedRoot = resolve(rootPath);
-    const resolvedCandidate = resolve(candidatePath);
-    if (resolvedCandidate === resolvedRoot)
-        return true;
-    const rel = relative(resolvedRoot, resolvedCandidate);
-    return rel !== '..' && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+    const lexicalRoot = resolve(rootPath);
+    const lexicalCandidate = resolve(candidatePath);
+    let resolvedRoot = lexicalRoot;
+    let resolvedCandidate = lexicalCandidate;
+    try {
+        resolvedRoot = realpathNative(resolvedRoot);
+    }
+    catch {
+        // Missing / inaccessible roots are handled by the caller's readdir/stat path.
+    }
+    try {
+        resolvedCandidate = realpathNative(resolvedCandidate);
+    }
+    catch {
+        // Non-existent children still need lexical sandboxing for "create later"
+        // probes; existing symlinks/junctions use the realpath branch above.
+        if (isResolvedPathWithinRoot(lexicalRoot, lexicalCandidate)) {
+            resolvedRoot = lexicalRoot;
+            resolvedCandidate = lexicalCandidate;
+        }
+    }
+    return isResolvedPathWithinRoot(resolvedRoot, resolvedCandidate);
 };

package/dist/src/server/hive-team-guidance.d.ts

@@ -1,4 +1,5 @@
 import type { AgentSummary } from '../shared/types.js';
+import { type WorkflowCliPolicy } from './workflow-cli-policy.js';
 /**
  * Tail reminder appended to every message that flows INTO the orchestrator
  * (worker reports, worker status updates, user chat input). Re-anchors the
@@ -11,10 +12,12 @@ import type { AgentSummary } from '../shared/types.js';
  * banner noise after a few occurrences, but `<...-system-reminder>` tags
  * mirror the out-of-band envelope LLMs are trained to attend to; placement
  * at the tail (right before the agent's reply turn) maximizes recency
- * weighting; phrasing as a two-option action menu is more actionable than
- * abstract identity restatement.
+ * weighting; phrasing as a short action menu is more actionable than abstract
+ * identity restatement. Kept deliberately SHORT — the full command syntax and
+ * the workflow DSL live in `.hive/PROTOCOL.md`, which agents re-read on demand.
+ * A long banner on every turn is itself the noise this envelope exists to beat.
  */
-export declare const ORCHESTRATOR_REMINDER_TAIL: string;
+export declare const buildOrchestratorReminderTail: (workflowsEnabled: boolean) => string;
 /**
  * Tail reminder appended to dispatches sent TO a worker. Reinforces the
  * worker identity (so the agent does not regress into its normal CLI
@@ -22,12 +25,14 @@ export declare const ORCHESTRATOR_REMINDER_TAIL: string;
  * with dispatch_id pre-bound.
  */
 export declare const buildWorkerReminderTail: (dispatchId: string) => string;
-export declare const getHiveTeamRules: (agent: Pick<AgentSummary, "role">) => string[];
+export declare const getHiveTeamRules: (agent: Pick<AgentSummary, "role">, workflowsEnabled?: boolean, autostaffEnabled?: boolean) => readonly string[];
 /**
  * Workspace-local protocol cheat sheet written to `.hive/PROTOCOL.md`. Agents
  * are explicitly trained to look at project root markdown when confused, so
  * keeping a single canonical doc next to `.hive/tasks.md` doubles as a
  * "cat-recover" path when both the startup prompt and the in-message
- * reminders fail to anchor.
+ * reminders fail to anchor. This is also the single home of the full command
+ * syntax and the workflow DSL reference — the always-on injections only carry
+ * the lean core rules and point here.
  */
-export declare const buildProtocolDoc: () => string;
+export declare const buildProtocolDoc: (cliPolicy?: WorkflowCliPolicy, workflowsEnabled?: boolean, autostaffEnabled?: boolean) => string;