fraim-hub 2.0.240 → 2.0.241

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

@@ -734,7 +734,8 @@ function resolveHostInvocation(plan) {
 // cannot drift on how the managed-agent bin directories are put on PATH.
 const versionProbeEnv = () => ({
     ...process.env,
-    PATH: (0, managed_agent_paths_1.buildPathWithManagedAgentBins)(process.env.PATH),
+    PATH: (0, managed_agent_paths_1.buildPathWithManagedAgentBins)(process.env.PATH ?? process.env.Path),
+    Path: (0, managed_agent_paths_1.buildPathWithManagedAgentBins)(process.env.PATH ?? process.env.Path),
 });
 const availableByVersionProbe = (command) => {
     const invocation = resolveHostInvocation({ command, args: ['--version'] });
@@ -806,10 +807,20 @@ const EMPLOYEE_DETECTION_TTL_MS = 5 * 60 * 1000;
 let employeeDetectionTtlMs = EMPLOYEE_DETECTION_TTL_MS;
 let cachedEmployees = null;
 let cachedEmployeesAtMs = 0;
+let cachedEmployeesContext = null;
 let inFlightDetection = null;
+function employeeDetectionContext() {
+    return JSON.stringify({
+        PATH: process.env.PATH || '',
+        Path: process.env.Path || '',
+        FRAIM_USER_DIR: process.env.FRAIM_USER_DIR || '',
+    });
+}
 function cachedEmployeesIfFresh() {
     if (!cachedEmployees)
         return null;
+    if (cachedEmployeesContext !== employeeDetectionContext())
+        return null;
     if (Date.now() - cachedEmployeesAtMs > employeeDetectionTtlMs)
         return null;
     return cachedEmployees;
@@ -831,6 +842,7 @@ function cachedEmployeesIfFresh() {
 // TTL lapses. That is recoverable and self-correcting, and is preferable to freezing every
 // cold start for 2.2s. Installs performed THROUGH the Hub invalidate explicitly.
 const AGENT_AVAILABILITY_FILE = 'hub-agent-availability.json';
+const AGENT_AVAILABILITY_SCHEMA_VERSION = 2;
 // Overridable so tests do not mutate the developer's real ~/.fraim state. These guards run
 // in the smoke suite now, and invalidation DELETES this file, so pointing them at a temp
 // path keeps a frequent test run from repeatedly clearing real agent-availability data.
@@ -850,6 +862,10 @@ function loadPersistedEmployees() {
     try {
         const raw = fs_1.default.readFileSync(agentAvailabilityFilePath(), 'utf8');
         const parsed = JSON.parse(raw);
+        if (parsed.schemaVersion !== AGENT_AVAILABILITY_SCHEMA_VERSION)
+            return null;
+        if (parsed.detectionContext !== employeeDetectionContext())
+            return null;
         if (!Array.isArray(parsed.employees) || parsed.employees.length === 0)
             return null;
         // Only accept entries that still match the current known agent ids, so a stale file
@@ -880,6 +896,7 @@ function loadPersistedEmployees() {
 function adoptPersistedEmployees(persisted) {
     cachedEmployees = persisted.employees;
     cachedEmployeesAtMs = persisted.detectedAtMs;
+    cachedEmployeesContext = employeeDetectionContext();
     if (Date.now() - persisted.detectedAtMs > employeeDetectionTtlMs) {
         void detectEmployeesAsync({ force: true }).catch(() => undefined);
     }
@@ -889,7 +906,12 @@ function persistEmployees(employees) {
     try {
         const file = agentAvailabilityFilePath();
         fs_1.default.mkdirSync(path_1.default.dirname(file), { recursive: true });
-        fs_1.default.writeFileSync(file, JSON.stringify({ employees, detectedAt: new Date().toISOString() }, null, 2), 'utf8');
+        fs_1.default.writeFileSync(file, JSON.stringify({
+            employees,
+            detectedAt: new Date().toISOString(),
+            detectionContext: employeeDetectionContext(),
+            schemaVersion: AGENT_AVAILABILITY_SCHEMA_VERSION,
+        }, null, 2), 'utf8');
     }
     catch {
         // Best effort only: failing to persist must never break detection.
@@ -898,6 +920,7 @@ function persistEmployees(employees) {
 function storeDetectedEmployees(employees) {
     cachedEmployees = employees;
     cachedEmployeesAtMs = Date.now();
+    cachedEmployeesContext = employeeDetectionContext();
     persistEmployees(employees);
     return employees;
 }
@@ -909,6 +932,7 @@ function storeDetectedEmployees(employees) {
 function invalidateEmployeeDetectionCache() {
     cachedEmployees = null;
     cachedEmployeesAtMs = 0;
+    cachedEmployeesContext = null;
     inFlightDetection = null;
     try {
         fs_1.default.rmSync(agentAvailabilityFilePath(), { force: true });

package/dist/src/ai-hub/manager-turns.js

@@ -53,9 +53,10 @@ function buildSameJobContinueMessage(coaching) {
         ? `Continue the active FRAIM job with this manager coaching:\n\n${remainder}`
         : 'Continue the active FRAIM job using the current session context.';
 }
-function buildManagerMessage(employeeId, jobId, kind, instructions, stubPath) {
+function buildManagerMessage(employeeId, jobId, kind, instructions, options) {
+    const stubPath = options?.stubPath;
     const trimmed = String(instructions || '').trim();
-    const explicit = extractExplicitFraimInvocation(trimmed);
+    const explicit = options?.ignoreEmbeddedInvocation ? null : extractExplicitFraimInvocation(trimmed);
     const effectiveJobId = explicit?.jobId || jobId;
     const invocation = fraimInvocationFor(employeeId, effectiveJobId);
     if (!invocation && effectiveJobId === '__freeform__' && kind === 'start') {

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

@@ -749,6 +749,9 @@ function normalizeDelegationLedger(raw) {
             status,
             personaKey: cleanNullableString((rawTask.personaKey || rawTask.persona)),
             jobId: cleanNullableString((rawTask.jobId || rawTask.job || rawTask.job_id)),
+            // Issue #1021: accept the same alias tolerance the rest of this normalizer applies,
+            // and coerce a numeric issue to a string so `#${issueNumber}` never renders `[object Object]`.
+            issueNumber: cleanNullableString((rawTask.issueNumber ?? rawTask.issue_number ?? rawTask.issue)?.toString()),
             reviewJobId: cleanNullableString(rawTask.reviewJobId),
             reviewType: cleanNullableString(rawTask.reviewType),
             instructions: cleanString((rawTask.instructions || rawTask.briefing)) || undefined,
@@ -2711,7 +2714,17 @@ class AiHubServer {
                 continue;
             if (task.status && task.status !== 'planned')
                 continue;
-            if (!task.jobId || !this.delegationDependenciesSatisfied(ledger, task.dependsOn || []))
+            // Issue #1021: a task that names no job is a manager-visible defect, not a
+            // silent skip. The unresolvable-job path below already blocks with a reason;
+            // this makes the no-job-at-all case behave identically instead of vanishing.
+            // Dependency waiting stays a silent continue — that task is pending, not broken.
+            if (!task.jobId) {
+                this.markDelegationTaskBlocked(managerRun, task, `Delegation blocked: task "${task.taskId}" does not name a job.`);
+                started.add(task.taskId);
+                managerRun.orchestratedDelegationTaskIds.push(task.taskId);
+                continue;
+            }
+            if (!this.delegationDependenciesSatisfied(ledger, task.dependsOn || []))
                 continue;
             if (!task.personaKey)
                 task.personaKey = getProtectedPersonaForHubJob(task.jobId);
@@ -2720,6 +2733,21 @@ class AiHubServer {
             managerRun.orchestratedDelegationTaskIds.push(task.taskId);
         }
     }
+    /**
+     * Issue #1021: one place that marks a delegation task blocked. Extracted so the
+     * no-job and unresolvable-job paths cannot drift apart — two hand-written copies
+     * of this transition is how the original inconsistency arose.
+     *
+     * Sets a status and a one-line reason only. Per issue #826 a protocol defect must
+     * not surface as manager decision UI, so this deliberately creates no review
+     * controls and no correction affordance.
+     */
+    markDelegationTaskBlocked(managerRun, task, reason) {
+        task.status = 'blocked';
+        task.latestSummary = reason;
+        managerRun.events.push((0, hosts_1.createHubEvent)('system', reason));
+        this.persistRunConversation(managerRun, managerRun.conversationId || managerRun.id);
+    }
     delegationDependenciesSatisfied(ledger, dependsOn) {
         if (!dependsOn.length)
             return true;
@@ -2738,27 +2766,40 @@ class AiHubServer {
             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);
+            this.markDelegationTaskBlocked(managerRun, task, `Delegation blocked: job "${task.jobId}" is not available in this project.`);
             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}.`,
-            '',
+        // Issue #1021: this brief adds context the job cannot know and subtracts nothing.
+        // It previously carried "This is a delegated subtask, not an end-to-end FRAIM
+        // submission workflow ... Do not create evidence docs, open or update PRs, update
+        // GitHub issues" plus a "submit a concise summary back to Mandy" substitute for the
+        // job's real submit phase. Both are gone: the child runs its named job in full, and
+        // delegation changes who reviews the output, not what the output is.
+        //
+        // Nothing is added in their place. The Hub does not restate what the job already
+        // instructs (#563), and it does not tell the child who reviews it — routing is
+        // handled entirely by notifyManagerOfDelegatedChild and, on the client, by
+        // syncManagedDelegationAccess. The retained "Mandy is your manager" line is the only
+        // one the child's behavior actually depends on: it stops the child blocking on a human.
+        const contextLines = [
             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.',
+            // The issue the child works, carried as ledger data rather than left to prose, so
+            // set-up-workspace can provision the right branch and the job can label the issue.
+            task.issueNumber ? `Issue: #${task.issueNumber}` : null,
+            task.reviewJobId ? `Manager review route: this output should be reviewed using ${task.reviewJobId}.` : null,
             'Do not ask the human for coaching; Mandy is your manager for this workstream.',
+        ].filter((line) => Boolean(line));
+        const childInstructions = [
+            task.instructions || task.latestSummary || `Complete the delegated workstream: ${task.title}.`,
+            '',
+            ...contextLines,
         ].join('\n');
-        const prepared = this.prepareStartPayload(managerRun.projectPath, managerRun.hostId, task.jobId, childInstructions);
+        const prepared = this.prepareStartPayload(managerRun.projectPath, managerRun.hostId, task.jobId, childInstructions, { ignoreEmbeddedInvocation: true });
         const childRun = {
             id: (0, crypto_1.randomUUID)(),
             conversationId: childConversationId,
@@ -3092,8 +3133,15 @@ class AiHubServer {
     // Lightweight markdown → .docx. Shared by the GET (file path) and POST (inline
     // content) export routes so a conversational deliverable with no on-disk file
     // can still be downloaded for Word annotation.
-    prepareStartPayload(projectPath, hostId, selectedJobId, instructions) {
-        const explicit = (0, manager_turns_1.extractExplicitFraimInvocation)(instructions);
+    prepareStartPayload(projectPath, hostId, selectedJobId, instructions, 
+    // Issue #1021: an explicit invocation inside `instructions` normally wins, which is
+    // correct when a human typed `/fraim <job>` into the coach box. For an
+    // orchestration-initiated launch there is no human typing: the instructions are
+    // agent-generated prose, and the delegation ledger is the only authority on which
+    // job runs. Without this, a stray `/fraim other-job` in Mandy's brief would silently
+    // launch a different job than the ledger declares and stamp it onto childRun.jobId.
+    options) {
+        const explicit = options?.ignoreEmbeddedInvocation ? null : (0, manager_turns_1.extractExplicitFraimInvocation)(instructions);
         const resolvedJobId = explicit?.jobId || selectedJobId;
         if (!resolvedJobId) {
             throw new Error('Choose a FRAIM job before starting a run, or start with /fraim <job-id>.');
@@ -3107,11 +3155,12 @@ class AiHubServer {
         // available (env published at boot).
         const browserNote = (0, managed_browser_1.buildBrowserContextNote)(process.env.FRAIM_BROWSER_CDP_ENDPOINT, process.env.FRAIM_HUB_BASE_URL);
         const styleNote = (0, manager_turns_1.buildCommunicationStyleNote)();
+        const ignoreEmbedded = options?.ignoreEmbeddedInvocation === true;
         if (resolvedJobId === '__freeform__') {
-            const display = (0, manager_turns_1.buildManagerMessage)(hostId, resolvedJobId, 'start', instructions);
+            const display = (0, manager_turns_1.buildManagerMessage)(hostId, resolvedJobId, 'start', instructions, { ignoreEmbeddedInvocation: ignoreEmbedded });
             return {
                 jobId: resolvedJobId,
-                message: (0, manager_turns_1.buildManagerMessage)(hostId, resolvedJobId, 'start', instructions) + browserNote + styleNote,
+                message: (0, manager_turns_1.buildManagerMessage)(hostId, resolvedJobId, 'start', instructions, { ignoreEmbeddedInvocation: ignoreEmbedded }) + browserNote + styleNote,
                 display,
             };
         }
@@ -3119,10 +3168,10 @@ class AiHubServer {
         const absoluteStubPath = resolvedJob?.stubPath
             ? [projectPath, resolvedJob.stubPath].join('/').replace(/\\/g, '/').replace(/\/+/g, '/')
             : undefined;
-        const display = (0, manager_turns_1.buildManagerMessage)(hostId, resolvedJobId, 'start', instructions);
+        const display = (0, manager_turns_1.buildManagerMessage)(hostId, resolvedJobId, 'start', instructions, { ignoreEmbeddedInvocation: ignoreEmbedded });
         return {
             jobId: resolvedJobId,
-            message: (0, manager_turns_1.buildManagerMessage)(hostId, resolvedJobId, 'start', instructions, absoluteStubPath) + browserNote + styleNote,
+            message: (0, manager_turns_1.buildManagerMessage)(hostId, resolvedJobId, 'start', instructions, { stubPath: absoluteStubPath, ignoreEmbeddedInvocation: ignoreEmbedded }) + browserNote + styleNote,
             display,
         };
     }
@@ -4585,12 +4634,17 @@ class AiHubServer {
                 if (!run) {
                     return res.status(404).json({ error: 'Run not found.' });
                 }
-                if (!run.sessionId) {
-                    return res.status(409).json({ error: 'This run does not have a resumable host session yet.' });
+                // When sessionId is null the host session is gone (agent crashed, Hub restart with no
+                // resume path, etc.). A non-managed direct run must still accept coaching: fall back to a
+                // fresh startRun with the conversation's handoff context + the manager's coaching text,
+                // exactly as the agent-switch path does. Managed delegation children are still blocked —
+                // their coaching flows through the parent manager run, not through the human.
+                if (!run.sessionId && !run.humanCoachingDisabled && run.status === 'running') {
+                    return res.status(409).json({ error: 'This run has not established a host session yet. Wait a moment and try again.' });
                 }
                 const instructions = (req.body.instructions || '').trim();
                 const coachingJobId = req.body.coachingJobId?.trim() || undefined;
-                // When coachingJobId is present (user picked a manager template via the UI),
+                // When coachingJobId is present (user picked a manager coaching template via the UI),
                 // it overrides the run's own jobId in the invocation. The server always adds
                 // the correct $fraim / /fraim prefix — the UI never passes raw invocation syntax.
                 const prepared = instructions
@@ -4602,6 +4656,70 @@ class AiHubServer {
                 if (!message) {
                     return res.status(400).json({ error: 'Coach your employee before sending the next turn.' });
                 }
+                // No resumable session — start fresh using a handoff prompt so the agent
+                // picks up from the preserved conversation state + manager coaching.
+                if (!run.sessionId) {
+                    if (run.humanCoachingDisabled) {
+                        return res.status(403).json({ error: 'Human coaching is disabled for this delegated workstream. Coach the parent manager run instead.' });
+                    }
+                    const conversation = this.conversationStore.loadConversation((0, conversation_store_1.conversationScopeKey)(run.scope, run.projectPath), run.conversationId || run.id);
+                    const handoffSummary = conversation
+                        ? buildAgentSwitchHandoffSummary(conversation)
+                        : null;
+                    const freshPayload = handoffSummary
+                        ? this.prepareStartPayload(run.projectPath, run.hostId, run.jobId, renderAgentSwitchHandoffPrompt(handoffSummary, prepared.display || message))
+                        : this.prepareStartPayload(run.projectPath, run.hostId, run.jobId, prepared.display || message);
+                    const reviewApprovalSystemEventTextFresh = buildReviewApprovalSystemEventText(prepared.display || message);
+                    this.runRegistry.update(run.id, (current) => {
+                        current.status = 'running';
+                        current.sessionId = undefined;
+                        current.messages.push((0, hosts_1.createHubMessage)('manager', prepared.display || message));
+                        if (reviewApprovalSystemEventTextFresh)
+                            current.events.push((0, hosts_1.createHubEvent)('system', reviewApprovalSystemEventTextFresh));
+                        current.events.push((0, hosts_1.createHubEvent)('system', 'No resumable session — starting a fresh agent turn from conversation context.'));
+                    });
+                    const startedFresh = this.runRegistry.get(run.id);
+                    if (startedFresh)
+                        this.persistRunConversation(startedFresh, startedFresh.conversationId || startedFresh.id);
+                    this.runRegistry.create(run, {});
+                    const freshLaunch = this.resolveLaunchAgent(run.configuredAgentId, run.hostId);
+                    const freshChild = this.hostRuntime.startRun(run.hostId, run.projectPath, freshPayload.message, {
+                        onEvent: (event, channel) => {
+                            this.runRegistry.update(run.id, (current) => {
+                                if (event.sessionId) {
+                                    current.sessionId = event.sessionId;
+                                    current.resumeCommand = (0, hosts_1.buildInteractiveResumeCommand)(run.hostId, event.sessionId);
+                                }
+                                appendHostMessage(current, run.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.fraimJob)
+                                    this.applyFraimJobSignalToRun(current, event.fraimJob);
+                                if (event.seekMentoring)
+                                    this.applySeekMentoringSignalToRun(current, event.seekMentoring);
+                                if (event.usage)
+                                    applyUsageSignal(current, event.usage);
+                            });
+                            const updated = this.runRegistry.get(run.id);
+                            if (updated) {
+                                this.maybeStartDelegatedChildRuns(updated);
+                                this.scheduleRunConversationPersistence(updated, updated.conversationId || updated.id);
+                            }
+                        },
+                        onExit: (exitCode) => {
+                            this.handleRunExit(run.id, exitCode, (updated) => {
+                                this.maybeStartDelegatedChildRuns(updated);
+                            });
+                        },
+                    }, startSessionSeedForHost(run.hostId, run.id), freshLaunch.launchContext);
+                    this.runRegistry.attachChildIfRunning(run.id, freshChild);
+                    const refreshedFresh = this.runRegistry.get(run.id);
+                    return res.json(refreshedFresh ? this.enrichRunForResponse(refreshedFresh) : refreshedFresh);
+                }
                 const reviewApprovalSystemEventText = buildReviewApprovalSystemEventText(prepared.display || message);
                 this.runRegistry.update(run.id, (current) => {
                     current.status = 'running';
@@ -5425,9 +5543,6 @@ class AiHubServer {
                         console.log(`[ai-hub] scheduled deployment ${deployment.id} skipped - scheduled fire already claimed`);
                         return;
                     }
-                    if (process.env.FRAIM_DEBUG_SCHEDULER === '1') {
-                        console.log('[ai-hub] debug claimed scheduled fire', deployment.id, deployment.hostId, deployment.activeRunId || null);
-                    }
                     await this.fireDeploymentRun(deployment);
                 }
                 catch (err) {
@@ -5438,7 +5553,7 @@ class AiHubServer {
             const exactFireMs = exactSixFieldCronDateMs(deployment.cronExpr);
             const exactFireNearDue = exactFireMs !== null && exactFireMs - Date.now() <= 5_000;
             if (exactFireNearDue) {
-                setTimeout(() => { void fireScheduledDeployment(exactFireMs); }, 0);
+                setTimeout(() => { void fireScheduledDeployment(exactFireMs); }, 1_000);
             }
             const exactTimer = exactFireMs !== null && !exactFireNearDue
                 ? setTimeout(() => { void fireScheduledDeployment(exactFireMs); }, Math.max(0, exactFireMs - Date.now()))
@@ -5506,9 +5621,6 @@ class AiHubServer {
         // Pre-register before startRun so synchronous onEvent calls (e.g. FakeHostRuntime)
         // can call runRegistry.update without "Run not found" throws.
         this.runRegistry.create(run, {});
-        if (process.env.FRAIM_DEBUG_SCHEDULER === '1') {
-            console.log('[ai-hub] debug starting deployment run', deployment.id, hostId, deployment.projectPath);
-        }
         const child = this.hostRuntime.startRun(hostId, deployment.projectPath, instructions, {
             onEvent: (event, channel) => {
                 this.runRegistry.update(run.id, (current) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fraim-hub",
-  "version": "2.0.240",
+  "version": "2.0.241",
   "description": "FRAIM Hub local companion package.",
   "bin": {
     "fraim-hub": "bin/fraim-hub.js",
@@ -161,7 +161,7 @@
     "electron": "^41.2.2",
     "electron-updater": "^6.8.9",
     "express": "^5.2.1",
-    "fraim": "2.0.240",
+    "fraim": "2.0.241",
     "mongodb": "^7.0.0",
     "node-cron": "4.2.1",
     "node-edge-tts": "^1.2.10",

package/public/ai-hub/script.js

@@ -1242,7 +1242,14 @@ function panelStateFor(convId) {
 }
 
 function defaultCoachOpen(conv) {
-  if (isManagerOversightConversation(conv)) return false;
+  // Issue #1021 (R11): an oversight run collapses the coach panel by default so the
+  // delegation boards get the vertical space. But the review actions live inside that
+  // panel, so once Mandy submits, the human had to expand a collapsed panel to find
+  // Approve while every other employee shows it immediately. Parity is the whole point
+  // of this issue: when the run is actually awaiting a decision, the decision is visible.
+  if (isManagerOversightConversation(conv)) {
+    return typeof convAwaitingReview === 'function' ? convAwaitingReview(conv) : false;
+  }
   return true;
 }
 
@@ -3649,6 +3656,32 @@ function delegatedTaskArtifacts(task, childConv) {
   return task.artifacts || [];
 }
 
+// Issue #1021: a delegated child's pull request is its review surface. The URL is
+// AI-derived (it originates in an agent-emitted review handoff), so it must pass the
+// shared safeHttpUrl gate before it can become an href — the same trust boundary
+// window-open-decision.ts enforces for the desktop shell. Never hand-roll this check.
+function delegatedTaskPullRequestTarget(task, childConv) {
+  const target = childConv?.reviewHandoff?.reviewTarget || task?.reviewHandoff?.reviewTarget;
+  if (!target || target.type !== 'pull_request') return null;
+  const url = safeHttpUrl(target.url);
+  return url ? { target, url } : null;
+}
+
+// Label for a child's pull request chip. Prefers the normalized `prNumber` the review
+// handoff already carries, matching the existing `PR #${target.prNumber}` convention used
+// by the delivery-action summary, rather than re-deriving it. Falls back to parsing the
+// URL for a provider that did not supply a number, then to the target's own label.
+function pullRequestChipLabel(target, url) {
+  const prNumber = target && typeof target.prNumber === 'number' && Number.isFinite(target.prNumber)
+    ? target.prNumber
+    : null;
+  if (prNumber) return `Pull request #${prNumber}`;
+  const match = /\/(?:pull|pull-requests|merge_requests)\/(\d+)/.exec(String(url || ''));
+  if (match) return `Pull request #${match[1]}`;
+  const label = target && typeof target.label === 'string' ? target.label.trim() : '';
+  return label || 'Pull request';
+}
+
 function renderDelegationLedger(conv) {
   const host = ensureDelegationHost();
   if (!host) return;
@@ -3732,7 +3765,26 @@ function renderDelegationLedger(conv) {
     if (detail.textContent) row.appendChild(detail);
     row.appendChild(summary);
 
+    // Issue #1021: a child that submits a pull request carries `artifacts: []` by
+    // contract (a PR target IS the whole review surface), so the artifact strip below
+    // was empty and the row fell through to "no file artifact reported" — actively
+    // wrong once delegated children open real PRs. Surface the PR as the child's
+    // review surface in the same strip, using the same component class.
+    const childPr = delegatedTaskPullRequestTarget(task, childConv);
     const artifacts = delegatedTaskArtifacts(task, childConv);
+    if (childPr) {
+      const prStrip = document.createElement('div');
+      prStrip.className = 'delegation-artifacts';
+      const link = document.createElement('a');
+      link.className = 'delegation-artifact';
+      link.href = childPr.url;
+      link.target = '_blank';
+      link.rel = 'noopener noreferrer';
+      link.textContent = pullRequestChipLabel(childPr.target, childPr.url);
+      link.title = childPr.url;
+      prStrip.appendChild(link);
+      row.appendChild(prStrip);
+    }
     if (artifacts.length) {
       const artifactStrip = document.createElement('div');
       artifactStrip.className = 'delegation-artifacts';
@@ -3752,7 +3804,7 @@ function renderDelegationLedger(conv) {
         artifactStrip.appendChild(chip);
       }
       row.appendChild(artifactStrip);
-    } else if (childConv?.status === 'completed' || taskStatus === 'submitted' || taskStatus === 'reviewed') {
+    } else if (!childPr && (childConv?.status === 'completed' || taskStatus === 'submitted' || taskStatus === 'reviewed')) {
       const inline = document.createElement('div');
       inline.className = 'delegation-review-note';
       inline.textContent = 'Inline deliverable; no file artifact reported';
@@ -6841,10 +6893,11 @@ async function continueRun(text, options) {
         body: JSON.stringify({ instructions: text, ...(coachingJobId ? { coachingJobId } : {}) }),
       });
     } catch (e) {
+      const isNotFound = /not found/i.test((e && e.message) || '');
       // #521: the Hub run is in-memory and is lost on a server restart, but the
       // agent session persists on disk. If the run is gone and we have a sessionId,
       // resume the conversation rather than failing — carries it forward intact.
-      if (conv.sessionId && /not found/i.test((e && e.message) || '')) {
+      if (conv.sessionId && isNotFound) {
         run = await requestJson('/api/ai-hub/runs/resume', {
           method: 'POST',
           headers: { 'Content-Type': 'application/json' },
@@ -6862,6 +6915,26 @@ async function continueRun(text, options) {
           }),
         });
         conv.runId = run.id; // bind the conversation to the freshly-resumed run
+      } else if (!conv.sessionId && (isNotFound || /409/.test((e && e.message) || ''))) {
+        // Run is gone from the registry AND there is no resumable session (agent crashed
+        // or Hub restarted after a failed run). Start a completely fresh run bound to
+        // this conversation so the manager's coaching is not lost.
+        run = await requestJson('/api/ai-hub/runs', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            projectPath: state.projectPath,
+            hostId: baseHostIdForAgent(conversationAgentName(conv) || state.selectedEmployeeId || 'claude'),
+            configuredAgentId: conversationAgentName(conv) || state.selectedEmployeeId || 'claude',
+            jobId: conv.jobId,
+            jobTitle: conv.jobTitle || conv.jobId,
+            conversationId: conv.id,
+            conversationTitle: conv.title,
+            instructions: text,
+            ...(coachingJobId ? { coachingJobId } : {}),
+          }),
+        });
+        conv.runId = run.id; // bind the conversation to the new run
       } else {
         throw e;
       }

package/public/ai-hub/styles.css

@@ -1277,6 +1277,17 @@ img.conv-employee-avatar {
 .delegation-artifact:hover {
   background: color-mix(in srgb, var(--accent) 16%, transparent);
 }
+/* Issue #1021: a child's pull request renders as an <a> in this strip, so the chip is
+   now keyboard-navigable where it was previously only a <button> relying on the UA
+   ring. Match the focus-visible convention used across this stylesheet. */
+.delegation-artifact:focus-visible,
+.delegation-view-work:focus-visible {
+  outline: 2px solid var(--accent-strong);
+  outline-offset: 2px;
+}
+.delegation-artifact {
+  text-decoration: none;
+}
 .delegation-review-note {
   background: var(--state-working-soft);
   color: var(--state-working);