fraim 2.0.171 → 2.0.173

package/dist/src/ai-hub/server.js

@@ -36,7 +36,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AiHubServer = void 0;
+exports.AiHubServer = exports.HostConfigStore = exports.DeploymentStore = void 0;
 exports.findAvailablePort = findAvailablePort;
 exports.findAvailablePortExcluding = findAvailablePortExcluding;
 const express_1 = __importDefault(require("express"));
@@ -166,6 +166,13 @@ class AiHubRunRegistry {
         this.children.set(run.id, child);
         return run;
     }
+    attachChildIfRunning(runId, child) {
+        const run = this.runs.get(runId);
+        if (!run || run.status !== 'running')
+            return false;
+        this.children.set(runId, child);
+        return true;
+    }
     update(runId, updater) {
         const run = this.runs.get(runId);
         if (!run) {
@@ -227,6 +234,114 @@ function safeHttpUrl(value) {
         return null;
     }
 }
+// ─── Issue #578: Deployment + Host stores ─────────────────────────────────────
+const VALID_EMPLOYEE_IDS = ['codex', 'claude', 'gemini', 'copilot'];
+class DeploymentStore {
+    constructor(filePath) {
+        this.filePath = filePath ?? path_1.default.join(getUserHubDir(), 'hub-deployments.json');
+    }
+    load() {
+        try {
+            if (!fs_1.default.existsSync(this.filePath))
+                return [];
+            return JSON.parse(fs_1.default.readFileSync(this.filePath, 'utf8'));
+        }
+        catch {
+            return [];
+        }
+    }
+    save(deployments) {
+        fs_1.default.mkdirSync(path_1.default.dirname(this.filePath), { recursive: true });
+        fs_1.default.writeFileSync(this.filePath, JSON.stringify(deployments, null, 2));
+    }
+    create(deployment) {
+        const list = this.load();
+        list.push(deployment);
+        this.save(list);
+        return deployment;
+    }
+    update(id, updater) {
+        const list = this.load();
+        const dep = list.find((d) => d.id === id);
+        if (!dep)
+            return false;
+        updater(dep);
+        dep.updatedAt = new Date().toISOString();
+        this.save(list);
+        return true;
+    }
+    delete(id) {
+        const list = this.load();
+        const next = list.filter((d) => d.id !== id);
+        if (next.length === list.length)
+            return false;
+        this.save(next);
+        return true;
+    }
+}
+exports.DeploymentStore = DeploymentStore;
+class HostConfigStore {
+    constructor(filePath) {
+        this.filePath = filePath ?? path_1.default.join(getUserHubDir(), 'hub-hosts.json');
+    }
+    load() {
+        try {
+            if (!fs_1.default.existsSync(this.filePath))
+                return [];
+            return JSON.parse(fs_1.default.readFileSync(this.filePath, 'utf8'));
+        }
+        catch {
+            return [];
+        }
+    }
+    save(hosts) {
+        fs_1.default.mkdirSync(path_1.default.dirname(this.filePath), { recursive: true });
+        fs_1.default.writeFileSync(this.filePath, JSON.stringify(hosts, null, 2));
+    }
+    add(host) {
+        const list = this.load();
+        list.push(host);
+        this.save(list);
+        return host;
+    }
+    delete(id) {
+        const list = this.load();
+        const next = list.filter((h) => h.id !== id);
+        if (next.length === list.length)
+            return false;
+        this.save(next);
+        return true;
+    }
+}
+exports.HostConfigStore = HostConfigStore;
+async function pingHost(host) {
+    const start = Date.now();
+    try {
+        const resp = await fetch(`${host.url.replace(/\/$/, '')}/health`, {
+            signal: AbortSignal.timeout(5000),
+            headers: host.authToken ? { 'X-Hub-Auth': host.authToken } : {},
+        });
+        const latencyMs = Date.now() - start;
+        return {
+            id: host.id,
+            label: host.label,
+            url: host.url,
+            status: resp.ok ? 'online' : 'degraded',
+            latencyMs,
+            lastPingAt: new Date().toISOString(),
+        };
+    }
+    catch {
+        return {
+            id: host.id,
+            label: host.label,
+            url: host.url,
+            status: 'offline',
+            latencyMs: null,
+            lastPingAt: new Date().toISOString(),
+        };
+    }
+}
 function normalizeReviewArtifact(raw, index = 0) {
     if (!raw || typeof raw !== 'object')
         return null;
@@ -289,6 +404,114 @@ function normalizeReviewHandoff(raw) {
     }
     return null;
 }
+const DELEGATION_TASK_STATUSES = new Set([
+    'planned',
+    'running',
+    'submitted',
+    'reviewed',
+    'blocked',
+    'completed',
+    'failed',
+]);
+function cleanString(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+function cleanNullableString(value) {
+    const cleaned = cleanString(value);
+    return cleaned.length > 0 ? cleaned : null;
+}
+function normalizeDelegationLedger(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const value = raw;
+    // Accept delegationRequired:true OR presence of goal/objective + tasks/jobs/groups (AI may omit the flag).
+    const hasFlag = value.delegationRequired === true;
+    const objective = cleanString((value.objective || value.goal));
+    if (!hasFlag && !objective)
+        return null;
+    if (!objective)
+        return null;
+    // Flatten tasks from multiple schemas:
+    //   canonical: tasks/jobs: [{title, taskId, personaKey, jobId, instructions, dependsOn}]
+    //   group-based: groups: [{runs: [{run_id, job, persona, briefing, expected_artifact}]}]
+    //   with optional depends_on referencing other run_id values
+    let rawTasks = [];
+    const rawJobs = (value.jobs || value.tasks);
+    if (Array.isArray(rawJobs)) {
+        rawTasks = rawJobs;
+    }
+    else if (Array.isArray(value.groups)) {
+        // Flatten groups[].runs into a linear task list, resolving depends_on from group membership.
+        let groupDepIds = [];
+        for (const group of value.groups) {
+            const runs = Array.isArray(group.runs) ? group.runs : [];
+            const currentIds = runs.map((r) => cleanString(r.run_id) || '').filter(Boolean);
+            for (const run of runs) {
+                // Synthesise a canonical task from the run schema.
+                const dependsOnRaw = Array.isArray(group.depends_on) ? group.depends_on.map(String) : groupDepIds.length ? groupDepIds : [];
+                rawTasks.push({
+                    taskId: run.run_id,
+                    title: cleanString(run.briefing)?.slice(0, 80) || cleanString(run.job) || 'Task',
+                    personaKey: run.persona,
+                    jobId: run.job,
+                    instructions: run.briefing,
+                    dependsOn: dependsOnRaw,
+                    status: 'planned',
+                });
+            }
+            groupDepIds = currentIds;
+        }
+    }
+    const tasks = rawTasks.map((task, index) => {
+        if (!task || typeof task !== 'object')
+            return null;
+        const rawTask = task;
+        // Accept title or first 80 chars of briefing/instructions
+        const title = cleanString((rawTask.title || rawTask.briefing || rawTask.instructions))?.slice(0, 80);
+        if (!title)
+            return null;
+        const taskId = cleanString((rawTask.taskId || rawTask.run_id || rawTask.id))
+            || title.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '')
+            || `task-${index + 1}`;
+        const rawStatus = cleanString(rawTask.status);
+        const status = DELEGATION_TASK_STATUSES.has(rawStatus) ? rawStatus : 'planned';
+        const artifacts = Array.isArray(rawTask.artifacts)
+            ? rawTask.artifacts.map((a, ai) => normalizeReviewArtifact(a, ai)).filter((a) => Boolean(a))
+            : [];
+        const reviewHandoff = normalizeReviewHandoff(rawTask.reviewHandoff);
+        // Accept dependsOn or depends_on as string array
+        const rawDeps = rawTask.dependsOn || rawTask.depends_on;
+        return {
+            taskId,
+            title,
+            status,
+            personaKey: cleanNullableString((rawTask.personaKey || rawTask.persona)),
+            jobId: cleanNullableString((rawTask.jobId || rawTask.job || rawTask.job_id)),
+            reviewJobId: cleanNullableString(rawTask.reviewJobId),
+            reviewType: cleanNullableString(rawTask.reviewType),
+            instructions: cleanString((rawTask.instructions || rawTask.briefing)) || undefined,
+            latestSummary: cleanString(rawTask.latestSummary) || undefined,
+            hostThreadId: cleanNullableString(rawTask.hostThreadId),
+            hostSessionId: cleanNullableString(rawTask.hostSessionId),
+            runId: cleanNullableString(rawTask.runId),
+            conversationId: cleanNullableString(rawTask.conversationId),
+            dependsOn: Array.isArray(rawDeps) ? rawDeps.map(String).filter(Boolean) : [],
+            artifacts,
+            reviewHandoff,
+        };
+    }).filter((task) => Boolean(task));
+    if (tasks.length === 0)
+        return null;
+    return {
+        delegationRequired: true,
+        objective,
+        orchestratorPersonaKey: cleanNullableString((value.orchestratorPersonaKey || value.manager_persona)),
+        rootRunId: cleanNullableString(value.rootRunId),
+        managerRunId: cleanNullableString((value.managerRunId || value.manager_session)),
+        latestSummary: cleanString(value.latestSummary) || undefined,
+        tasks,
+    };
+}
 function extractReviewHandoffFromText(text) {
     if (!text || !/reviewRequired|reviewTarget|review_handoff/i.test(text))
         return null;
@@ -313,36 +536,102 @@ function extractReviewHandoffFromText(text) {
     }
     return null;
 }
-const ARTIFACT_PATH_RE = /([A-Za-z0-9_\-.\\/]*?(?:docs|public|src|tests)[\\/][A-Za-z0-9_\-.\\/]+\.[A-Za-z0-9]+)/;
+function extractDelegationLedgerFromText(text) {
+    if (!text || !/delegationRequired|delegation_ledger|delegationLedger|"goal"\s*:.*"groups"\s*:/is.test(text))
+        return null;
+    const candidates = [];
+    for (const match of String(text).matchAll(/```(?:json)?\s*([\s\S]*?)```/gi))
+        candidates.push(match[1]);
+    const tagged = String(text).match(/<delegation_ledger>\s*([\s\S]*?)\s*<\/delegation_ledger>/i);
+    if (tagged)
+        candidates.push(tagged[1]);
+    const inline = String(text).match(/(\{\s*"delegationRequired"[\s\S]*\})/i);
+    if (inline)
+        candidates.push(inline[1]);
+    for (const candidate of candidates) {
+        try {
+            const ledger = normalizeDelegationLedger(JSON.parse(candidate.trim()));
+            if (ledger)
+                return ledger;
+        }
+        catch {
+            // Malformed delegation snippets are ignored; the host transcript remains available in Micro-manage.
+        }
+    }
+    return null;
+}
 const ARTIFACT_EXCLUDE_RE = /(^|[\\/])(retrospectives|evidence|learnings|mocks|raw|archive)[\\/]/i;
-function extractReviewArtifactFromText(text, projectPath) {
+function extractReviewArtifactsFromText(text, projectPath) {
     if (!text)
-        return null;
-    const match = text.match(ARTIFACT_PATH_RE);
-    if (!match)
-        return null;
-    const relativePath = match[1].replace(/\\/g, '/');
-    if (ARTIFACT_EXCLUDE_RE.test(relativePath))
-        return null;
-    const parts = relativePath.split('/').filter(Boolean);
-    const name = parts[parts.length - 1] || relativePath;
-    const artifactPath = path_1.default.isAbsolute(relativePath) ? relativePath : path_1.default.join(projectPath, relativePath);
-    return { type: path_1.default.extname(name).replace(/^\./, '') || 'file', label: name, path: artifactPath };
+        return [];
+    const artifacts = [];
+    const seen = new Set();
+    const matches = String(text)
+        .split(/[\s`"'()<>{}\[\],;:]+/)
+        .filter((token) => /^(docs|public|src|tests)[\\/]/.test(token));
+    for (const candidate of matches) {
+        const relativePath = candidate.replace(/[.)]+$/g, '').replace(/\\/g, '/');
+        if (!/\.[A-Za-z0-9]+$/.test(relativePath))
+            continue;
+        if (ARTIFACT_EXCLUDE_RE.test(relativePath))
+            continue;
+        const parts = relativePath.split('/').filter(Boolean);
+        const name = parts[parts.length - 1] || relativePath;
+        const artifactPath = path_1.default.isAbsolute(relativePath) ? relativePath : path_1.default.join(projectPath, relativePath);
+        if (seen.has(artifactPath))
+            continue;
+        seen.add(artifactPath);
+        artifacts.push({ type: path_1.default.extname(name).replace(/^\./, '') || 'file', label: name, path: artifactPath });
+    }
+    return artifacts;
 }
 function applyReviewProjection(run, text) {
+    const delegation = extractDelegationLedgerFromText(text);
+    if (delegation) {
+        run.delegation = {
+            ...delegation,
+            rootRunId: delegation.rootRunId || run.id,
+            managerRunId: delegation.managerRunId || run.id,
+        };
+    }
     const handoff = extractReviewHandoffFromText(text);
     if (handoff) {
         run.reviewHandoff = handoff;
         run.artifacts = handoff.artifacts;
         return;
     }
-    const artifact = extractReviewArtifactFromText(text, run.projectPath);
-    if (!artifact)
+    const artifacts = extractReviewArtifactsFromText(text, run.projectPath);
+    if (!artifacts.length)
         return;
     run.artifacts = run.artifacts || [];
-    if (!run.artifacts.some((entry) => entry.path === artifact.path || entry.url === artifact.url)) {
-        run.artifacts.push(artifact);
+    for (const artifact of artifacts) {
+        if (!run.artifacts.some((entry) => (entry.path && artifact.path && entry.path === artifact.path) || (entry.url && artifact.url && entry.url === artifact.url))) {
+            run.artifacts.push(artifact);
+        }
+    }
+}
+function mergeReviewArtifacts(existing, discovered) {
+    const merged = [...(existing || [])];
+    for (const artifact of discovered) {
+        if (!merged.some((entry) => (entry.path && artifact.path && entry.path === artifact.path) || (entry.url && artifact.url && entry.url === artifact.url))) {
+            merged.push(artifact);
+        }
+    }
+    return merged;
+}
+function extractRunReviewArtifacts(run) {
+    const discovered = [];
+    for (const message of run.messages || []) {
+        if (message.role !== 'employee')
+            continue;
+        discovered.push(...extractReviewArtifactsFromText(message.text, run.projectPath));
+    }
+    for (const event of run.events || []) {
+        if (event.channel !== 'stdout')
+            continue;
+        discovered.push(...extractReviewArtifactsFromText(event.text, run.projectPath));
     }
+    return mergeReviewArtifacts(run.artifacts, discovered);
 }
 function emptyTotals() {
     return {
@@ -408,6 +697,12 @@ function applyAgentIdentitySignal(run, identity) {
     run.agentName = identity.agentName;
     run.agentModel = identity.agentModel;
 }
+function stripStructuredHostPayloads(text) {
+    return text
+        .replace(/<delegation_ledger>\s*[\s\S]*?\s*<\/delegation_ledger>/gi, '')
+        .replace(/<review_handoff>\s*[\s\S]*?\s*<\/review_handoff>/gi, '')
+        .trim();
+}
 function appendHostMessage(run, hostId, event, channel) {
     if (!event.message || channel !== 'stdout')
         return;
@@ -417,10 +712,17 @@ function appendHostMessage(run, hostId, event, channel) {
         if (last?.role === 'employee') {
             last.text = `${last.text}\n${event.message}`;
             last.createdAt = new Date().toISOString();
+            applyReviewProjection(run, last.text);
+            last.text = stripStructuredHostPayloads(last.text);
+            if (!last.text)
+                run.messages.pop();
             return;
         }
     }
-    run.messages.push((0, hosts_1.createHubMessage)('employee', event.message));
+    const displayMessage = stripStructuredHostPayloads(event.message);
+    if (!displayMessage)
+        return;
+    run.messages.push((0, hosts_1.createHubMessage)('employee', displayMessage));
 }
 // Apply a parsed seekMentoring tool-use signal from the host stream to
 // the run state. Returns the updated currentPhase.
@@ -437,6 +739,16 @@ function applySeekMentoringSignal(run, signal) {
         return;
     if (signal.reviewHandoff)
         run.reviewHandoff = signal.reviewHandoff;
+    if (signal.delegationLedger &&
+        run.jobId === 'fully-delegate' &&
+        signal.phaseStatus === 'complete' &&
+        (signal.phaseId === 'confirm-or-fallback' || signal.phaseId === 'create-delegation-graph')) {
+        run.delegation = {
+            ...signal.delegationLedger,
+            rootRunId: signal.delegationLedger.rootRunId || run.id,
+            managerRunId: signal.delegationLedger.managerRunId || run.id,
+        };
+    }
     // Discriminant signals are routing hints only — they don't move the
     // tracker, but they do change which phase id will be considered
     // reachable next time stages are derived. Persist on the run.
@@ -792,9 +1104,13 @@ function countMarkdownFilesRecursive(dirPath) {
     return total;
 }
 class AiHubServer {
+    get hubBase() {
+        return process.env.FRAIM_HUB_BASE_URL || `http://127.0.0.1:${this.httpPort}`;
+    }
     constructor(options = {}) {
         this.app = (0, express_1.default)();
         this.runRegistry = new AiHubRunRegistry();
+        this.cronHandles = new Map();
         this.projectPath = options.projectPath || process.cwd();
         this.preferencesStore = options.preferencesStore || new preferences_1.AiHubPreferencesStore();
         this.conversationStore = options.conversationStore || new conversation_store_1.AiHubConversationStore();
@@ -817,7 +1133,9 @@ class AiHubServer {
             this.dbService = createDefaultDbService();
             this.ownsDbService = this.dbService !== undefined;
         }
-        this.app.use(express_1.default.json());
+        this.deploymentStore = options.deploymentStore ?? new DeploymentStore();
+        this.hostConfigStore = options.hostConfigStore ?? new HostConfigStore();
+        this.app.use(express_1.default.json({ limit: '10mb' }));
         if (this.dbService) {
             const { registerPaymentRoutes } = require('../routes/payment-routes');
             registerPaymentRoutes(this.app, () => this.paymentRepo ?? null, this.dbService);
@@ -961,6 +1279,8 @@ class AiHubServer {
         // so it's known even before the browser is running.
         process.env.FRAIM_BROWSER_CDP_ENDPOINT = this.managedBrowser.cdpEndpoint();
         process.env.FRAIM_HUB_BASE_URL = `http://127.0.0.1:${port}`;
+        // Issue #578: rehydrate active scheduled deployments from disk.
+        this.rehydrateScheduledDeployments();
         // Start HTTPS server when a cert bundle and port are provided.
         // Word Online requires HTTPS; the HTTPS server shares the same Express app
         // so all routes (including /word-taskpane/*) are available over both protocols.
@@ -987,10 +1307,19 @@ class AiHubServer {
     }
     async stop() {
         const closeServer = (srv) => new Promise((resolve, reject) => {
-            srv.close((error) => { if (error)
-                reject(error);
-            else
-                resolve(); });
+            const closable = srv;
+            closable.closeIdleConnections?.();
+            const forceCloseTimer = setTimeout(() => {
+                closable.closeIdleConnections?.();
+                closable.closeAllConnections?.();
+            }, 250);
+            srv.close((error) => {
+                clearTimeout(forceCloseTimer);
+                if (error)
+                    reject(error);
+                else
+                    resolve();
+            });
         });
         if (this.httpsServer) {
             await closeServer(this.httpsServer);
@@ -1000,6 +1329,11 @@ class AiHubServer {
             await closeServer(this.httpServer);
             this.httpServer = undefined;
         }
+        // Issue #578: stop all active scheduled deployments.
+        for (const [, task] of this.cronHandles) {
+            task.stop();
+        }
+        this.cronHandles.clear();
         // #521: tear down the shared browser if WE launched it (stop() no-ops on a
         // browser the manager owns).
         this.managedBrowser.stop();
@@ -1094,8 +1428,16 @@ class AiHubServer {
             })),
             artifacts: run.artifacts || [],
             reviewHandoff: run.reviewHandoff || null,
+            delegation: run.delegation || null,
+            delegationTaskId: run.delegationTaskId || null,
+            managedByRunId: run.managedByRunId || null,
+            managedByPersonaKey: run.managedByPersonaKey || null,
+            humanCoachingDisabled: run.humanCoachingDisabled || false,
+            managedReviewStatus: run.managedReviewStatus || null,
             compareMode: run.runRole === 'fraim' && run.compareRunId ? 'ab' : undefined,
             compareRunId: run.compareRunId || null,
+            // Issue #578: preserve trigger source so the UI can render the chip.
+            sourceTrigger: run.sourceTrigger,
         };
     }
     persistRunConversation(run, activeId) {
@@ -1109,6 +1451,280 @@ class AiHubServer {
     // Issue #512 (S3, R13) — derive the four Get-started step states, then let any
     // persisted `true` in ~/.fraim/{install-state,preferences}.json override the
     // derivation (so a completed step stays completed even if its signal vanishes).
+    maybeStartDelegatedChildRuns(managerRun) {
+        const ledger = managerRun.delegation;
+        if (!ledger || managerRun.managedByRunId)
+            return;
+        managerRun.orchestratedDelegationTaskIds = managerRun.orchestratedDelegationTaskIds || [];
+        const started = new Set(managerRun.orchestratedDelegationTaskIds);
+        for (const task of ledger.tasks || []) {
+            if (!task.taskId || started.has(task.taskId))
+                continue;
+            if (!task.jobId || !this.delegationDependenciesSatisfied(ledger, task.dependsOn || []))
+                continue;
+            if (!task.personaKey)
+                task.personaKey = getProtectedPersonaForHubJob(task.jobId);
+            this.startDelegatedChildRun(managerRun, task.taskId);
+            started.add(task.taskId);
+            managerRun.orchestratedDelegationTaskIds.push(task.taskId);
+        }
+    }
+    delegationDependenciesSatisfied(ledger, dependsOn) {
+        if (!dependsOn.length)
+            return true;
+        const terminal = new Set(['reviewed', 'completed']);
+        return dependsOn.every((dependency) => {
+            const matched = ledger.tasks.find((task) => task.taskId === dependency || task.jobId === dependency);
+            return !!matched && terminal.has(matched.status);
+        });
+    }
+    startDelegatedChildRun(managerRun, taskId) {
+        const ledger = managerRun.delegation;
+        const task = ledger?.tasks.find((entry) => entry.taskId === taskId);
+        if (!ledger || !task || !task.jobId)
+            return;
+        if (!task.personaKey)
+            task.personaKey = getProtectedPersonaForHubJob(task.jobId);
+        const resolvedJob = this.resolveHubJob(managerRun.projectPath, task.jobId);
+        if (!resolvedJob) {
+            task.status = 'blocked';
+            task.latestSummary = `Delegation blocked: job "${task.jobId}" is not available in this project.`;
+            managerRun.events.push((0, hosts_1.createHubEvent)('system', task.latestSummary));
+            this.persistRunConversation(managerRun, managerRun.conversationId || managerRun.id);
+            return;
+        }
+        const childConversationId = task.conversationId || `${managerRun.id}-${task.taskId}`;
+        const now = new Date().toISOString();
+        const childInstructions = [
+            task.instructions || task.latestSummary || `Complete the delegated workstream: ${task.title}.`,
+            '',
+            task.personaKey
+                ? `You are working as ${task.personaKey} for the manager job.`
+                : 'You are working as the specialist assigned by this delegated job.',
+            `Parent objective: ${ledger.objective}.`,
+            task.reviewJobId ? `Manager review route: this output should be reviewed using ${task.reviewJobId}.` : '',
+            'Submit a concise deliverable summary and any artifact references back to Mandy.',
+            'This is a delegated subtask, not an end-to-end FRAIM submission workflow. After you provide the deliverable for Mandy, stop. Do not create evidence docs, open or update PRs, update GitHub issues, or ask the human for review.',
+            'Do not ask the human for coaching; Mandy is your manager for this workstream.',
+        ].join('\n');
+        const prepared = this.prepareStartPayload(managerRun.projectPath, managerRun.hostId, task.jobId, childInstructions);
+        const childRun = {
+            id: (0, crypto_1.randomUUID)(),
+            conversationId: childConversationId,
+            conversationTitle: task.title,
+            jobTitle: task.title,
+            jobId: prepared.jobId || task.jobId,
+            hostId: managerRun.hostId,
+            projectPath: managerRun.projectPath,
+            status: 'running',
+            createdAt: now,
+            updatedAt: now,
+            messages: [(0, hosts_1.createHubMessage)('manager', `Mandy delegated: ${task.title}\n\n${childInstructions}`)],
+            events: [(0, hosts_1.createHubEvent)('system', `Mandy started delegated workstream ${task.taskId} for ${task.personaKey || task.jobId}.`)],
+            currentPhase: null,
+            phaseHistory: [],
+            totals: emptyTotals(),
+            lastStatusChangeAt: now,
+            personaKey: task.personaKey,
+            delegationTaskId: task.taskId,
+            managedByRunId: managerRun.id,
+            managedByPersonaKey: managerRun.personaKey || ledger.orchestratorPersonaKey || 'mandy',
+            humanCoachingDisabled: true,
+        };
+        task.runId = childRun.id;
+        task.conversationId = childConversationId;
+        task.status = 'running';
+        this.runRegistry.create(childRun, {});
+        this.persistRunConversation(childRun);
+        this.persistRunConversation(managerRun, managerRun.conversationId || managerRun.id);
+        const child = this.hostRuntime.startRun(managerRun.hostId, managerRun.projectPath, prepared.message, {
+            onEvent: (event, channel) => {
+                this.runRegistry.update(childRun.id, (current) => {
+                    if (event.sessionId)
+                        current.sessionId = event.sessionId;
+                    appendHostMessage(current, managerRun.hostId, event, channel);
+                    if (event.raw) {
+                        current.events.push((0, hosts_1.createHubEvent)(channel, event.raw));
+                        applyReviewProjection(current, event.raw);
+                    }
+                    if (event.agentIdentity)
+                        applyAgentIdentitySignal(current, event.agentIdentity);
+                    if (event.seekMentoring)
+                        applySeekMentoringSignal(current, event.seekMentoring);
+                    if (event.usage)
+                        applyUsageSignal(current, event.usage);
+                });
+                const updatedChild = this.runRegistry.get(childRun.id);
+                if (updatedChild)
+                    this.persistRunConversation(updatedChild);
+            },
+            onExit: (exitCode) => {
+                this.runRegistry.update(childRun.id, (current) => {
+                    current.exitCode = exitCode;
+                    current.status = exitCode === 0 ? 'completed' : 'failed';
+                    current.events.push((0, hosts_1.createHubEvent)('system', `Delegated workstream exited with code ${exitCode ?? 'unknown'}.`));
+                });
+                const updatedChild = this.runRegistry.get(childRun.id);
+                if (updatedChild) {
+                    this.persistRunConversation(updatedChild);
+                    this.markDelegatedChildSubmitted(managerRun.id, updatedChild);
+                    this.notifyManagerOfDelegatedChild(managerRun.id, updatedChild);
+                }
+                this.runRegistry.dispose(childRun.id);
+            },
+        }, childRun.sessionId);
+        this.runRegistry.attachChildIfRunning(childRun.id, child);
+    }
+    notifyManagerOfDelegatedChild(managerRunId, childRun) {
+        const managerRun = this.runRegistry.get(managerRunId);
+        if (!managerRun) {
+            childRun.events.push((0, hosts_1.createHubEvent)('system', 'Delegated deliverable could not be routed because the manager run is unavailable.'));
+            this.persistRunConversation(childRun);
+            return;
+        }
+        if (!managerRun.sessionId || managerRun.status === 'running') {
+            this.enqueueDelegatedReview(managerRun, childRun, !managerRun.sessionId ? 'manager session is unavailable' : 'manager is still running');
+            return;
+        }
+        const latest = [...(childRun.messages || [])].reverse().find((message) => message.role === 'employee')?.text || '';
+        const artifacts = childRun.reviewHandoff?.artifacts?.map((artifact) => artifact.label || artifact.path || artifact.url).filter(Boolean).join(', ') || 'none reported';
+        const reviewPrompt = [
+            `Delegated workstream submitted by ${childRun.personaKey || 'a peer agent'}: ${childRun.conversationTitle || childRun.jobTitle || childRun.jobId}.`,
+            `Status: ${childRun.status}.`,
+            `Latest deliverable summary: ${latest || 'No employee summary captured.'}`,
+            `Artifacts: ${artifacts}.`,
+            childRun.delegationTaskId ? this.delegatedReviewRouteLine(managerRun, childRun.delegationTaskId) : '',
+            '',
+            'As Mandy, review this child deliverable. If it is acceptable, say it is reviewed for synthesis. If it needs correction, write specific coaching feedback for that child workstream.',
+        ].join('\n');
+        this.continueManagerRunForDelegation(managerRun, reviewPrompt, `Mandy reviews ${childRun.conversationTitle || childRun.jobTitle || childRun.jobId}`, childRun);
+    }
+    delegatedReviewRouteLine(managerRun, taskId) {
+        const task = managerRun.delegation?.tasks.find((entry) => entry.taskId === taskId);
+        if (!task?.reviewJobId)
+            return '';
+        return `Declared manager review job: ${task.reviewJobId}${task.reviewType ? ` (${task.reviewType})` : ''}. Use that review standard when judging the deliverable.`;
+    }
+    enqueueDelegatedReview(managerRun, childRun, reason) {
+        managerRun.pendingDelegatedReviewChildRunIds = managerRun.pendingDelegatedReviewChildRunIds || [];
+        if (!managerRun.pendingDelegatedReviewChildRunIds.includes(childRun.id)) {
+            managerRun.pendingDelegatedReviewChildRunIds.push(childRun.id);
+            managerRun.events.push((0, hosts_1.createHubEvent)('system', `Delegated deliverable queued for Mandy review because ${reason}.`));
+        }
+        childRun.events.push((0, hosts_1.createHubEvent)('system', `Deliverable submitted to Mandy; review is queued because ${reason}.`));
+        this.persistRunConversation(managerRun, managerRun.conversationId || managerRun.id);
+        this.persistRunConversation(childRun);
+    }
+    drainPendingDelegatedReviews(managerRun) {
+        if (managerRun.status === 'running' || !managerRun.sessionId)
+            return;
+        const queue = managerRun.pendingDelegatedReviewChildRunIds || [];
+        while (queue.length > 0) {
+            const childRunId = queue.shift();
+            const childRun = this.runRegistry.get(childRunId);
+            if (!childRun || childRun.managedReviewStatus === 'reviewed')
+                continue;
+            managerRun.pendingDelegatedReviewChildRunIds = queue;
+            this.persistRunConversation(managerRun, managerRun.conversationId || managerRun.id);
+            this.notifyManagerOfDelegatedChild(managerRun.id, childRun);
+            return;
+        }
+        managerRun.pendingDelegatedReviewChildRunIds = queue;
+        this.persistRunConversation(managerRun, managerRun.conversationId || managerRun.id);
+    }
+    markDelegatedChildSubmitted(managerRunId, childRun) {
+        const managerRun = this.runRegistry.get(managerRunId);
+        if (!managerRun?.delegation)
+            return;
+        const task = managerRun.delegation.tasks.find((entry) => entry.taskId === childRun.delegationTaskId || entry.runId === childRun.id);
+        if (!task)
+            return;
+        task.status = childRun.status === 'completed' ? 'submitted' : 'failed';
+        const latest = [...(childRun.messages || [])].reverse().find((message) => message.role === 'employee')?.text || '';
+        if (latest)
+            task.latestSummary = latest;
+        if (childRun.reviewHandoff)
+            task.reviewHandoff = childRun.reviewHandoff;
+        const artifacts = childRun.reviewHandoff?.artifacts?.length ? childRun.reviewHandoff.artifacts : childRun.artifacts || [];
+        if (artifacts.length)
+            task.artifacts = artifacts;
+        this.persistRunConversation(managerRun, managerRun.conversationId || managerRun.id);
+    }
+    markDelegatedChildReviewed(childRun, managerRun) {
+        const reviewText = [...(managerRun.messages || [])].reverse().find((message) => message.role === 'employee')?.text || '';
+        childRun.managedReviewStatus = 'reviewed';
+        childRun.updatedAt = new Date().toISOString();
+        if (reviewText) {
+            childRun.messages.push((0, hosts_1.createHubMessage)('manager', `Mandy reviewed this workstream:\n\n${reviewText}`));
+        }
+        childRun.events.push((0, hosts_1.createHubEvent)('system', 'Mandy reviewed the delegated deliverable.'));
+        this.persistRunConversation(childRun);
+        const task = managerRun.delegation?.tasks.find((entry) => entry.taskId === childRun.delegationTaskId || entry.runId === childRun.id);
+        if (task) {
+            task.status = 'reviewed';
+            task.latestSummary = reviewText || task.latestSummary;
+            if (childRun.reviewHandoff)
+                task.reviewHandoff = childRun.reviewHandoff;
+            const artifacts = childRun.reviewHandoff?.artifacts?.length ? childRun.reviewHandoff.artifacts : childRun.artifacts || [];
+            if (artifacts.length)
+                task.artifacts = artifacts;
+        }
+        this.maybeStartDelegatedChildRuns(managerRun);
+    }
+    continueManagerRunForDelegation(managerRun, instructions, display, reviewedChildRun) {
+        if (!managerRun.sessionId || managerRun.status === 'running')
+            return;
+        const prepared = this.prepareContinueMessage(managerRun, instructions);
+        this.runRegistry.update(managerRun.id, (current) => {
+            current.status = 'running';
+            current.messages.push((0, hosts_1.createHubMessage)('manager', display));
+            current.events.push((0, hosts_1.createHubEvent)('system', 'Delegated child output routed back to Mandy for review.'));
+        });
+        const started = this.runRegistry.get(managerRun.id);
+        if (started)
+            this.persistRunConversation(started, started.conversationId || started.id);
+        this.runRegistry.create(managerRun, {});
+        const child = this.hostRuntime.continueRun(managerRun.hostId, managerRun.projectPath, managerRun.sessionId, prepared.message, {
+            onEvent: (event, channel) => {
+                this.runRegistry.update(managerRun.id, (current) => {
+                    if (event.sessionId)
+                        current.sessionId = event.sessionId;
+                    appendHostMessage(current, managerRun.hostId, event, channel);
+                    if (event.raw) {
+                        current.events.push((0, hosts_1.createHubEvent)(channel, event.raw));
+                        applyReviewProjection(current, event.raw);
+                    }
+                    if (event.agentIdentity)
+                        applyAgentIdentitySignal(current, event.agentIdentity);
+                    if (event.seekMentoring)
+                        applySeekMentoringSignal(current, event.seekMentoring);
+                    if (event.usage)
+                        applyUsageSignal(current, event.usage);
+                });
+                const updated = this.runRegistry.get(managerRun.id);
+                if (updated)
+                    this.persistRunConversation(updated, updated.conversationId || updated.id);
+            },
+            onExit: (exitCode) => {
+                this.runRegistry.update(managerRun.id, (current) => {
+                    current.exitCode = exitCode;
+                    current.status = exitCode === 0 ? 'completed' : 'failed';
+                    current.events.push((0, hosts_1.createHubEvent)('system', `Mandy review turn exited with code ${exitCode ?? 'unknown'}.`));
+                });
+                const updated = this.runRegistry.get(managerRun.id);
+                if (updated) {
+                    if (exitCode === 0 && reviewedChildRun)
+                        this.markDelegatedChildReviewed(reviewedChildRun, updated);
+                    this.persistRunConversation(updated, updated.conversationId || updated.id);
+                }
+                this.runRegistry.dispose(managerRun.id);
+                const latestManager = this.runRegistry.get(managerRun.id);
+                if (latestManager)
+                    this.drainPendingDelegatedReviews(latestManager);
+            },
+        });
+        this.runRegistry.attachChildIfRunning(managerRun.id, child);
+    }
     computeFirstRun(projectPath, jobCount, personas) {
         const tc = (0, learning_context_builder_1.resolveTeamContextFiles)(projectPath);
         // company = any organization-layer context written by org onboarding.
@@ -1827,8 +2443,10 @@ class AiHubServer {
                                 applyUsageSignal(current, event.usage);
                         });
                         const updated = this.runRegistry.get(run.id);
-                        if (updated)
+                        if (updated) {
+                            this.maybeStartDelegatedChildRuns(updated);
                             this.persistRunConversation(updated, updated.conversationId || updated.id);
+                        }
                     },
                     onExit: (exitCode) => {
                         this.runRegistry.update(run.id, (current) => {
@@ -1844,12 +2462,17 @@ class AiHubServer {
                             }
                         });
                         const updated = this.runRegistry.get(run.id);
-                        if (updated)
+                        if (updated) {
+                            this.maybeStartDelegatedChildRuns(updated);
                             this.persistRunConversation(updated, updated.conversationId || updated.id);
+                        }
                         this.runRegistry.dispose(run.id);
+                        const latest = this.runRegistry.get(run.id);
+                        if (latest)
+                            this.drainPendingDelegatedReviews(latest);
                     },
                 }, run.sessionId);
-                this.runRegistry.create(run, child);
+                this.runRegistry.attachChildIfRunning(run.id, child);
                 // Issue #442: spawn the Direct run via startDirectRun so CliHostRuntime
                 // uses buildDirectStartPlan (--strict-mcp-config, raw stdin) rather than
                 // the FRAIM-wrapping buildStartPlan path.
@@ -1878,7 +2501,7 @@ class AiHubServer {
                             this.runRegistry.dispose(directId);
                         },
                     }, directRun.sessionId);
-                    this.runRegistry.create(directRun, directChild);
+                    this.runRegistry.attachChildIfRunning(directRun.id, directChild);
                 }
                 const existingPreferences = this.preferencesStore.load(projectPath);
                 this.preferencesStore.remember({
@@ -2009,8 +2632,10 @@ class AiHubServer {
                                 applyUsageSignal(current, event.usage);
                         });
                         const updated = this.runRegistry.get(run.id);
-                        if (updated)
+                        if (updated) {
+                            this.maybeStartDelegatedChildRuns(updated);
                             this.persistRunConversation(updated, updated.conversationId || updated.id);
+                        }
                     },
                     onExit: (exitCode) => {
                         this.runRegistry.update(run.id, (current) => {
@@ -2019,12 +2644,17 @@ class AiHubServer {
                             current.events.push((0, hosts_1.createHubEvent)('system', `Run exited with code ${exitCode ?? 'unknown'}.`));
                         });
                         const updated = this.runRegistry.get(run.id);
-                        if (updated)
+                        if (updated) {
+                            this.maybeStartDelegatedChildRuns(updated);
                             this.persistRunConversation(updated, updated.conversationId || updated.id);
+                        }
                         this.runRegistry.dispose(run.id);
+                        const latest = this.runRegistry.get(run.id);
+                        if (latest)
+                            this.drainPendingDelegatedReviews(latest);
                     },
                 });
-                this.runRegistry.create(run, child);
+                this.runRegistry.attachChildIfRunning(run.id, child);
                 const refreshed = this.runRegistry.get(run.id);
                 res.json(refreshed ? this.enrichRunForResponse(refreshed) : refreshed);
             }
@@ -2110,9 +2740,12 @@ class AiHubServer {
                         if (updated)
                             this.persistRunConversation(updated, updated.conversationId || updated.id);
                         this.runRegistry.dispose(run.id);
+                        const latest = this.runRegistry.get(run.id);
+                        if (latest)
+                            this.drainPendingDelegatedReviews(latest);
                     },
                 });
-                this.runRegistry.create(run, child);
+                this.runRegistry.attachChildIfRunning(run.id, child);
                 res.status(201).json(this.enrichRunForResponse(this.runRegistry.get(run.id) ?? run));
             }
             catch (error) {
@@ -2158,7 +2791,7 @@ class AiHubServer {
                         this.runRegistry.dispose(run.id);
                     },
                 });
-                this.runRegistry.create(run, child);
+                this.runRegistry.attachChildIfRunning(run.id, child);
                 const refreshed = this.runRegistry.get(run.id);
                 res.json(refreshed ? this.enrichRunForResponse(refreshed) : refreshed);
             }
@@ -2181,6 +2814,27 @@ class AiHubServer {
             runs = runs.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt)).slice(0, limit);
             return res.json(runs.map((r) => this.enrichRunForResponse(r)));
         });
+        // ─── Issue #578: /api/ai-hub/runs/merged must be registered BEFORE :runId ──
+        this.app.get('/api/ai-hub/runs/merged', async (req, res) => {
+            const local = this.runRegistry.all().map((r) => this.enrichRunForResponse(r));
+            const hosts = this.hostConfigStore.load();
+            const remoteResults = await Promise.allSettled(hosts.map(async (host) => {
+                const url = `${host.url.replace(/\/$/, '')}/api/ai-hub/runs`;
+                const resp = await fetch(url, {
+                    signal: AbortSignal.timeout(8000),
+                    headers: host.authToken ? { 'X-Hub-Auth': host.authToken } : {},
+                });
+                if (!resp.ok)
+                    return [];
+                return resp.json();
+            }));
+            const remote = remoteResults
+                .filter((r) => r.status === 'fulfilled')
+                .flatMap((r) => r.value);
+            const merged = [...local, ...remote].sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+            return res.json(merged);
+        });
+        // GET /api/ai-hub/runs/:runId — registered AFTER /merged to avoid shadowing.
         this.app.get('/api/ai-hub/runs/:runId', (req, res) => {
             const run = this.runRegistry.get(req.params.runId);
             if (!run) {
@@ -2188,6 +2842,216 @@ class AiHubServer {
             }
             return res.json(this.enrichRunForResponse(run));
         });
+        // ─── Issue #578: Scheduled + Reactive Employees ───────────────────────────
+        // POST /api/ai-hub/schedules — create a recurring scheduled deployment.
+        this.app.post('/api/ai-hub/schedules', (req, res) => {
+            const { label, jobId, projectPath, hostId, cronExpr, instructions, outputChannel, allowConcurrent } = req.body ?? {};
+            if (!label || !jobId || !cronExpr) {
+                return res.status(400).json({ error: 'label, jobId, and cronExpr are required.' });
+            }
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const cronLib = require('node-cron');
+            if (!cronLib.validate(cronExpr)) {
+                return res.status(400).json({ error: 'Invalid cron expression.' });
+            }
+            const validEmployees = VALID_EMPLOYEE_IDS;
+            const resolvedHostId = validEmployees.includes(hostId) ? hostId : 'claude';
+            const now = new Date().toISOString();
+            const deployment = {
+                id: (0, crypto_1.randomUUID)(),
+                type: 'scheduled',
+                label,
+                jobId,
+                projectPath: ensureDirectoryPath(projectPath || this.projectPath),
+                hostId: resolvedHostId,
+                cronExpr,
+                instructions: typeof instructions === 'string' ? instructions : undefined,
+                outputChannel: typeof outputChannel === 'string' ? outputChannel : undefined,
+                allowConcurrent: allowConcurrent === true,
+                active: true,
+                createdAt: now,
+                updatedAt: now,
+            };
+            this.deploymentStore.create(deployment);
+            this.scheduleDeployment(deployment);
+            return res.status(201).json(deployment);
+        });
+        // GET /api/ai-hub/schedules — list all scheduled deployments.
+        this.app.get('/api/ai-hub/schedules', (_req, res) => {
+            return res.json(this.deploymentStore.load().filter((d) => d.type === 'scheduled'));
+        });
+        // DELETE /api/ai-hub/schedules/:id — remove a scheduled deployment.
+        this.app.delete('/api/ai-hub/schedules/:id', (req, res) => {
+            const { id } = req.params;
+            const task = this.cronHandles.get(id);
+            if (task) {
+                task.stop();
+                this.cronHandles.delete(id);
+            }
+            const deleted = this.deploymentStore.delete(id);
+            if (!deleted)
+                return res.status(404).json({ error: 'Deployment not found.' });
+            return res.json({ ok: true });
+        });
+        // PUT /api/ai-hub/schedules/:id — update an existing scheduled deployment.
+        this.app.put('/api/ai-hub/schedules/:id', (req, res) => {
+            const { id } = req.params;
+            const { label, jobId, cronExpr, hostId, instructions, allowConcurrent } = req.body ?? {};
+            if (cronExpr !== undefined) {
+                // eslint-disable-next-line @typescript-eslint/no-var-requires
+                const cronLib = require('node-cron');
+                if (!cronLib.validate(cronExpr)) {
+                    return res.status(400).json({ error: 'Invalid cron expression.' });
+                }
+            }
+            const validEmployees = VALID_EMPLOYEE_IDS;
+            let updated = null;
+            const ok = this.deploymentStore.update(id, (dep) => {
+                if (label !== undefined)
+                    dep.label = label;
+                if (jobId !== undefined)
+                    dep.jobId = jobId;
+                if (cronExpr !== undefined)
+                    dep.cronExpr = cronExpr;
+                if (hostId !== undefined && validEmployees.includes(hostId))
+                    dep.hostId = hostId;
+                if (instructions !== undefined)
+                    dep.instructions = typeof instructions === 'string' ? instructions : undefined;
+                if (allowConcurrent !== undefined)
+                    dep.allowConcurrent = allowConcurrent === true;
+                updated = dep;
+            });
+            if (!ok || !updated)
+                return res.status(404).json({ error: 'Deployment not found.' });
+            const oldTask = this.cronHandles.get(id);
+            if (oldTask) {
+                oldTask.stop();
+                this.cronHandles.delete(id);
+            }
+            this.scheduleDeployment(updated);
+            return res.json(updated);
+        });
+        // POST /api/ai-hub/webhooks — register an inbound webhook deployment.
+        this.app.post('/api/ai-hub/webhooks', (req, res) => {
+            const { label, jobId, projectPath, hostId, instructions, outputChannel, allowConcurrent } = req.body ?? {};
+            if (!label || !jobId) {
+                return res.status(400).json({ error: 'label and jobId are required.' });
+            }
+            const validEmployees = VALID_EMPLOYEE_IDS;
+            const resolvedHostId = validEmployees.includes(hostId) ? hostId : 'claude';
+            const now = new Date().toISOString();
+            const deployment = {
+                id: (0, crypto_1.randomUUID)(),
+                type: 'webhook',
+                label,
+                jobId,
+                projectPath: ensureDirectoryPath(projectPath || this.projectPath),
+                hostId: resolvedHostId,
+                instructions: typeof instructions === 'string' ? instructions : undefined,
+                outputChannel: typeof outputChannel === 'string' ? outputChannel : undefined,
+                allowConcurrent: allowConcurrent === true,
+                active: true,
+                createdAt: now,
+                updatedAt: now,
+            };
+            this.deploymentStore.create(deployment);
+            return res.status(201).json({ ...deployment, inboundUrl: `${this.hubBase}/api/ai-hub/webhooks/${deployment.id}/inbound` });
+        });
+        // GET /api/ai-hub/webhooks — list all webhook deployments.
+        this.app.get('/api/ai-hub/webhooks', (_req, res) => {
+            const hubBase = this.hubBase;
+            return res.json(this.deploymentStore.load()
+                .filter((d) => d.type === 'webhook')
+                .map((d) => ({ ...d, inboundUrl: `${hubBase}/api/ai-hub/webhooks/${d.id}/inbound` })));
+        });
+        // DELETE /api/ai-hub/webhooks/:id — remove a webhook deployment.
+        this.app.delete('/api/ai-hub/webhooks/:id', (req, res) => {
+            const deleted = this.deploymentStore.delete(req.params.id);
+            if (!deleted)
+                return res.status(404).json({ error: 'Deployment not found.' });
+            return res.json({ ok: true });
+        });
+        // PUT /api/ai-hub/webhooks/:id — update an existing webhook deployment.
+        this.app.put('/api/ai-hub/webhooks/:id', (req, res) => {
+            const { id } = req.params;
+            const { label, jobId, hostId, instructions, allowConcurrent } = req.body ?? {};
+            const validEmployees = VALID_EMPLOYEE_IDS;
+            let updated = null;
+            const ok = this.deploymentStore.update(id, (dep) => {
+                if (label !== undefined)
+                    dep.label = label;
+                if (jobId !== undefined)
+                    dep.jobId = jobId;
+                if (hostId !== undefined && validEmployees.includes(hostId))
+                    dep.hostId = hostId;
+                if (instructions !== undefined)
+                    dep.instructions = typeof instructions === 'string' ? instructions : undefined;
+                if (allowConcurrent !== undefined)
+                    dep.allowConcurrent = allowConcurrent === true;
+                updated = dep;
+            });
+            if (!ok || !updated)
+                return res.status(404).json({ error: 'Deployment not found.' });
+            return res.json({ ...updated, inboundUrl: `${this.hubBase}/api/ai-hub/webhooks/${id}/inbound` });
+        });
+        // POST /api/ai-hub/webhooks/:id/inbound — webhook inbound trigger from external systems.
+        this.app.post('/api/ai-hub/webhooks/:id/inbound', async (req, res) => {
+            const deployments = this.deploymentStore.load();
+            const deployment = deployments.find((d) => d.id === req.params.id && d.type === 'webhook' && d.active);
+            if (!deployment) {
+                return res.status(404).json({ error: 'Webhook not found or inactive.' });
+            }
+            try {
+                const run = await this.fireDeploymentRun(deployment, req.body);
+                return res.status(202).json({ runId: run.id, status: run.status });
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : 'Failed to start run.';
+                return res.status(500).json({ error: msg });
+            }
+        });
+        // GET /api/ai-hub/hosts — list registered remote hosts with health status.
+        this.app.get('/api/ai-hub/hosts', async (_req, res) => {
+            const hosts = this.hostConfigStore.load();
+            const healthResults = await Promise.allSettled(hosts.map((h) => pingHost(h)));
+            const health = healthResults.map((r, i) => r.status === 'fulfilled'
+                ? r.value
+                : { id: hosts[i].id, label: hosts[i].label, url: hosts[i].url, status: 'offline', latencyMs: null, lastPingAt: new Date().toISOString() });
+            return res.json(health);
+        });
+        // POST /api/ai-hub/hosts — register a named remote hub host.
+        this.app.post('/api/ai-hub/hosts', (req, res) => {
+            const { label, url, authToken } = req.body ?? {};
+            const validUrl = safeHttpUrl(url);
+            if (!label || !validUrl) {
+                return res.status(400).json({ error: 'label and a valid http(s) url are required.' });
+            }
+            const host = {
+                id: (0, crypto_1.randomUUID)(),
+                label,
+                url: validUrl,
+                authToken: typeof authToken === 'string' && authToken ? authToken : undefined,
+                createdAt: new Date().toISOString(),
+            };
+            this.hostConfigStore.add(host);
+            return res.status(201).json({ id: host.id, label: host.label, url: host.url, createdAt: host.createdAt });
+        });
+        // DELETE /api/ai-hub/hosts/:id — remove a named remote host.
+        this.app.delete('/api/ai-hub/hosts/:id', (req, res) => {
+            const deleted = this.hostConfigStore.delete(req.params.id);
+            if (!deleted)
+                return res.status(404).json({ error: 'Host not found.' });
+            return res.json({ ok: true });
+        });
+        // GET /api/ai-hub/hosts/:id/health — ping a single host.
+        this.app.get('/api/ai-hub/hosts/:id/health', async (req, res) => {
+            const host = this.hostConfigStore.load().find((h) => h.id === req.params.id);
+            if (!host)
+                return res.status(404).json({ error: 'Host not found.' });
+            const health = await pingHost(host);
+            return res.json(health);
+        });
+        // ─── End Issue #578 ───────────────────────────────────────────────────────
         // -------------------------------------------------------------------------
         // Issue #489: POST /api/trigger
         // Stable API endpoint for extension surfaces (Office add-ins, browser
@@ -2270,7 +3134,7 @@ class AiHubServer {
                     },
                 }, run.sessionId);
                 // Update the registry entry with the real child process handle.
-                this.runRegistry.create(run, child);
+                this.runRegistry.attachChildIfRunning(run.id, child);
                 return res.json({ runId: run.id, status: 'started', employee: employeeId, job: jobName });
             }
             catch (error) {
@@ -2286,6 +3150,121 @@ class AiHubServer {
         process.env.FRAIM_BROWSER_CDP_ENDPOINT = result.endpoint;
         return { endpoint: result.endpoint, reused: result.reused, channel: result.channel };
     }
+    // ─── Issue #578: Scheduled deployment helpers ─────────────────────────────
+    rehydrateScheduledDeployments() {
+        const active = this.deploymentStore.load().filter((d) => d.type === 'scheduled' && d.active);
+        for (const dep of active) {
+            this.scheduleDeployment(dep);
+        }
+        if (active.length > 0) {
+            console.log(`[ai-hub] rehydrated ${active.length} scheduled deployment(s)`);
+        }
+    }
+    scheduleDeployment(deployment) {
+        if (!deployment.cronExpr)
+            return;
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const cron = require('node-cron');
+            if (!cron.validate(deployment.cronExpr)) {
+                console.warn(`[ai-hub] invalid cronExpr for deployment ${deployment.id}: ${deployment.cronExpr}`);
+                return;
+            }
+            const task = cron.schedule(deployment.cronExpr, async () => {
+                try {
+                    await this.fireDeploymentRun(deployment);
+                }
+                catch (err) {
+                    console.warn(`[ai-hub] scheduled deployment ${deployment.id} fire failed:`, err);
+                }
+            });
+            this.cronHandles.set(deployment.id, task);
+        }
+        catch (err) {
+            console.warn('[ai-hub] node-cron not available — scheduled deployments require node-cron:', err);
+        }
+    }
+    async fireDeploymentRun(deployment, webhookBody) {
+        // Overlapping run guard: if the prior run is still active and allowConcurrent is false, skip.
+        if (!deployment.allowConcurrent && deployment.activeRunId) {
+            const active = this.runRegistry.get(deployment.activeRunId);
+            if (active && active.status === 'running') {
+                console.log(`[ai-hub] deployment ${deployment.id} skipped — prior run ${deployment.activeRunId} still running`);
+                return active;
+            }
+        }
+        const employees = this.hostRuntime.detectEmployees();
+        const employee = employees.find((e) => e.id === deployment.hostId);
+        if (!employee?.available) {
+            throw new Error(`Employee ${deployment.hostId} is not available for scheduled/webhook run.`);
+        }
+        const instructions = [
+            deployment.instructions ?? `/fraim ${deployment.jobId}`,
+            webhookBody ? `\n\nInbound payload:\n${JSON.stringify(webhookBody, null, 2)}` : '',
+        ].join('').trim();
+        const startTimestamp = new Date().toISOString();
+        const run = {
+            id: (0, crypto_1.randomUUID)(),
+            jobId: deployment.jobId,
+            hostId: deployment.hostId,
+            projectPath: deployment.projectPath,
+            status: 'running',
+            sourceTrigger: deployment.type === 'scheduled' ? 'scheduled' : 'webhook',
+            createdAt: startTimestamp,
+            updatedAt: startTimestamp,
+            messages: [(0, hosts_1.createHubMessage)('manager', instructions)],
+            events: [(0, hosts_1.createHubEvent)('system', `Triggered by deployment: ${deployment.label} (${deployment.type})`)],
+            currentPhase: null,
+            phaseHistory: [],
+            totals: emptyTotals(),
+            lastStatusChangeAt: startTimestamp,
+            // Deployment runs group under the selected employee (hostId), not the job's
+            // protected persona. Leaving personaKey unset lets conversationRecordFromRun
+            // fall through to agentName (= hostId), which is what the rail groups by.
+            personaKey: null,
+        };
+        // Pre-register before startRun so synchronous onEvent calls (e.g. FakeHostRuntime)
+        // can call runRegistry.update without "Run not found" throws.
+        this.runRegistry.create(run, {});
+        const child = this.hostRuntime.startRun(deployment.hostId, deployment.projectPath, instructions, {
+            onEvent: (event, channel) => {
+                this.runRegistry.update(run.id, (current) => {
+                    if (event.sessionId)
+                        current.sessionId = event.sessionId;
+                    appendHostMessage(current, deployment.hostId, event, channel);
+                    if (event.raw) {
+                        current.events.push((0, hosts_1.createHubEvent)(channel, event.raw));
+                        applyReviewProjection(current, event.raw);
+                    }
+                    if (event.agentIdentity)
+                        applyAgentIdentitySignal(current, event.agentIdentity);
+                    if (event.seekMentoring)
+                        applySeekMentoringSignal(current, event.seekMentoring);
+                    if (event.usage)
+                        applyUsageSignal(current, event.usage);
+                });
+                const updated = this.runRegistry.get(run.id);
+                if (updated)
+                    this.persistRunConversation(updated, updated.conversationId || updated.id);
+            },
+            onExit: (exitCode) => {
+                this.runRegistry.update(run.id, (r) => {
+                    r.exitCode = exitCode;
+                    r.status = exitCode === 0 ? 'completed' : 'failed';
+                    r.events.push((0, hosts_1.createHubEvent)('system', `Run exited with code ${exitCode ?? 'unknown'}.`));
+                });
+                const updated = this.runRegistry.get(run.id);
+                if (updated)
+                    this.persistRunConversation(updated, updated.conversationId || updated.id);
+                this.deploymentStore.update(deployment.id, (d) => { d.activeRunId = undefined; });
+                this.runRegistry.dispose(run.id);
+            },
+        });
+        this.runRegistry.create(run, child);
+        this.deploymentStore.update(deployment.id, (d) => { d.activeRunId = run.id; });
+        return run;
+    }
+    // ─── End Issue #578 helpers ───────────────────────────────────────────────
     // Issue #347 — assemble the read-side projection of a run. Stages are
     // derived from job frontmatter + visited phases; totalDurationMs ticks
     // forward while the run is still running so the UI's totals line
@@ -2326,7 +3305,7 @@ class AiHubServer {
                 liveTotals.waitingDurationMs = Math.max(0, liveTotals.waitingDurationMs - overflow);
             }
         }
-        return { ...run, stages, totals: liveTotals };
+        return { ...run, stages, totals: liveTotals, artifacts: extractRunReviewArtifacts(run) };
     }
 }
 exports.AiHubServer = AiHubServer;