fraim-hub 2.0.274 → 2.0.275

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

@@ -379,6 +379,27 @@ function readJobFrontmatter(filePath) {
         return null;
     }
 }
+/**
+ * Issue #1246: resolve the stub whose phase graph actually governs this job.
+ * A personalized override that is `extends`-only (no `phases`/`initialPhase`
+ * of its own) wins the layer-precedence override chain in findJobStubPath,
+ * but declares no phase graph AND has no `## Steps` section for
+ * loadJobPhasesFromSteps to fall back to either — every phase-derivation
+ * caller silently degraded to zero phases. Follow `extends` to the baseline
+ * stub when the resolved stub itself declares no phase graph.
+ */
+function resolveDeclaredPhaseStub(stubPath, projectPath) {
+    const fm = readJobFrontmatter(stubPath);
+    if (fm?.initialPhase && fm.phases)
+        return { fm, path: stubPath };
+    const extendsValue = typeof fm?.extends === 'string' ? fm.extends.trim() : '';
+    if (!extendsValue)
+        return { fm, path: stubPath };
+    const basePath = resolveExtendedStubPath(projectPath, extendsValue);
+    if (!basePath)
+        return { fm, path: stubPath };
+    return { fm: readJobFrontmatter(basePath), path: basePath };
+}
 function findJobStubPath(projectPath, jobId) {
     // Walk both employee and manager layer sets. The analytics surfaces can
     // inspect any FRAIM job run, including manager-side jobs such as
@@ -432,9 +453,9 @@ function loadJobPhases(jobId, projectPath, discriminant = 'feature') {
     const stubPath = findJobStubPath(projectPath, jobId);
     if (!stubPath)
         return [];
-    const fm = readJobFrontmatter(stubPath);
+    const { fm, path: declaredPath } = resolveDeclaredPhaseStub(stubPath, projectPath);
     if (!fm || !fm.initialPhase || !fm.phases)
-        return loadJobPhasesFromSteps(stubPath);
+        return loadJobPhasesFromSteps(declaredPath);
     const visited = new Set();
     const ordered = [];
     let cursor = fm.initialPhase;
@@ -461,7 +482,7 @@ function resolveJobPhaseTransition(jobId, projectPath, phaseId, outcome, discrim
     const stubPath = findJobStubPath(projectPath, jobId);
     if (!stubPath)
         return null;
-    const fm = readJobFrontmatter(stubPath);
+    const { fm } = resolveDeclaredPhaseStub(stubPath, projectPath);
     if (!fm || !fm.phases)
         return null;
     const phaseDef = fm.phases[phaseId];
@@ -474,9 +495,9 @@ function loadAllJobPhaseIds(jobId, projectPath) {
     const stubPath = findJobStubPath(projectPath, jobId);
     if (!stubPath)
         return new Set();
-    const fm = readJobFrontmatter(stubPath);
+    const { fm, path: declaredPath } = resolveDeclaredPhaseStub(stubPath, projectPath);
     if (!fm || !fm.phases) {
-        const phases = loadJobPhasesFromSteps(stubPath);
+        const phases = loadJobPhasesFromSteps(declaredPath);
         return new Set(phases.map((p) => p.id));
     }
     return new Set(Object.keys(fm.phases));

package/dist/src/ai-hub/desktop-main.js

@@ -107,7 +107,7 @@ function configureAutoUpdater() {
 function ensureWordSideload(projectPath, httpsPort) {
     // Flag version bump: bump this string when new manifests are added so all
     // users get re-sideloaded on their next launch.
-    const FLAG_VERSION = 'v5-https-port';
+    const FLAG_VERSION = 'v6-excel-addin';
     const expectedFlag = `${FLAG_VERSION}:${httpsPort}`;
     const flagPath = path_1.default.join(electron_1.app.getPath('userData'), 'word-sideloaded.flag');
     const existingFlag = fs_1.default.existsSync(flagPath) ? fs_1.default.readFileSync(flagPath, 'utf8') : null;

package/dist/src/ai-hub/office-sideload.js

@@ -1,7 +1,7 @@
 "use strict";
 /**
- * Sideloads Office add-in manifests (Word + PowerPoint) so they appear under
- * Insert > My Add-ins > Developer Add-ins without admin rights or AppSource.
+ * Sideloads Office add-in manifests (Word + PowerPoint + Excel) so they appear
+ * under Insert > My Add-ins > Developer Add-ins without admin rights or AppSource.
  *
  * Windows: writes HKCU\SOFTWARE\Microsoft\Office\16.0\WEF\Developer\{<guid>}
  *          (Default) = ABSOLUTE FILE PATH to manifest.xml. This is the registry
@@ -52,6 +52,15 @@ const MANIFESTS = [
         ],
         macContainer: 'com.microsoft.Powerpoint',
     },
+    {
+        guid: 'da8d22c7-2c00-485a-bdc9-13dda7f80c48',
+        candidates: (base) => [
+            path_1.default.resolve(base, 'public/ai-hub/excel-taskpane/manifest.xml'),
+            path_1.default.resolve(__dirname, '..', '..', 'public/ai-hub/excel-taskpane/manifest.xml'),
+            path_1.default.resolve(__dirname, '..', '..', '..', 'public/ai-hub/excel-taskpane/manifest.xml'),
+        ],
+        macContainer: 'com.microsoft.Excel',
+    },
 ];
 function resolveManifestPath(entry, projectPath) {
     return entry.candidates(projectPath).find(c => fs_1.default.existsSync(c)) ?? null;
@@ -157,7 +166,7 @@ function sideloadManifest(projectPath, options = {}) {
     for (const entry of MANIFESTS) {
         const manifestPath = resolveManifestPath(entry, projectPath);
         if (!manifestPath) {
-            return { ok: false, reason: `Manifest not found for GUID ${entry.guid} — check extensions/office-word/ and public/ai-hub/powerpoint-taskpane/` };
+            return { ok: false, reason: `Manifest not found for GUID ${entry.guid} — check extensions/office-word/, public/ai-hub/powerpoint-taskpane/, and public/ai-hub/excel-taskpane/` };
         }
         const sideloadPath = prepareManifestForSideload(entry, manifestPath, options);
         if (process.platform === 'win32') {

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

@@ -248,15 +248,18 @@ function getCustomPersonaForJob(projectPath, jobId) {
     const match = employees.find((e) => Array.isArray(e.jobIds) && e.jobIds.includes(jobId));
     return match ? match.key : null;
 }
+// This set exists only for jobs that need hiding from the main picker for a
+// reason beyond ownership. `praise-fraim` is already surfaced in the Hub
+// coaching UI, so a picker entry would be a duplicate. Every other FRAIM-meta
+// job (contribute-to-fraim, file-fraim-issue) or persona-owned job
+// (run-on-remote-hub, setup-remote-hub under sreya) is a real, synced
+// capability and belongs in the main picker like any other job.
+// `evolve-fraim-registry` is a personalized-employee-only job local to the
+// FRAIM source repo (no registry/ counterpart ships to any installation), so
+// it has no entry here at all — this set is shared product code and must not
+// carry a job id that is meaningless to every customer.
 const FRAIM_INTERNAL_JOB_IDS = new Set([
-    'contribute-to-fraim',
-    'create-registry-asset',
-    'extract-ashley-learnings',
-    'file-fraim-issue',
     'praise-fraim',
-    'run-on-remote-hub',
-    'setup-remote-hub',
-    'update-registry-override',
 ]);
 // Jobs that operate on machine-level context (~/.fraim/) rather than a project
 // directory. They must be launchable from the Hub even when no project has been
@@ -1004,6 +1007,23 @@ function readPersistedRunProjection(conversation) {
         runDiscriminant: typeof value.runDiscriminant === 'string' ? value.runDiscriminant : null,
     };
 }
+// Issue #1246: the disk-serving GET-by-id endpoint returned the persisted
+// `run.stages` snapshot verbatim. That snapshot is written mid-run (e.g. while
+// a personalized `extends`-only stub was still resolving to zero phases) and
+// never revisited, so a completed run's tracker could freeze on one stale
+// phase forever. Re-derive stages from the conversation's own phase history
+// at read time instead of trusting the stored value.
+function deriveStagesForConversation(conversation) {
+    const persisted = readPersistedRunProjection(conversation);
+    return deriveStages({
+        jobId: conversation.jobId,
+        status: conversation.status,
+        currentPhase: persisted?.currentPhase ?? null,
+        phaseHistory: persisted?.phaseHistory ?? [],
+        phaseVisits: persisted?.phaseVisits ?? [],
+        runDiscriminant: persisted?.runDiscriminant ?? undefined,
+    }, conversation.projectPath);
+}
 function boundedText(value, maxChars = 500) {
     const text = typeof value === 'string' ? value.trim() : '';
     if (text.length <= maxChars)
@@ -1226,6 +1246,7 @@ function appendHostMessage(run, hostId, event, channel) {
 }
 const MAX_PROJECTED_EVENT_CHARS = 300;
 const MAX_PROJECTED_EVENTS_PER_RUN = 200;
+const MAX_HOST_ERROR_THREAD_CHARS = 160;
 function boundedEventText(text) {
     const trimmed = text.trim();
     if (trimmed.length <= MAX_PROJECTED_EVENT_CHARS)
@@ -1378,12 +1399,6 @@ function phaseVisitsForProjection(run) {
         latestText: entry.latestText,
     }));
 }
-// Build the stage list for a run. Combines the FSM's reachable path with
-// any phases the run has actually visited (in case the run took an
-// onFailure back-edge into a phase the simple onSuccess walk wouldn't
-// surface). Each stage is marked done / current / upcoming based on
-// whether it precedes / matches / follows the current phase along the
-// rendered order.
 function deriveStages(run, projectPath) {
     const declaredPath = (0, catalog_1.loadJobPhases)(run.jobId, projectPath, run.runDiscriminant || 'feature');
     if (declaredPath.length === 0)
@@ -1832,18 +1847,29 @@ function buildHubRecoveryContinueMessage(run, exitCode, attempt) {
 function hostErrorSuffix(run) {
     return run.lastHostError ? ` Last host error: ${run.lastHostError}` : '';
 }
-// Issue #1221 (PR #1223 review): the interim `Host error: ...` message
-// (pushed the moment a hostError event arrives, see recordHostEvent) tells
-// the manager reading only the main thread that *something* went wrong, but
-// nothing in the thread ever says the run is now actually done and why —
-// that closing statement previously only reached Micro-manage. A manager
-// reading just the conversation would see error chatter, then silence, with
-// no thread-visible statement tying the two together. Call this once at each
-// terminal-park site, alongside the Micro-manage event, so a failure the
-// manager is already reading about in the thread is also closed out there.
+// Issue #1240: raw API error messages (rate-limit notices, turn.failed payloads)
+// can be multi-sentence paragraphs with retry hints, URLs, and quota details.
+// The conversation thread should show only the first sentence, capped at 160
+// chars; full technical detail remains in run.events (micro-log).
+function summarizeHostErrorForThread(error) {
+    const raw = String(error || '').trim();
+    if (!raw)
+        return 'An unexpected error occurred.';
+    const firstLine = raw.split(/[\r\n]/)[0].trim();
+    // Split on ". " followed by an uppercase letter to find the sentence boundary.
+    const sentenceEnd = firstLine.search(/\.\s+[A-Z]/);
+    const firstSentence = sentenceEnd >= 0 ? firstLine.slice(0, sentenceEnd + 1) : firstLine;
+    if (firstSentence.length <= MAX_HOST_ERROR_THREAD_CHARS)
+        return firstSentence;
+    return firstSentence.slice(0, MAX_HOST_ERROR_THREAD_CHARS - 3) + '…';
+}
+// Only surface a host error in the conversation thread when the run has
+// actually terminated with a failure. Transient errors that resolve through
+// auto-recovery must not reach the thread so the manager is not alarmed by
+// noise that the system handled on its own.
 function pushTerminalFailureToThread(run, exitCode) {
     if (exitCode !== 0 && run.lastHostError) {
-        run.messages.push((0, hosts_1.createHubMessage)('system', `This run stopped: ${run.lastHostError}`));
+        run.messages.push((0, hosts_1.createHubMessage)('system', `This run stopped: ${summarizeHostErrorForThread(run.lastHostError)}`));
     }
 }
 function createHubRecoveryEvent(run, exitCode, attempt) {
@@ -2236,7 +2262,7 @@ class AiHubServer {
                 });
             });
         }
-        this.app.get(['/word-taskpane/config.js', '/powerpoint-taskpane/config.js'], (_req, res) => {
+        this.app.get(['/word-taskpane/config.js', '/powerpoint-taskpane/config.js', '/excel-taskpane/config.js'], (_req, res) => {
             const port = this.httpPort || 43091;
             const origin = `http://127.0.0.1:${port}`;
             res.setHeader('Content-Type', 'application/javascript; charset=utf-8');
@@ -2529,6 +2555,16 @@ class AiHubServer {
             ...job,
             requiredPersonaKey: getProtectedPersonaForHubJob(job.id),
         }));
+        // Issue #1247: expose internal jobs in a separate bootstrap field so next-job
+        // recommendation chips can resolve and launch them. They are intentionally
+        // excluded from `jobs` (the main picker list) but must be resolvable for chips.
+        // Internal jobs default to the fraimworker persona rather than the unassigned default.
+        const internalJobs = rawJobs
+            .filter((job) => FRAIM_INTERNAL_JOB_IDS.has(job.id))
+            .map((job) => ({
+            ...job,
+            requiredPersonaKey: getProtectedPersonaForHubJob(job.id) ?? GENERIC_WORKER_PERSONA_KEY,
+        }));
         const managerTemplates = (0, catalog_1.discoverManagerTemplates)(normalizedProjectPath, catalogOptions);
         // Issue #750: the apiKey always comes from ~/.fraim/config.json — no header
         // override, no ai-hub-state.json copy, no fallback chain.
@@ -2579,6 +2615,7 @@ class AiHubServer {
             preferences: { ...preferences, apiKey: resolvedApiKey },
             categories: (0, catalog_1.getAiHubCategories)(normalizedProjectPath, catalogOptions),
             jobs,
+            internalJobs,
             managerTemplates,
             employees,
             configuredAgents,
@@ -2755,14 +2792,15 @@ class AiHubServer {
             }
         }
         // Issue #1221: a host-reported error/turn-failure must never be dropped
-        // as opaque raw JSON. Record it for the terminal exit message, surface it
-        // in the regular transcript as a distinct system message (not just a side
-        // panel), and put it in Micro-manage unconditionally — bypassing
+        // as opaque raw JSON. Record it for the terminal exit message and put it
+        // in Micro-manage unconditionally — bypassing
         // projectHostEventForConversation's raw-payload filter, which exists for
         // routine protocol chatter, not for a failure the manager needs to see.
+        // Issue #1240: do NOT push to run.messages here; only surface in the
+        // conversation thread via pushTerminalFailureToThread when the run actually
+        // fails, so transient errors resolved by auto-recovery stay silent to the user.
         if (event.hostError) {
             run.lastHostError = event.hostError;
-            run.messages.push((0, hosts_1.createHubMessage)('system', `Host error: ${event.hostError}`));
             run.events.push((0, hosts_1.createHubEvent)('stderr', boundedEventText(event.hostError)));
         }
         const projected = projectHostEventForConversation(event, channel);
@@ -4198,6 +4236,45 @@ class AiHubServer {
                 res.end(data);
             });
         });
+        // Issue #1248: Serve the Excel task pane HTML and manifest, mirroring the
+        // PowerPoint route above. Office JS appends query strings
+        // (?_host_Info=Excel$Win32$...) to every request, so strip them before
+        // resolving the file path.
+        this.app.get(/^\/excel-taskpane(\/.*)?$/, (req, res) => {
+            const taskpaneDir = resolveTaskpaneDir('excel-taskpane');
+            const { pathname } = new URL(req.url, 'http://localhost');
+            const relativePath = pathname.replace(/^\/excel-taskpane\/?/, '') || 'index.html';
+            const filePath = path_1.default.join(taskpaneDir, relativePath);
+            // Path traversal guard. A bare `startsWith(taskpaneDir)` (the pattern
+            // the PowerPoint route above uses) would also accept a sibling
+            // directory whose name happens to start with "excel-taskpane" (e.g.
+            // "excel-taskpane-evil") — require the separator (or an exact match)
+            // like the /_fraim-hub-ui asset guard above does.
+            if (!filePath.startsWith(taskpaneDir + path_1.default.sep) && filePath !== taskpaneDir) {
+                res.status(403).end();
+                return;
+            }
+            const ext = path_1.default.extname(filePath).toLowerCase();
+            const contentTypeMap = {
+                '.html': 'text/html; charset=utf-8',
+                '.xml': 'application/xml',
+                '.js': 'application/javascript',
+                '.css': 'text/css',
+                '.png': 'image/png',
+                '.ico': 'image/x-icon',
+                '.svg': 'image/svg+xml',
+            };
+            const contentType = contentTypeMap[ext] || 'application/octet-stream';
+            fs_1.default.readFile(filePath, (err, data) => {
+                if (err) {
+                    res.status(404).end('Not found');
+                    return;
+                }
+                res.setHeader('Content-Type', contentType);
+                res.setHeader('Access-Control-Allow-Origin', '*');
+                res.end(data);
+            });
+        });
         this.app.get('/api/ai-hub/bootstrap', async (req, res) => {
             let projectPath = typeof req.query.projectPath === 'string' && req.query.projectPath.length > 0
                 ? req.query.projectPath
@@ -4365,8 +4442,13 @@ class AiHubServer {
                 const conversation = this.conversationStore.loadConversation(key, conversationId);
                 if (!conversation)
                     return res.status(404).json({ error: 'conversation not found' });
+                // Issue #1246: re-derive stages at read time rather than trusting the
+                // persisted mid-run snapshot; see deriveStagesForConversation.
+                const withFreshStages = conversation.run
+                    ? { ...conversation, run: { ...conversation.run, stages: deriveStagesForConversation(conversation) } }
+                    : conversation;
                 // Issue #1090: ownership is derived on read, never served from the frozen record.
-                return res.json({ projectPath: key, scope: scope ?? 'project', conversation: withDerivedPersona(conversation, key), source: 'disk' });
+                return res.json({ projectPath: key, scope: scope ?? 'project', conversation: withDerivedPersona(withFreshStages, key), source: 'disk' });
             }
             if (req.query.headersOnly === '1' || req.query.headersOnly === 'true') {
                 // One disk walk for the whole list, not one per conversation.

package/dist/src/config/persona-capability-bundles.js

@@ -219,7 +219,9 @@ exports.PERSONA_CAPABILITY_BUNDLES = {
         personaKey: 'sreya',
         bundleId: 'persona-sreya-core',
         catalogMetadata: buildCatalogMetadata('sreya', ['slo-design-and-implementation', 'incident-response', 'reliability-review']),
-        protectedJobs: ['slo-design-and-implementation', 'incident-response', 'reliability-review', 'production-readiness-review'],
+        // run-on-remote-hub and setup-remote-hub are owned by SReya, the infra
+        // persona, rather than the display-only FRAIMworker default.
+        protectedJobs: ['slo-design-and-implementation', 'incident-response', 'reliability-review', 'production-readiness-review', 'run-on-remote-hub', 'setup-remote-hub'],
         protectedAliases: ['sre', 'reliability', 'incident-response', 'on-call'],
         defaultHireMode: 'job',
         lockCopy: 'Hire SREya to unlock SLO governance, incident response, and production reliability work for this request.'

package/extensions/office-word/taskpane.html

@@ -3,9 +3,9 @@
 <head>
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>FRAIM Hub</title>
-  <script src="https://appsforoffice.microsoft.com/lib/1/hosted/office.js" type="text/javascript"></script>
-  <script src="config.js" type="text/javascript"></script>
+  <title>FRAIM Hub</title>
+  <script src="https://appsforoffice.microsoft.com/lib/1/hosted/office.js" type="text/javascript"></script>
+  <script src="config.js" type="text/javascript"></script>
   <style>
     * { margin: 0; padding: 0; box-sizing: border-box; }
     html, body { height: 100%; overflow: hidden; }
@@ -19,9 +19,9 @@
     // Loading an HTTP iframe from an HTTPS page is mixed-content-blocked, so use the
     // same origin as the taskpane when running over HTTPS (the ssl-proxy forwards all
     // routes to the Hub).  HTTP (isolated tests) keeps the direct Hub address.
-    var HUB_ORIGIN = window.location.protocol === 'https:'
-      ? window.location.origin
-      : (window.FRAIM_HUB_ORIGIN || 'http://127.0.0.1:43091');
+    var HUB_ORIGIN = window.location.protocol === 'https:'
+      ? window.location.origin
+      : (window.FRAIM_HUB_ORIGIN || 'http://127.0.0.1:43091');
     var hubFrame = document.getElementById('hub');
     var pendingPush = null;   // context queued before hub-ready fires
     var hubReady = false;
@@ -70,12 +70,21 @@
     }
 
     function readBodyAsync(cb) {
+      // Issue #1239: getSelectedDataAsync (used by readSelectionAsync above) only
+      // ever returns the current selection, never the full document — passing a
+      // different `valueFormat`/omitting `filterType` does not change that. Use
+      // the Word-specific API (already used below for comments/insert/append) to
+      // read the actual document body.
       try {
-        Office.context.document.getSelectedDataAsync(
-          Office.CoercionType.Text,
-          { valueFormat: 'unformatted' },
-          function(r) { cb(r.status === Office.AsyncResultStatus.Succeeded ? String(r.value || '') : ''); }
-        );
+        if (typeof Word !== 'undefined' && Word.run) {
+          Word.run(function(ctx) {
+            var body = ctx.document.body;
+            body.load('text');
+            return ctx.sync().then(function() { cb(body.text || ''); });
+          }).catch(function() { cb(''); });
+        } else {
+          cb('');
+        }
       } catch(e) { cb(''); }
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fraim-hub",
-  "version": "2.0.274",
+  "version": "2.0.275",
   "description": "FRAIM Hub local companion package.",
   "bin": {
     "fraim-hub": "bin/fraim-hub.js",
@@ -168,7 +168,7 @@
     "electron-updater": "^6.8.9",
     "express": "^5.2.1",
     "extract-zip": "^2.0.1",
-    "fraim": "2.0.274",
+    "fraim": "2.0.275",
     "mongodb": "^7.0.0",
     "node-cron": "4.2.1",
     "node-edge-tts": "^1.2.10",

package/public/ai-hub/excel-taskpane/index.html

@@ -0,0 +1,298 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>FRAIM Hub</title>
+  <script src="https://appsforoffice.microsoft.com/lib/1/hosted/office.js" type="text/javascript"></script>
+  <script src="config.js" type="text/javascript"></script>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    html, body { height: 100%; overflow: hidden; }
+    iframe { width: 100%; height: 100vh; border: none; display: block; }
+  </style>
+</head>
+<body>
+  <iframe id="hub" src="" allow="clipboard-read; clipboard-write"></iframe>
+  <script>
+    // Excel task pane — mirrors extensions/office-word/taskpane.html and
+    // public/ai-hub/powerpoint-taskpane/index.html so Excel gets the identical
+    // full Hub experience (issue #1248). Mounts the Hub /ai-hub/ surface in an
+    // iframe and bridges sheet/selection context over postMessage using the
+    // same word-context / word-request / word-response contract the Hub
+    // already speaks for every host (the names are the generic host-bridge
+    // protocol, not Word-specific).
+    //
+    // In Excel Online the pane is served over HTTPS (ssl-proxy at localhost:43092,
+    // same mechanism Word Online already uses). Loading an HTTP iframe from an
+    // HTTPS page is mixed-content-blocked, so use the pane's own origin there.
+    // On desktop (HTTP) use the direct Hub address.
+    var HUB_ORIGIN = window.location.protocol === 'https:'
+      ? window.location.origin
+      : (window.FRAIM_HUB_ORIGIN || 'http://127.0.0.1:43091');
+    var hubFrame = document.getElementById('hub');
+    var pendingPush = null;   // context queued before hub-ready fires
+    var hubReady = false;
+    var selectionHandlerAdded = false;
+    // Selection captured the last time context was read (on mount, on
+    // get-context/get-selection, and on every DocumentSelectionChanged fire).
+    // Write-back (R4) needs this to decide adjacent-cell vs append-new-row,
+    // since Excel's hasSelection is always true and can't gate that branch
+    // the way Word's optional selection does.
+    var lastSelectionInfo = null;
+
+    // ── postMessage bridge (inbound from Hub) ─────────────────────────────────
+    window.addEventListener('message', function(event) {
+      if (event.origin !== HUB_ORIGIN) return;
+      var msg = event.data || {};
+      if (msg.type === 'hub-ready') {
+        hubReady = true;
+        if (pendingPush) { pushToHub(pendingPush); pendingPush = null; }
+      } else if (msg.type === 'word-request') {
+        handleExcelRequest(msg.action, msg.requestId, msg.payload || {});
+      }
+    });
+
+    function pushToHub(msg) {
+      if (hubFrame && hubFrame.contentWindow) {
+        hubFrame.contentWindow.postMessage(msg, HUB_ORIGIN);
+      }
+    }
+
+    // ── Reading Excel context ───────────────────────────────────────────────────
+    function docMeta() {
+      var meta = { docUrl: '', docTitle: '' };
+      try {
+        var doc = window.Office && Office.context && Office.context.document;
+        meta.docUrl = (doc && doc.url) ? doc.url : '';
+        if (meta.docUrl) {
+          var parts = meta.docUrl.replace(/\\/g, '/').split('/');
+          meta.docTitle = (parts[parts.length - 1] || '').replace(/\.[^.]+$/, '');
+        }
+      } catch(e) {}
+      return meta;
+    }
+
+    // R2 edge case: Excel always has an active cell — there is no true "nothing
+    // selected" state the way Word has. Only a single cell at the sheet's bare
+    // A1 default counts as "nothing meaningful" for the R4 write-back branch.
+    function isDefaultA1(info) {
+      if (!info || !info.address) return true;
+      var bare = String(info.address).split('!').pop();
+      return bare === 'A1' || bare === '$A$1';
+    }
+
+    function csvEscapeCell(v) {
+      var s = (v === null || v === undefined) ? '' : String(v);
+      if (/[",\n]/.test(s)) return '"' + s.replace(/"/g, '""') + '"';
+      return s;
+    }
+
+    // Bounded CSV serialization of the used/visible range (R2, R8). Callers
+    // must still cap the RESULT to 800 chars — this only shapes the rows.
+    function rangeToCsv(values) {
+      return (values || []).map(function(row) {
+        return (row || []).map(csvEscapeCell).join(',');
+      }).join('\n');
+    }
+
+    // Build the human-readable selection label, e.g. "D5 (Engineering OpEx,
+    // Q2 Forecast): 344400" — address, inferred row/column headers from the
+    // used range's first column/first row, and the cell's own value. Falls
+    // back to a bare "address: value" when no header is discoverable.
+    function describeSelection(selRange, usedRange) {
+      try {
+        var addr = String(selRange.address || '').split('!').pop();
+        var rows = (selRange.values && selRange.values[0]) || [];
+        var val = rows[0] !== undefined ? rows[0] : '';
+        var rowLabel = '', colLabel = '';
+        if (usedRange && !usedRange.isNullObject && usedRange.values && usedRange.values.length > 1) {
+          var relRow = selRange.rowIndex - usedRange.rowIndex;
+          var relCol = selRange.columnIndex - usedRange.columnIndex;
+          var headerRow = usedRange.values[0] || [];
+          var rowAtCol0 = (usedRange.values[relRow] || [])[0];
+          if (relRow > 0 && rowAtCol0 !== undefined && rowAtCol0 !== '') rowLabel = String(rowAtCol0);
+          if (relCol > 0 && headerRow[relCol] !== undefined && headerRow[relCol] !== '') colLabel = String(headerRow[relCol]);
+        }
+        var parts = [rowLabel, colLabel].filter(Boolean);
+        return parts.length ? (addr + ' (' + parts.join(', ') + '): ' + val) : (addr + ': ' + val);
+      } catch(e) { return ''; }
+    }
+
+    function emptyContext() {
+      var meta = docMeta();
+      return { docUrl: meta.docUrl, docTitle: meta.docTitle, selection: '', hasSelection: true, bodyPreview: '', wordCount: 0, comments: [] };
+    }
+
+    function readFullContext(cb) {
+      var meta = docMeta();
+      if (typeof Excel === 'undefined' || !Excel.run) { cb(emptyContext()); return; }
+      Excel.run(function(ctx) {
+        var sheet = ctx.workbook.worksheets.getActiveWorksheet();
+        sheet.load('name');
+        var selRange = ctx.workbook.getSelectedRange();
+        selRange.load('address,values,rowIndex,columnIndex');
+        var usedRange = sheet.getUsedRangeOrNullObject();
+        usedRange.load('values,isNullObject,rowIndex,columnIndex,rowCount');
+        var comments = sheet.comments;
+        comments.load('items/content,items/authorName,items/resolved');
+        return ctx.sync().then(function() {
+          lastSelectionInfo = { address: selRange.address, rowIndex: selRange.rowIndex, columnIndex: selRange.columnIndex };
+          var body = usedRange.isNullObject ? '' : rangeToCsv(usedRange.values);
+          var commentList = (comments.items || []).slice(0, 20).map(function(c) {
+            return { author: c.authorName || '', text: c.content || '', resolved: !!c.resolved };
+          });
+          cb({
+            docUrl: meta.docUrl,
+            docTitle: sheet.name ? (meta.docTitle + ' — ' + sheet.name) : meta.docTitle,
+            selection: describeSelection(selRange, usedRange),
+            hasSelection: true,
+            bodyPreview: body.slice(0, 800),
+            wordCount: body ? body.split(/\s+/).filter(Boolean).length : 0,
+            comments: commentList,
+          });
+        });
+      }).catch(function() { cb(emptyContext()); });
+    }
+
+    // Lighter-weight read used by get-selection and the selection-change
+    // handler — just the label, not the whole used range + comments.
+    function refreshSelectionLabel(cb) {
+      if (typeof Excel === 'undefined' || !Excel.run) { cb(''); return; }
+      Excel.run(function(ctx) {
+        var sheet = ctx.workbook.worksheets.getActiveWorksheet();
+        var selRange = ctx.workbook.getSelectedRange();
+        selRange.load('address,values,rowIndex,columnIndex');
+        var usedRange = sheet.getUsedRangeOrNullObject();
+        usedRange.load('values,isNullObject,rowIndex,columnIndex');
+        return ctx.sync().then(function() {
+          lastSelectionInfo = { address: selRange.address, rowIndex: selRange.rowIndex, columnIndex: selRange.columnIndex };
+          cb(describeSelection(selRange, usedRange));
+        });
+      }).catch(function() { cb(''); });
+    }
+
+    // ── Selection-change handler ───────────────────────────────────────────────
+    // Reuses the same Office.context.document common-API event Word/PowerPoint
+    // already wire (issue #1248 spec: "the same Office JS event exists on
+    // Excel's document object") — it only signals that something changed; the
+    // actual range data is re-fetched via Excel.run() above, same as Word/PPT.
+    function addSelectionHandler() {
+      if (selectionHandlerAdded) return;
+      try {
+        Office.context.document.addHandlerAsync(
+          Office.EventType.DocumentSelectionChanged,
+          function() {
+            refreshSelectionLabel(function(sel) {
+              var m = docMeta();
+              pushToHub({ type: 'word-context-update', payload: {
+                docUrl: m.docUrl, docTitle: m.docTitle,
+                selection: sel, hasSelection: true,
+              }});
+            });
+          },
+          function(r) { if (r.status === Office.AsyncResultStatus.Succeeded) selectionHandlerAdded = true; }
+        );
+      } catch(e) {}
+    }
+
+    // ── Write-back (R4) ─────────────────────────────────────────────────────────
+    // Never overwrites the cell that was selected when the job started: if that
+    // selection was meaningful (anything but the sheet's bare A1 default),
+    // write into the cell immediately adjacent to it (same row, next column).
+    // Otherwise append a new row at the end of the used range. Either way, add
+    // a cell comment noting the write for audit/undo-by-review (R4's own
+    // recommended default) and rely on Excel's native Ctrl+Z for reject.
+    function writeBackNonDestructive(text, jobLabel, cb) {
+      if (typeof Excel === 'undefined' || !Excel.run) { cb(false, 'Excel API 1.10+ not available'); return; }
+      var info = lastSelectionInfo;
+      var meaningful = !!(info && !isDefaultA1(info));
+      var note = 'Written by FRAIM' + (jobLabel ? ' (' + jobLabel + ')' : '') + ' - ' + new Date().toISOString();
+      try {
+        Excel.run(function(ctx) {
+          var sheet = ctx.workbook.worksheets.getActiveWorksheet();
+          if (meaningful) {
+            var addr = String(info.address).split('!').pop();
+            var selRange = sheet.getRange(addr);
+            var target = selRange.getOffsetRange(0, 1);
+            target.values = [[text]];
+            sheet.comments.add(target, note);
+            return ctx.sync();
+          }
+          var used = sheet.getUsedRangeOrNullObject();
+          used.load('rowCount,rowIndex,isNullObject');
+          return ctx.sync().then(function() {
+            var nextRow = used.isNullObject ? 0 : (used.rowIndex + used.rowCount);
+            var target = sheet.getRangeByIndexes(nextRow, 0, 1, 1);
+            target.values = [[text]];
+            sheet.comments.add(target, note);
+            return ctx.sync();
+          });
+        }).then(function() { cb(true); }).catch(function(e) { cb(false, (e && e.message) || String(e)); });
+      } catch(e) { cb(false, e.message); }
+    }
+
+    // ── Handling requests from Hub ─────────────────────────────────────────────
+    function handleExcelRequest(action, requestId, payload) {
+      function respond(result) {
+        pushToHub({ type: 'word-response', requestId: requestId, payload: result });
+      }
+      if (action === 'get-context') {
+        readFullContext(function(ctx) { respond(ctx); });
+      } else if (action === 'get-selection') {
+        refreshSelectionLabel(function(sel) { respond({ selection: sel, hasSelection: true }); });
+      } else if (action === 'insert-text') {
+        // Symmetry with Word/PowerPoint's action surface; not part of the
+        // write-back flow (which only ever calls insert-after/append-to-doc —
+        // see tryWordWriteBack in public/ai-hub/script.js). Sets the selected
+        // cell's own value directly, matching Word's "replace selection".
+        try {
+          if (typeof Excel === 'undefined' || !Excel.run) { respond({ ok: false, error: 'Excel API 1.10+ not available' }); return; }
+          Excel.run(function(ctx) {
+            var range = ctx.workbook.getSelectedRange();
+            range.values = [[payload.text || '']];
+            return ctx.sync();
+          }).then(function() { respond({ ok: true }); }).catch(function(e) { respond({ ok: false, error: e.message }); });
+        } catch(e) { respond({ ok: false, error: e.message }); }
+      } else if (action === 'insert-after' || action === 'append-to-doc') {
+        writeBackNonDestructive(payload.text || '', payload.jobLabel || '', function(ok, err) {
+          if (ok) respond({ ok: true }); else respond({ ok: false, error: err });
+        });
+      } else if (action === 'track-changes-on' || action === 'track-changes-off') {
+        // R4: Excel has no Office-JS-exposed equivalent to Word's tracked-changes
+        // mode. Respond with an explicit ok, not the generic unknown-action
+        // fallthrough PowerPoint's host script currently falls into for these
+        // same two action names.
+        respond({ ok: true });
+      } else {
+        respond({ ok: false, error: 'Unknown action: ' + action });
+      }
+    }
+
+    // ── Mount ─────────────────────────────────────────────────────────────────
+    function mountHub() {
+      var meta = docMeta();
+      var params = new URLSearchParams({ surface: 'task-pane' });
+      if (meta.docUrl)   params.set('docUrl',   meta.docUrl);
+      if (meta.docTitle) params.set('docTitle',  meta.docTitle);
+      hubFrame.src = HUB_ORIGIN + '/ai-hub/?' + params.toString();
+
+      hubFrame.addEventListener('load', function() {
+        setTimeout(function() {
+          readFullContext(function(ctx) {
+            var msg = { type: 'word-context', payload: ctx };
+            if (hubReady) { pushToHub(msg); } else { pendingPush = msg; }
+          });
+        }, 300);
+        addSelectionHandler();
+      });
+    }
+
+    if (typeof Office !== 'undefined') {
+      Office.onReady(function() { mountHub(); });
+    } else {
+      window.addEventListener('DOMContentLoaded', mountHub);
+    }
+  </script>
+</body>
+</html>

package/public/ai-hub/excel-taskpane/manifest.xml

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<OfficeApp xmlns="http://schemas.microsoft.com/office/appforoffice/1.1"
+           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+           xmlns:bt="http://schemas.microsoft.com/office/officeappbasictypes/1.0"
+           xsi:type="TaskPaneApp">
+  <Id>da8d22c7-2c00-485a-bdc9-13dda7f80c48</Id>
+  <Version>1.0.0.0</Version>
+  <ProviderName>FRAIM</ProviderName>
+  <DefaultLocale>en-US</DefaultLocale>
+  <DisplayName DefaultValue="FRAIM"/>
+  <Description DefaultValue="AI Hub for your workbook - any FRAIM job, with sheet and selection context, in one task pane."/>
+  <IconUrl DefaultValue="https://localhost:43092/excel-taskpane/icon-64.png"/>
+  <HighResolutionIconUrl DefaultValue="https://localhost:43092/excel-taskpane/icon-64.png"/>
+  <AppDomains>
+    <AppDomain>https://appsforoffice.microsoft.com</AppDomain>
+  </AppDomains>
+
+  <Hosts>
+    <Host Name="Workbook"/>
+  </Hosts>
+
+  <Requirements>
+    <Sets>
+      <Set Name="ExcelApi" MinVersion="1.10"/>
+    </Sets>
+  </Requirements>
+
+  <DefaultSettings>
+    <SourceLocation DefaultValue="https://localhost:43092/excel-taskpane/"/>
+  </DefaultSettings>
+
+  <Permissions>ReadWriteDocument</Permissions>
+</OfficeApp>

package/public/ai-hub/script.js

@@ -5578,6 +5578,9 @@ function resolveNextJobFromCatalog(jobId) {
   const all = [
     ...((state.bootstrap && state.bootstrap.jobs) || []),
     ...((state.bootstrap && state.bootstrap.managerTemplates) || []),
+    // Issue #1247: internal jobs are excluded from the main picker list but must
+    // be resolvable so next-job recommendation chips can launch them.
+    ...((state.bootstrap && state.bootstrap.internalJobs) || []),
   ];
   return all.find((j) => j.id === jobId) || null;
 }
@@ -7663,6 +7666,22 @@ function deriveTitle(jobTitle, instructions) {
 // The browser sends raw manager instructions. AI Hub normalizes assigned
 // FRAIM jobs into host-facing invocations so the Hub UI and channel callers
 // share one start/continue contract.
+// Issue #1239: shared by startRun() and continueRun() — in a task-pane/
+// extension surface, fetches a fresh selection snapshot, merges it with the
+// last-pushed state.wordContext, and prepends the resulting document-context
+// block to outgoing text so the agent knows what the user is looking at. A
+// no-op outside task-pane/extension surfaces.
+async function withWordContext(text) {
+  let effective = text || '';
+  if (document.body.dataset.surface === 'task-pane' || document.body.dataset.surface === 'extension') {
+    const fresh = await requestWordContext('get-selection').catch(() => null);
+    const wc = (fresh && (fresh.selection || fresh.hasSelection)) ? { ...state.wordContext, ...fresh } : state.wordContext;
+    const ctxBlock = buildWordContextBlock(wc);
+    if (ctxBlock) effective = ctxBlock + '\n\n---\n\n' + effective;
+  }
+  return effective;
+}
+
 async function startRun(job, instructions, employeeId, preassignedConvId, invokedArea) {
   if (!hubEmployeeIsAvailable(employeeId)) {
     renderHubAgentSetupPanel();
@@ -7674,13 +7693,7 @@ async function startRun(job, instructions, employeeId, preassignedConvId, invoke
   // In task-pane/extension mode: get a fresh selection snapshot and prepend
   // document context to the instructions so the agent knows what the user is
   // looking at. stubPath resolution and FRAIM invocation are now server-side.
-  let effectiveInstructions = instructions || '';
-  if (document.body.dataset.surface === 'task-pane' || document.body.dataset.surface === 'extension') {
-    const fresh = await requestWordContext('get-selection').catch(() => null);
-    const wc = (fresh && (fresh.selection || fresh.hasSelection)) ? { ...state.wordContext, ...fresh } : state.wordContext;
-    const ctxBlock = buildWordContextBlock(wc);
-    if (ctxBlock) effectiveInstructions = ctxBlock + '\n\n---\n\n' + effectiveInstructions;
-  }
+  const effectiveInstructions = await withWordContext(instructions);
 
   // Issue #442: read the A/B toggle state from the modal before it closes.
   const abToggle = document.getElementById('ab-toggle');
@@ -7859,13 +7872,20 @@ async function continueRun(text, options) {
   upsertConversation(conv);
   refreshStatusSurfaces(); // #533 R5: also recolor the tree/area dots back to working
   renderActive();
+  // Issue #1239: task-pane/extension surfaces must attach current Word document
+  // context to every follow-up message, the same way startRun() does for the
+  // job-start instructions — otherwise a highlighted selection or a question
+  // asked mid-conversation reaches the agent with zero document context. Runs
+  // after the render above so the UI flips to "running" immediately on send,
+  // not after the (up to few-hundred-ms) context round trip.
+  const effectiveText = await withWordContext(text);
   try {
     let run;
     try {
       run = await requestJson(`/api/ai-hub/runs/${conv.runId}/messages`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ instructions: text, ...(coachingJobId ? { coachingJobId } : {}), ...(deliveryIntent ? { deliveryIntent } : {}) }),
+        body: JSON.stringify({ instructions: effectiveText, ...(coachingJobId ? { coachingJobId } : {}), ...(deliveryIntent ? { deliveryIntent } : {}) }),
       });
     } catch (e) {
       const isNotFound = /not found/i.test((e && e.message) || '');
@@ -7888,7 +7908,7 @@ async function continueRun(text, options) {
             conversationId: conv.id,
             conversationTitle: conv.title,
             sessionId: conv.sessionId,
-            instructions: text,
+            instructions: effectiveText,
             ...(coachingJobId ? { coachingJobId } : {}),
           }),
         });
@@ -7908,7 +7928,7 @@ async function continueRun(text, options) {
             jobTitle: conv.jobTitle || conv.jobId,
             conversationId: conv.id,
             conversationTitle: conv.title,
-            instructions: text,
+            instructions: effectiveText,
             ...(coachingJobId ? { coachingJobId } : {}),
           }),
         });
@@ -8159,7 +8179,9 @@ async function tryWordWriteBack(conv) {
   try {
     await requestWordContext('track-changes-on');
     const action = conv.wordStartedWithSelection ? 'insert-after' : 'append-to-doc';
-    await requestWordContext(action, { text: outputText });
+    // jobLabel (issue #1248): Word/PowerPoint ignore this extra field; Excel's
+    // write-back audit comment (R4) uses it to name the job that wrote the cell.
+    await requestWordContext(action, { text: outputText, jobLabel: conv.jobTitle || conv.jobId });
     await requestWordContext('track-changes-off');
     showStatus('Result written to document. Review tracked changes.');
   } catch (e) {