fraim-hub 2.0.269 → 2.0.270

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

@@ -53,15 +53,8 @@ const hub_launch_decision_1 = require("./hub-launch-decision");
 const hub_runtime_file_1 = require("./hub-runtime-file");
 const project_fraim_paths_1 = require("../core/utils/project-fraim-paths");
 const version_utils_1 = require("../cli/utils/version-utils");
-function resolveElectronBinary() {
-    try {
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
-        return require('electron');
-    }
-    catch {
-        return null;
-    }
-}
+const electron_dist_1 = require("./electron-dist");
+const process_liveness_1 = require("./process-liveness");
 function resolveDesktopEntry() {
     const candidates = [
         path_1.default.resolve(__dirname, 'desktop-main.js'),
@@ -78,10 +71,20 @@ function resolveDesktopEntry() {
     }
     return null;
 }
-function openDesktopWindow(projectPath, preferredPort, runtimeId) {
-    const electronBinary = resolveElectronBinary();
+// #1112: the Electron binary is resolved (and, on a first launch for a version, extracted) before
+// the spawn, not inside waitForDesktopHubReady. A one-time extraction is minutes of work on a slow
+// disk; charging it to the readiness budget is exactly the mistake #1110 fixed, so it happens here
+// with progress on stdout while nothing is being waited on.
+async function openDesktopWindow(projectPath, preferredPort, runtimeId) {
     const desktopEntry = resolveDesktopEntry();
-    if (!electronBinary || !desktopEntry) {
+    if (!desktopEntry) {
+        return null;
+    }
+    const electron = await (0, electron_dist_1.resolveHubElectronBinary)({
+        onProgress: (message) => console.log(message),
+        onError: (error) => console.log(`Could not prepare the shared Electron runtime (${error.message}). Opening the FRAIM Hub in your browser instead.`),
+    });
+    if (!electron) {
         return null;
     }
     const args = projectPath
@@ -90,7 +93,7 @@ function openDesktopWindow(projectPath, preferredPort, runtimeId) {
     if (runtimeId && runtimeId !== 'hub') {
         args.push('--hub-runtime-id', runtimeId);
     }
-    const child = (0, child_process_1.spawn)(electronBinary, args, {
+    const child = (0, child_process_1.spawn)(electron.binaryPath, args, {
         detached: true,
         stdio: 'ignore',
     });
@@ -110,15 +113,6 @@ function openBrowser(url) {
     const child = (0, child_process_1.spawn)('xdg-open', [url], { detached: true, stdio: 'ignore' });
     child.unref();
 }
-function isProcessAlive(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (e) {
-        return !!(e && e.code === 'EPERM');
-    }
-}
 function killPid(pid) {
     try {
         if (process.platform === 'win32') {
@@ -307,7 +301,7 @@ async function waitForDesktopHubReady(child, preferredPort, options = {}) {
 async function reconcileRunningHub(flags, runtimeId = 'hub') {
     const running = (0, hub_runtime_file_1.readHubRuntimeFile)((0, project_fraim_paths_1.getUserFraimDirPath)(), runtimeId);
     const confirmedVersion = running ? await fetchRunningHubVersion(running.port) : null;
-    const live = !!(running && confirmedVersion && isProcessAlive(running.pid));
+    const live = !!(running && confirmedVersion && (0, process_liveness_1.isPidAlive)(running.pid));
     const effective = live && running ? { ...running, version: confirmedVersion } : null;
     const decision = (0, hub_launch_decision_1.decideHubLaunch)({
         running: effective,
@@ -340,7 +334,7 @@ async function runHub(options) {
         if (wantDesktop) {
             await reconcileRunningHub({ restart: !!options.restart, keepRunning: !!options.keepRunning }, runtimeId);
         }
-        const desktopChild = wantDesktop ? openDesktopWindow(projectPath, preferredPort, runtimeId) : null;
+        const desktopChild = wantDesktop ? await openDesktopWindow(projectPath, preferredPort, runtimeId) : null;
         if (!desktopChild) {
             const port = await findAvailablePort(preferredPort);
             const server = new AiHubServer(projectPath ? { projectPath } : {});

package/dist/src/ai-hub/conversation-store-lock.js

@@ -7,22 +7,13 @@ exports.isLockStale = isLockStale;
 exports.withBucketLock = withBucketLock;
 const fs_1 = __importDefault(require("fs"));
 const os_1 = __importDefault(require("os"));
+const process_liveness_1 = require("./process-liveness");
 const DEFAULT_TIMEOUT_MS = 5000;
 const DEFAULT_STALE_MS = 10000;
 // Synchronous sleep without a busy spin (the store's write path is synchronous).
 function sleepMs(ms) {
     Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 }
-function pidAlive(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (error) {
-        // ESRCH: no such process. EPERM: exists but not ours (still alive).
-        return error.code === 'EPERM';
-    }
-}
 // A lock is stale (safe to steal) if its file is unreadable/absent, its timestamp is older than
 // staleMs, or it names a dead pid on this same host.
 function isLockStale(lockPath, staleMs = DEFAULT_STALE_MS) {
@@ -35,7 +26,7 @@ function isLockStale(lockPath, staleMs = DEFAULT_STALE_MS) {
     }
     if (typeof info.ts === 'number' && Date.now() - info.ts > staleMs)
         return true;
-    if (typeof info.pid === 'number' && info.host === os_1.default.hostname() && !pidAlive(info.pid))
+    if (typeof info.pid === 'number' && info.host === os_1.default.hostname() && !(0, process_liveness_1.isPidAlive)(info.pid))
         return true;
     return false;
 }

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

@@ -0,0 +1,265 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HUB_ELECTRON_VERSION = void 0;
+exports.electronExecutableRelativePath = electronExecutableRelativePath;
+exports.resolveSharedElectronDistDir = resolveSharedElectronDistDir;
+exports.resolveSharedElectronBinaryPath = resolveSharedElectronBinaryPath;
+exports.isElectronDistComplete = isElectronDistComplete;
+exports.ensureSharedElectronDist = ensureSharedElectronDist;
+exports.resolveHubElectronBinary = resolveHubElectronBinary;
+// #1112: one shared, versioned Electron dist instead of a private 345 MB copy per npx install.
+//
+// `electron` used to be a hard dependency of packages/fraim-hub. npm runs its postinstall in every
+// tree it installs into, and that postinstall extracts the ~345 MB platform zip. Because
+// `npx fraim-hub@latest` creates a fresh `_npx/<hash>/` tree for every published version, the same
+// dist was unpacked again on every upgrade: 27 copies and 9.1 GB on one developer machine, and a
+// first-execution cost on freshly written binaries that was the largest remaining term in the Hub
+// cold start measured in #1110.
+//
+// The extraction cannot be skipped at launch time. electron/install.js short-circuits only on
+// ELECTRON_SKIP_BINARY_DOWNLOAD, read from the environment of the npm process, and by the time
+// src/ai-hub/cli.ts runs npm has already unpacked. So `electron` is no longer declared at all, and
+// the Hub resolves the binary itself from ~/.fraim/bin/electron/<version>/ — extracted once per
+// Electron version per machine, shared by every installed and future fraim-hub version.
+//
+// The zip still comes from the same shared cache npm used (~/AppData/Local/electron/Cache on
+// Windows, ~/Library/Caches/electron on macOS, ~/.cache/electron on Linux), because this reuses
+// @electron/get and extract-zip — the two modules electron/install.js itself uses. That keeps
+// checksum validation, mirror and proxy environment variables, and symlink- and mode-preserving
+// extraction behaving exactly as they do today.
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const project_fraim_paths_1 = require("../core/utils/project-fraim-paths");
+const process_liveness_1 = require("./process-liveness");
+/**
+ * The exact Electron release the Hub runs on, and the runtime source of truth for it.
+ *
+ * @electron/get needs an exact version: a range cannot name a download. Two other declarations are
+ * pinned to this value and `scripts/validate-package-split.ts` fails the build if either drifts:
+ *   - `packages/fraim-hub` `build.electronVersion`, which is how electron-builder learns the
+ *     version now that `electron` is absent from that manifest.
+ *   - the repo root's `dependencies.electron` range, which still installs Electron for local dev,
+ *     `npm run hub:desktop`, and the Electron-launching test suites.
+ */
+exports.HUB_ELECTRON_VERSION = '41.2.2';
+/** Relative path of the Electron executable inside a dist, matching getPlatformPath() in electron/install.js. */
+function electronExecutableRelativePath(platform = process.platform) {
+    switch (platform) {
+        case 'darwin':
+            return path_1.default.join('Electron.app', 'Contents', 'MacOS', 'Electron');
+        case 'win32':
+            return 'electron.exe';
+        default:
+            return 'electron';
+    }
+}
+// An Electron release is `x.y.z` or `x.y.z-<prerelease>`, and nothing else. Anchoring on that shape
+// means a version string can never carry path syntax into the directory name below, which matters
+// because `ensureSharedElectronDist` calls a recursive `fs.rmSync` on the resulting path: a version
+// of `../../..` would delete an unrelated tree. Not reachable today - every caller resolves to the
+// compile-time `HUB_ELECTRON_VERSION` - so this is a guard at the write boundary, kept next to the
+// path construction it protects rather than left to every future caller to remember.
+const EXACT_ELECTRON_VERSION = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/;
+function assertPathSafeVersion(version) {
+    if (!EXACT_ELECTRON_VERSION.test(version)) {
+        throw new Error(`Refusing to use "${version}" as an Electron version: expected an exact release such as 41.2.2.`);
+    }
+    return version;
+}
+/**
+ * `~/.fraim/bin/electron/<version>/`.
+ *
+ * Deliberately a sibling of, not a child of, `resolveHubInstallDir()`
+ * (`~/.fraim/bin/fraim-hub-electron/`). That directory belongs to the installed Hub application:
+ * `runHubInstall` writes `fraim-hub.exe` and the downloaded release asset into it, and
+ * `installDownloadedAsset` does an `fs.rmSync` inside it on macOS. A shared runtime with a
+ * different lifecycle should not live inside a tree another code path deletes from.
+ */
+function resolveSharedElectronDistDir(version, fraimDir = (0, project_fraim_paths_1.getUserFraimDirPath)()) {
+    return path_1.default.join(fraimDir, 'bin', 'electron', assertPathSafeVersion(version));
+}
+/** Absolute path of the Electron executable inside the shared dist for a version. */
+function resolveSharedElectronBinaryPath(version, fraimDir = (0, project_fraim_paths_1.getUserFraimDirPath)(), platform = process.platform) {
+    return path_1.default.join(resolveSharedElectronDistDir(version, fraimDir), electronExecutableRelativePath(platform));
+}
+/**
+ * Whether a directory holds a complete dist for exactly this version.
+ *
+ * Same two conditions electron's own `isInstalled()` checks: the `version` file names this release,
+ * and the platform executable is present. A dist that fails either is stale or half-written, and
+ * spawning from it would fail at launch instead of here.
+ */
+function isElectronDistComplete(distDir, version, platform = process.platform) {
+    try {
+        const recorded = fs_1.default.readFileSync(path_1.default.join(distDir, 'version'), 'utf8').trim().replace(/^v/, '');
+        if (recorded !== version)
+            return false;
+        return fs_1.default.existsSync(path_1.default.join(distDir, electronExecutableRelativePath(platform)));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Resolve the platform zip through @electron/get, so a zip npm already cached for this version is a
+ * cache hit and no bytes cross the network. Checksums stay enabled: @electron/get validates the
+ * artifact against SHASUMS256.txt, fetching that 2 KB file when no local checksums.json is
+ * available. That is the only integrity check standing between a 345 MB download and executing it.
+ */
+const downloadElectronZip = async ({ version, platform, arch }) => {
+    // Required lazily: @electron/get pulls in got, fs-extra, and sumchecker, and none of that belongs
+    // in the module graph of a launch that resolves an already-extracted dist.
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const { downloadArtifact } = require('@electron/get');
+    return downloadArtifact({ version, artifactName: 'electron', platform, arch });
+};
+const extractElectronZip = async (zipPath, destDir) => {
+    // extract-zip is what electron/install.js uses, and it preserves the mode bits and the symlinks
+    // inside Electron.app/Contents/Frameworks that a naive zip reader drops.
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const extract = require('extract-zip');
+    await extract(zipPath, { dir: destDir });
+};
+/**
+ * Remove staging trees whose owning process is gone.
+ *
+ * The `finally` that cleans up a staging tree does not run when the process is killed, and the
+ * window it covers is a visible "Preparing the shared Electron runtime" message that invites a
+ * Ctrl+C. Without this sweep, one impatient interrupt strands ~345 MB under `~/.fraim` forever,
+ * which is the same disk leak this change exists to stop. A staging tree whose pid is still alive
+ * belongs to a concurrent launch and is left alone.
+ */
+function sweepDeadStagingDirs(distDir) {
+    const parent = path_1.default.dirname(distDir);
+    const prefix = `${path_1.default.basename(distDir)}.staging-`;
+    let entries;
+    try {
+        entries = fs_1.default.readdirSync(parent, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory() || !entry.name.startsWith(prefix))
+            continue;
+        const pid = Number(entry.name.slice(prefix.length));
+        if (Number.isInteger(pid) && pid > 0 && (0, process_liveness_1.isPidAlive)(pid))
+            continue;
+        try {
+            fs_1.default.rmSync(path_1.default.join(parent, entry.name), { recursive: true, force: true });
+        }
+        catch {
+            /* best effort: a tree we cannot delete is not a reason to fail a launch */
+        }
+    }
+}
+/**
+ * Return the Electron executable in the shared dist for this version, extracting it first if it is
+ * not already there. Returns immediately when a complete dist exists, which is the case on every
+ * launch after the first for a given Electron version.
+ *
+ * Extraction goes to a staging sibling and is promoted with a rename, matching the
+ * `${dir}.staging-${pid}` pattern in `org-pack-sync.ts` and `manager-pack-sync.ts`. A failure
+ * therefore leaves no partial tree at the versioned path, so the next launch cannot mistake one for
+ * a usable dist.
+ */
+async function ensureSharedElectronDist(options = {}) {
+    const version = options.version ?? exports.HUB_ELECTRON_VERSION;
+    const fraimDir = options.fraimDir ?? (0, project_fraim_paths_1.getUserFraimDirPath)();
+    const platform = options.platform ?? process.platform;
+    const arch = options.arch ?? process.arch;
+    const distDir = resolveSharedElectronDistDir(version, fraimDir);
+    const binaryPath = resolveSharedElectronBinaryPath(version, fraimDir, platform);
+    if (isElectronDistComplete(distDir, version, platform)) {
+        return binaryPath;
+    }
+    const downloadZip = options.downloadZip ?? downloadElectronZip;
+    const extractZip = options.extractZip ?? extractElectronZip;
+    const onProgress = options.onProgress;
+    onProgress?.(`Preparing the shared Electron ${version} runtime in ${distDir}. `
+        + 'This happens once per Electron version on this machine; later Hub launches reuse it.');
+    const zipPath = await downloadZip({ version, platform, arch });
+    await extractAndPromote({ zipPath, distDir, version, platform, extractZip });
+    onProgress?.(`Shared Electron ${version} runtime ready.`);
+    return binaryPath;
+}
+/**
+ * Unpack a zip into `distDir`, atomically.
+ *
+ * Extraction goes to a `${distDir}.staging-${pid}` sibling and is promoted with a rename, matching
+ * the pattern in `org-pack-sync.ts` and `manager-pack-sync.ts`. A failure therefore leaves no
+ * partial tree at the versioned path, so the next launch cannot mistake one for a usable dist.
+ */
+async function extractAndPromote(args) {
+    const { zipPath, distDir, version, platform, extractZip } = args;
+    const stagingDir = `${distDir}.staging-${process.pid}`;
+    fs_1.default.mkdirSync(path_1.default.dirname(distDir), { recursive: true });
+    sweepDeadStagingDirs(distDir);
+    fs_1.default.rmSync(stagingDir, { recursive: true, force: true });
+    try {
+        await extractZip(zipPath, stagingDir);
+        if (!isElectronDistComplete(stagingDir, version, platform)) {
+            throw new Error(`Extracted Electron ${version} is missing its version file or ${electronExecutableRelativePath(platform)}; `
+                + `refusing to install an incomplete dist from ${zipPath}.`);
+        }
+        // A concurrent launch may have finished extracting the same version while this one worked.
+        // Promoting over a complete dist would delete the tree that launch is spawning from, so the
+        // winner keeps it and this one discards its own copy.
+        if (!isElectronDistComplete(distDir, version, platform)) {
+            fs_1.default.rmSync(distDir, { recursive: true, force: true });
+            try {
+                fs_1.default.renameSync(stagingDir, distDir);
+            }
+            catch (error) {
+                // The same race, one step later: the target can appear between that check and this rename.
+                // A complete dist at the target is the outcome this call wanted, so it is success.
+                if (!isElectronDistComplete(distDir, version, platform))
+                    throw error;
+            }
+        }
+    }
+    finally {
+        fs_1.default.rmSync(stagingDir, { recursive: true, force: true });
+    }
+}
+/** Resolve the `electron` npm package's own binary, or null when it is absent or points nowhere. */
+function resolveInstalledElectronBinary(requireElectron) {
+    try {
+        const binaryPath = requireElectron();
+        return typeof binaryPath === 'string' && fs_1.default.existsSync(binaryPath) ? binaryPath : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The Electron binary this Hub should launch, or null when there is none.
+ *
+ * An installed `electron` package wins when one is present. That is this repo, and any consumer who
+ * depends on Electron themselves: its dist is already on disk, so preferring it avoids a needless
+ * download and keeps `npm run hub:desktop` and the Electron-launching suites on the exact path they
+ * use today. The published `fraim-hub` package declares no `electron`, so it takes the shared dist.
+ *
+ * Null is a supported outcome, not a failure: `openDesktopWindow()` returns null in that case and
+ * `runHub` starts the in-process server and opens a browser. An offline first launch must reach that
+ * fallback rather than throwing, so a download failure is reported through `onError` and swallowed.
+ */
+async function resolveHubElectronBinary(options = {}) {
+    const requireElectron = options.requireElectron
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        ?? (() => require('electron'));
+    const installed = resolveInstalledElectronBinary(requireElectron);
+    if (installed) {
+        return { binaryPath: installed, source: 'installed-package' };
+    }
+    try {
+        return { binaryPath: await ensureSharedElectronDist(options), source: 'shared-dist' };
+    }
+    catch (error) {
+        options.onError?.(error instanceof Error ? error : new Error(String(error)));
+        return null;
+    }
+}

package/dist/src/ai-hub/process-liveness.js

@@ -0,0 +1,25 @@
+"use strict";
+// Is a pid on this host still running? A leaf with no dependencies, so any Hub module can use it
+// without pulling in a graph or creating an import cycle.
+//
+// #1112 consolidated three byte-identical copies of this: `isProcessAlive` in `cli.ts` (which
+// decides whether a recorded Hub instance is live), `pidAlive` in `conversation-store-lock.ts`
+// (which decides whether a lock is stealable), and a third that the shared-Electron-dist sweep
+// would otherwise have added.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPidAlive = isPidAlive;
+/**
+ * `process.kill(pid, 0)` sends no signal; it only checks that the process exists and is signalable.
+ * `ESRCH` means no such process. `EPERM` means it exists but belongs to another user, which still
+ * counts as alive — treating it as dead is what would let a caller steal a live lock or delete a
+ * live process's working tree.
+ */
+function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === 'EPERM';
+    }
+}

package/dist/src/ai-hub/raw-event-log-store.js

@@ -0,0 +1,110 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AiHubRawEventLogStore = void 0;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const project_fraim_paths_1 = require("../core/utils/project-fraim-paths");
+function defaultRawEventLogRoot() {
+    try {
+        return node_path_1.default.join((0, project_fraim_paths_1.getUserFraimDirPath)(), 'ai-hub-event-logs');
+    }
+    catch {
+        return node_path_1.default.join(node_os_1.default.homedir(), '.fraim', 'ai-hub-event-logs');
+    }
+}
+function hashSegment(value, length = 24) {
+    return node_crypto_1.default.createHash('sha256').update(value || 'unknown').digest('hex').slice(0, length);
+}
+function safeRunFileName(runId) {
+    return `${hashSegment(runId, 40)}.jsonl`;
+}
+class AiHubRawEventLogStore {
+    constructor(rootDir = defaultRawEventLogRoot()) {
+        this.rootDir = node_path_1.default.resolve(rootDir);
+    }
+    append(bucketKey, conversationId, runId, entry) {
+        const dir = node_path_1.default.join(this.rootDir, hashSegment(bucketKey), hashSegment(conversationId));
+        node_fs_1.default.mkdirSync(dir, { recursive: true });
+        const logPath = node_path_1.default.join(dir, safeRunFileName(runId));
+        const metaPath = `${logPath}.meta.json`;
+        const createdAt = entry.createdAt || new Date().toISOString();
+        const line = {
+            createdAt,
+            channel: entry.channel,
+            text: entry.text,
+        };
+        node_fs_1.default.appendFileSync(logPath, `${JSON.stringify(line)}\n`, 'utf8');
+        const prior = this.readMeta(metaPath, runId, logPath);
+        const stat = node_fs_1.default.statSync(logPath);
+        const ref = {
+            runId,
+            path: logPath,
+            bytes: stat.size,
+            eventCount: prior.eventCount + 1,
+            createdAt: prior.createdAt || createdAt,
+            updatedAt: createdAt,
+            ...(prior.truncated ? { truncated: true } : {}),
+        };
+        node_fs_1.default.writeFileSync(metaPath, `${JSON.stringify(ref, null, 2)}\n`, 'utf8');
+        return ref;
+    }
+    readEntries(ref) {
+        const logPath = this.resolveReadableLogPath(ref.path);
+        if (!logPath || !node_fs_1.default.existsSync(logPath))
+            return [];
+        const lines = node_fs_1.default.readFileSync(logPath, 'utf8').split(/\r?\n/).filter(Boolean);
+        const entries = [];
+        for (const line of lines) {
+            try {
+                const parsed = JSON.parse(line);
+                if (typeof parsed.text === 'string' &&
+                    (parsed.channel === 'stdout' || parsed.channel === 'stderr' || parsed.channel === 'system')) {
+                    entries.push({
+                        createdAt: typeof parsed.createdAt === 'string' ? parsed.createdAt : new Date(0).toISOString(),
+                        channel: parsed.channel,
+                        text: parsed.text,
+                    });
+                }
+            }
+            catch {
+                // Corrupt diagnostic lines are ignored; callers fall back to other session sources.
+            }
+        }
+        return entries;
+    }
+    readMeta(metaPath, runId, logPath) {
+        if (!node_fs_1.default.existsSync(metaPath)) {
+            return { runId, path: logPath, bytes: 0, eventCount: 0, createdAt: '', updatedAt: '' };
+        }
+        try {
+            const parsed = JSON.parse(node_fs_1.default.readFileSync(metaPath, 'utf8'));
+            return {
+                runId,
+                path: logPath,
+                bytes: typeof parsed.bytes === 'number' ? parsed.bytes : 0,
+                eventCount: typeof parsed.eventCount === 'number' ? parsed.eventCount : 0,
+                createdAt: typeof parsed.createdAt === 'string' ? parsed.createdAt : '',
+                updatedAt: typeof parsed.updatedAt === 'string' ? parsed.updatedAt : '',
+                ...(parsed.truncated ? { truncated: true } : {}),
+            };
+        }
+        catch {
+            return { runId, path: logPath, bytes: 0, eventCount: 0, createdAt: '', updatedAt: '' };
+        }
+    }
+    resolveReadableLogPath(candidate) {
+        if (!candidate)
+            return null;
+        const resolved = node_path_1.default.resolve(candidate);
+        const rootPrefix = `${this.rootDir}${node_path_1.default.sep}`;
+        const comparableResolved = process.platform === 'win32' ? resolved.toLowerCase() : resolved;
+        const comparableRootPrefix = process.platform === 'win32' ? rootPrefix.toLowerCase() : rootPrefix;
+        return comparableResolved.startsWith(comparableRootPrefix) ? resolved : null;
+    }
+}
+exports.AiHubRawEventLogStore = AiHubRawEventLogStore;

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

@@ -60,6 +60,7 @@ const url_safety_1 = require("./url-safety");
 const manager_turns_1 = require("./manager-turns");
 const preferences_1 = require("./preferences");
 const conversation_store_1 = require("./conversation-store");
+const raw_event_log_store_1 = require("./raw-event-log-store");
 const conversation_search_1 = require("./conversation-search");
 const conversation_search_index_1 = require("./conversation-search-index");
 const conversation_store_lock_1 = require("./conversation-store-lock");
@@ -1220,6 +1221,45 @@ function appendHostMessage(run, hostId, event, channel) {
         return;
     run.messages.push((0, hosts_1.createHubMessage)('employee', displayMessage));
 }
+const MAX_PROJECTED_EVENT_CHARS = 300;
+const MAX_PROJECTED_EVENTS_PER_RUN = 200;
+function boundedEventText(text) {
+    const trimmed = text.trim();
+    if (trimmed.length <= MAX_PROJECTED_EVENT_CHARS)
+        return trimmed;
+    return `${trimmed.slice(0, MAX_PROJECTED_EVENT_CHARS - 1).trimEnd()}...`;
+}
+function looksLikeRawHostPayload(text) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return false;
+    if (trimmed.length > 1000)
+        return true;
+    return trimmed.startsWith('{') || trimmed.startsWith('[');
+}
+function projectHostEventForConversation(event, channel) {
+    if (event.message && channel === 'stdout') {
+        const display = stripStructuredHostPayloads(event.message);
+        return display ? (0, hosts_1.createHubEvent)(channel, boundedEventText(display)) : null;
+    }
+    if (!event.raw)
+        return null;
+    if (looksLikeRawHostPayload(event.raw))
+        return null;
+    if (channel === 'stdout')
+        return null;
+    return (0, hosts_1.createHubEvent)(channel, boundedEventText(event.raw));
+}
+function upsertEventLogRef(refs, ref) {
+    const next = (refs || []).filter((entry) => entry.runId !== ref.runId || entry.path !== ref.path);
+    next.push(ref);
+    return next;
+}
+function capProjectedEvents(run) {
+    if (run.events.length <= MAX_PROJECTED_EVENTS_PER_RUN)
+        return;
+    run.events = run.events.slice(run.events.length - MAX_PROJECTED_EVENTS_PER_RUN);
+}
 function isCodexMissingReasoningResumeError(run) {
     return (run.events || []).some((event) => {
         const text = String(event.text || '');
@@ -1888,6 +1928,7 @@ class AiHubServer {
             ? path_1.default.resolve(options.projectPath)
             : resolveInitialHubProjectPath(this.preferencesStore);
         this.conversationStore = options.conversationStore || new conversation_store_1.AiHubConversationStore();
+        this.rawEventLogStore = options.rawEventLogStore || new raw_event_log_store_1.AiHubRawEventLogStore();
         this.searchIndex = new conversation_search_index_1.ConversationSearchIndex(this.conversationStore);
         this.configuredAgentStore = options.configuredAgentStore || new configured_agents_1.AiHubConfiguredAgentStore();
         this.wordTaskpaneDir = options.wordTaskpaneDir ?? resolveWordTaskpaneDir(this.projectPath);
@@ -2441,8 +2482,24 @@ class AiHubServer {
         if (!conversationId)
             return { ok: true, continuityDecision: 'new_conversation' };
         const existing = this.conversationStore.loadConversation(options.projectPath, conversationId);
-        if (!existing)
+        if (!existing) {
+            const headerExists = this.conversationStore
+                .loadProjectHeaders(options.projectPath)
+                .some((conversation) => conversation.id === conversationId);
+            if (headerExists) {
+                console.warn('[ai-hub] hub.conversation_continuity.hydration_failed', { conversationId });
+                return {
+                    ok: false,
+                    status: 409,
+                    body: {
+                        error: 'Conversation body could not be loaded. Reload the conversation before continuing.',
+                        continuityDecision: 'not_found',
+                        conversationId,
+                    },
+                };
+            }
             return { ok: true, continuityDecision: 'new_conversation' };
+        }
         const existingAgentId = this.configuredAgentIdForConversation(existing, options.employees);
         if (existingAgentId !== options.requestedAgent.id) {
             console.warn('[ai-hub] hub.conversation_continuity.agent_switch_required', {
@@ -2517,18 +2574,36 @@ class AiHubServer {
         host_session_state_1.hostSessionState.applySession(run, owner, sessionId, { sourceRunId: run.id });
         run.resumeCommand = (0, hosts_1.buildInteractiveResumeCommand)(hostIdForCommand, sessionId);
     }
+    recordHostEvent(run, hostId, event, channel) {
+        appendHostMessage(run, hostId, event, channel);
+        if (event.raw) {
+            applyReviewProjection(run, event.raw);
+            try {
+                const ref = this.rawEventLogStore.append((0, conversation_store_1.conversationScopeKey)(run.scope, run.projectPath), run.conversationId || run.id, run.id, { channel, text: event.raw });
+                run.eventLogRefs = upsertEventLogRef(run.eventLogRefs, ref);
+            }
+            catch (error) {
+                run.events.push((0, hosts_1.createHubEvent)('system', 'Raw host event logging failed; visible conversation state was preserved.'));
+                console.error('[ai-hub] raw host event log write failed:', error instanceof Error ? error.message : error);
+            }
+        }
+        const projected = projectHostEventForConversation(event, channel);
+        if (projected)
+            run.events.push(projected);
+        capProjectedEvents(run);
+    }
     repairConversationHostSessionFromEvents(conversation, owner) {
-        if (!conversation || !Array.isArray(conversation.events))
+        if (!conversation)
             return false;
         let repaired = false;
-        for (const event of conversation.events) {
-            const text = typeof event?.text === 'string' ? event.text.trim() : '';
+        const repairFromText = (textValue) => {
+            const text = typeof textValue === 'string' ? textValue.trim() : '';
             if (!text)
-                continue;
+                return;
             try {
                 const parsed = (0, hosts_1.parseHostLine)(owner.baseHostId, text);
                 if (!parsed.sessionId)
-                    continue;
+                    return;
                 const projectedRun = {
                     id: conversation.runId || conversation.id,
                     hostSessions: conversation.hostSessions,
@@ -2544,6 +2619,16 @@ class AiHubServer {
                 // Persisted event logs include plain text, diagnostics, and historical host output.
                 // Non-parseable lines are not session signals.
             }
+        };
+        for (const event of Array.isArray(conversation.events) ? conversation.events : []) {
+            repairFromText(event?.text);
+        }
+        for (const ref of [...(conversation.eventLogRefs || [])].reverse()) {
+            for (const entry of this.rawEventLogStore.readEntries(ref).reverse()) {
+                repairFromText(entry.text);
+                if (repaired)
+                    return true;
+            }
         }
         return repaired;
     }
@@ -2582,6 +2667,7 @@ class AiHubServer {
                 channel: event.channel,
                 text: event.text,
             })),
+            eventLogRefs: run.eventLogRefs || [],
             artifacts: run.artifacts || [],
             reviewHandoff: run.reviewHandoff || null,
             delegation: run.delegation || null,
@@ -2651,6 +2737,17 @@ class AiHubServer {
         this.pendingConversationWrites.delete(run.id);
         this.persistRunConversationNow(run, activeId);
     }
+    finalizeRunConversationProjection(runId, activeId) {
+        this.pendingConversationWrites.delete(runId);
+        const run = this.runRegistry.get(runId);
+        if (!run)
+            return;
+        this.persistRunConversationNow(run, activeId ?? run.conversationId ?? run.id);
+        console.info('[ai-hub] hub.conversation_projection.finalized', {
+            conversationId: run.conversationId || run.id,
+            runId,
+        });
+    }
     startFreshCodexReviewApprovalFallback(runId, managerNote) {
         const run = this.runRegistry.get(runId);
         if (!run)
@@ -2682,11 +2779,7 @@ class AiHubServer {
                         clearCompactionLifecycle(current);
                     }
                     applyHostLifecycleSignal(current, event.hostLifecycle);
-                    appendHostMessage(current, run.hostId, event, channel);
-                    if (event.raw) {
-                        current.events.push((0, hosts_1.createHubEvent)(channel, event.raw));
-                        applyReviewProjection(current, event.raw);
-                    }
+                    this.recordHostEvent(current, run.hostId, event, channel);
                     if (event.agentIdentity)
                         applyAgentIdentitySignal(current, event.agentIdentity);
                     if (event.fraimJob)
@@ -2884,6 +2977,7 @@ class AiHubServer {
                 ...persistedEventsForRun(conversation),
                 (0, hosts_1.createHubEvent)('system', `Hub restart recovery reattached this conversation (${reason}).`),
             ],
+            eventLogRefs: conversation.eventLogRefs || [],
             currentPhase: persistedRun?.currentPhase || null,
             phaseHistory: persistedRun?.phaseHistory || [],
             phaseVisits: persistedRun?.phaseVisits || [],
@@ -2942,11 +3036,7 @@ class AiHubServer {
                         clearCompactionLifecycle(current);
                     }
                     applyHostLifecycleSignal(current, event.hostLifecycle);
-                    appendHostMessage(current, current.hostId, event, channel);
-                    if (event.raw) {
-                        current.events.push((0, hosts_1.createHubEvent)(channel, event.raw));
-                        applyReviewProjection(current, event.raw);
-                    }
+                    this.recordHostEvent(current, current.hostId, event, channel);
                     if (event.agentIdentity)
                         applyAgentIdentitySignal(current, event.agentIdentity);
                     if (event.fraimJob)
@@ -3268,11 +3358,7 @@ class AiHubServer {
                         clearCompactionLifecycle(current);
                     }
                     applyHostLifecycleSignal(current, event.hostLifecycle);
-                    appendHostMessage(current, managerRun.hostId, event, channel);
-                    if (event.raw) {
-                        current.events.push((0, hosts_1.createHubEvent)(channel, event.raw));
-                        applyReviewProjection(current, event.raw);
-                    }
+                    this.recordHostEvent(current, managerRun.hostId, event, channel);
                     if (event.agentIdentity)
                         applyAgentIdentitySignal(current, event.agentIdentity);
                     if (event.fraimJob)
@@ -3421,11 +3507,7 @@ class AiHubServer {
                         clearCompactionLifecycle(current);
                     }
                     applyHostLifecycleSignal(current, event.hostLifecycle);
-                    appendHostMessage(current, managerRun.hostId, event, channel);
-                    if (event.raw) {
-                        current.events.push((0, hosts_1.createHubEvent)(channel, event.raw));
-                        applyReviewProjection(current, event.raw);
-                    }
+                    this.recordHostEvent(current, managerRun.hostId, event, channel);
                     if (event.agentIdentity)
                         applyAgentIdentitySignal(current, event.agentIdentity);
                     if (event.fraimJob)
@@ -4246,6 +4328,7 @@ class AiHubServer {
                             (0, hosts_1.createHubEvent)('system', switchEventText),
                             ...(fallbackReason ? [(0, hosts_1.createHubEvent)('system', `Same-host resume fell back to handoff: ${fallbackReason}`)] : []),
                         ],
+                        eventLogRefs: conversation.eventLogRefs || [],
                         currentPhase: persistedRun?.currentPhase || null,
                         phaseHistory: persistedRun?.phaseHistory || [],
                         phaseVisits: persistedRun?.phaseVisits || [],
@@ -4282,11 +4365,7 @@ class AiHubServer {
                                     clearCompactionLifecycle(current);
                                 }
                                 applyHostLifecycleSignal(current, event.hostLifecycle);
-                                appendHostMessage(current, run.hostId, event, channel);
-                                if (event.raw) {
-                                    current.events.push((0, hosts_1.createHubEvent)(channel, event.raw));
-                                    applyReviewProjection(current, event.raw);
-                                }
+                                this.recordHostEvent(current, run.hostId, event, channel);
                                 if (event.agentIdentity)
                                     applyAgentIdentitySignal(current, event.agentIdentity);
                                 if (event.fraimJob)
@@ -5021,11 +5100,7 @@ class AiHubServer {
                                 clearCompactionLifecycle(current);
                             }
                             applyHostLifecycleSignal(current, event.hostLifecycle);
-                            appendHostMessage(current, hostId, event, channel);
-                            if (event.raw) {
-                                current.events.push((0, hosts_1.createHubEvent)(channel, event.raw));
-                                applyReviewProjection(current, event.raw);
-                            }
+                            this.recordHostEvent(current, hostId, event, channel);
                             if (event.agentIdentity)
                                 applyAgentIdentitySignal(current, event.agentIdentity);
                             if (event.fraimJob)
@@ -5063,9 +5138,7 @@ class AiHubServer {
                                     clearCompactionLifecycle(current);
                                 }
                                 applyHostLifecycleSignal(current, event.hostLifecycle);
-                                appendHostMessage(current, hostId, event, channel);
-                                if (event.raw)
-                                    current.events.push((0, hosts_1.createHubEvent)(channel, event.raw));
+                                this.recordHostEvent(current, hostId, event, channel);
                                 if (event.agentIdentity)
                                     applyAgentIdentitySignal(current, event.agentIdentity);
                                 if (event.usage)
@@ -5078,6 +5151,9 @@ class AiHubServer {
                                 current.status = exitCode === 0 ? 'completed' : 'failed';
                                 current.events.push((0, hosts_1.createHubEvent)('system', `Direct run exited with code ${exitCode ?? 'unknown'}.`));
                             });
+                            const updated = this.runRegistry.get(directId);
+                            if (updated)
+                                this.finalizeRunConversationProjection(directId, updated.conversationId || updated.id);
                             this.runRegistry.dispose(directId);
                         },
                     }, startSessionSeedForHost(hostId, directRun.id), launchContext);
@@ -5231,11 +5307,7 @@ class AiHubServer {
                                     clearCompactionLifecycle(current);
                                 }
                                 applyHostLifecycleSignal(current, event.hostLifecycle);
-                                appendHostMessage(current, run.hostId, event, channel);
-                                if (event.raw) {
-                                    current.events.push((0, hosts_1.createHubEvent)(channel, event.raw));
-                                    applyReviewProjection(current, event.raw);
-                                }
+                                this.recordHostEvent(current, run.hostId, event, channel);
                                 if (event.agentIdentity)
                                     applyAgentIdentitySignal(current, event.agentIdentity);
                                 if (event.fraimJob)
@@ -5282,11 +5354,7 @@ class AiHubServer {
                                 clearCompactionLifecycle(current);
                             }
                             applyHostLifecycleSignal(current, event.hostLifecycle);
-                            appendHostMessage(current, run.hostId, event, channel);
-                            if (event.raw) {
-                                current.events.push((0, hosts_1.createHubEvent)(channel, event.raw));
-                                applyReviewProjection(current, event.raw);
-                            }
+                            this.recordHostEvent(current, run.hostId, event, channel);
                             if (event.agentIdentity)
                                 applyAgentIdentitySignal(current, event.agentIdentity);
                             if (event.fraimJob)
@@ -5374,6 +5442,8 @@ class AiHubServer {
                 }
                 const sessionId = resolvedHostSession?.sessionId || requestedSessionId;
                 const now = new Date().toISOString();
+                const resumeEvents = persistedConversation ? persistedEventsForRun(persistedConversation) : [];
+                resumeEvents.push((0, hosts_1.createHubEvent)('system', `Resuming ${configuredAgent.label} (${hostId}) session ${sessionId} in ${projectPath}`));
                 const run = {
                     id: (0, crypto_1.randomUUID)(),
                     conversationId,
@@ -5385,8 +5455,11 @@ class AiHubServer {
                     // Issue #892: keep the invocation scope so a resumed manager/company run stays
                     // in its project-independent conversation bucket.
                     scope,
-                    createdAt: now, updatedAt: now, messages: [],
-                    events: [(0, hosts_1.createHubEvent)('system', `Resuming ${configuredAgent.label} (${hostId}) session ${sessionId} in ${projectPath}`)],
+                    createdAt: typeof persistedConversation?.createdAt === 'string' ? persistedConversation.createdAt : now,
+                    updatedAt: now,
+                    messages: persistedConversation ? persistedMessagesForRun(persistedConversation) : [],
+                    events: resumeEvents,
+                    eventLogRefs: persistedConversation?.eventLogRefs || [],
                     // Only carry phase state forward when the prior run was interrupted mid-job
                     // (status !== 'completed'). A completed conversation is a finished run;
                     // resuming the session starts a fresh job, so the tracker must be blank.
@@ -5423,15 +5496,13 @@ class AiHubServer {
                                 clearCompactionLifecycle(current);
                             }
                             applyHostLifecycleSignal(current, event.hostLifecycle);
-                            appendHostMessage(current, hostId, event, channel);
+                            this.recordHostEvent(current, hostId, event, channel);
                             if (event.raw) {
                                 const missingSessionId = extractMissingHostSessionId(event.raw);
                                 if (missingSessionId) {
                                     host_session_state_1.hostSessionState.markInvalidRun(current, { configuredAgentId: current.configuredAgentId || null, baseHostId: current.baseHostId || current.hostId }, missingSessionId, 'host-reported-missing-session');
                                     invalidatedMissingHostSession = true;
                                 }
-                                current.events.push((0, hosts_1.createHubEvent)(channel, event.raw));
-                                applyReviewProjection(current, event.raw);
                             }
                             if (event.agentIdentity)
                                 applyAgentIdentitySignal(current, event.agentIdentity);
@@ -5490,9 +5561,7 @@ class AiHubServer {
                                 clearCompactionLifecycle(current);
                             }
                             applyHostLifecycleSignal(current, event.hostLifecycle);
-                            appendHostMessage(current, run.hostId, event, channel);
-                            if (event.raw)
-                                current.events.push((0, hosts_1.createHubEvent)(channel, event.raw));
+                            this.recordHostEvent(current, run.hostId, event, channel);
                             if (event.usage)
                                 applyUsageSignal(current, event.usage);
                         });
@@ -5503,6 +5572,9 @@ class AiHubServer {
                             current.status = exitCode === 0 ? 'completed' : 'failed';
                             current.events.push((0, hosts_1.createHubEvent)('system', `Direct run exited with code ${exitCode ?? 'unknown'}.`));
                         });
+                        const updated = this.runRegistry.get(run.id);
+                        if (updated)
+                            this.finalizeRunConversationProjection(run.id, updated.conversationId || updated.id);
                         this.runRegistry.dispose(run.id);
                     },
                 }, directLaunch.launchContext);
@@ -6086,9 +6158,7 @@ class AiHubServer {
                                 clearCompactionLifecycle(current);
                             }
                             applyHostLifecycleSignal(current, event.hostLifecycle);
-                            appendHostMessage(current, hostId, event, channel);
-                            if (event.raw)
-                                current.events.push((0, hosts_1.createHubEvent)(channel, event.raw));
+                            this.recordHostEvent(current, hostId, event, channel);
                             if (event.agentIdentity)
                                 applyAgentIdentitySignal(current, event.agentIdentity);
                             if (event.fraimJob)
@@ -6105,6 +6175,9 @@ class AiHubServer {
                             current.status = exitCode === 0 ? 'completed' : 'failed';
                             current.events.push((0, hosts_1.createHubEvent)('system', `Trigger run exited with code ${exitCode ?? 'unknown'}.`));
                         });
+                        const updated = this.runRegistry.get(run.id);
+                        if (updated)
+                            this.finalizeRunConversationProjection(run.id, updated.conversationId || updated.id);
                         this.runRegistry.dispose(run.id);
                     },
                 }, startSessionSeedForHost(hostId, run.id), launchContext);
@@ -6238,11 +6311,7 @@ class AiHubServer {
                         clearCompactionLifecycle(current);
                     }
                     applyHostLifecycleSignal(current, event.hostLifecycle);
-                    appendHostMessage(current, hostId, event, channel);
-                    if (event.raw) {
-                        current.events.push((0, hosts_1.createHubEvent)(channel, event.raw));
-                        applyReviewProjection(current, event.raw);
-                    }
+                    this.recordHostEvent(current, hostId, event, channel);
                     if (event.agentIdentity)
                         applyAgentIdentitySignal(current, event.agentIdentity);
                     if (event.fraimJob)
@@ -6302,7 +6371,7 @@ class AiHubServer {
                 });
                 const parked = this.runRegistry.get(runId);
                 if (parked)
-                    this.persistRunConversation(parked, parked.conversationId || parked.id);
+                    this.finalizeRunConversationProjection(runId, parked.conversationId || parked.id);
                 this.runRegistry.dispose(runId);
                 return;
             }
@@ -6323,11 +6392,7 @@ class AiHubServer {
                                 clearCompactionLifecycle(r);
                             }
                             applyHostLifecycleSignal(r, event.hostLifecycle);
-                            appendHostMessage(r, current.hostId, event, channel);
-                            if (event.raw) {
-                                r.events.push((0, hosts_1.createHubEvent)(channel, event.raw));
-                                applyReviewProjection(r, event.raw);
-                            }
+                            this.recordHostEvent(r, current.hostId, event, channel);
                             if (event.seekMentoring)
                                 this.applySeekMentoringSignalToRun(r, event.seekMentoring);
                             if (event.usage)
@@ -6370,7 +6435,7 @@ class AiHubServer {
         if (updated) {
             if (postPark)
                 postPark(updated);
-            this.persistRunConversation(updated, updated.conversationId || updated.id);
+            this.finalizeRunConversationProjection(runId, updated.conversationId || updated.id);
         }
         this.runRegistry.dispose(runId);
         const latest = this.runRegistry.get(runId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fraim-hub",
-  "version": "2.0.269",
+  "version": "2.0.270",
   "description": "FRAIM Hub local companion package.",
   "bin": {
     "fraim-hub": "bin/fraim-hub.js",
@@ -91,6 +91,7 @@
   "build": {
     "appId": "ai.fraim.hub",
     "productName": "FRAIM Hub",
+    "electronVersion": "41.2.2",
     "artifactName": "FRAIM-Hub-${version}-${os}-${arch}.${ext}",
     "directories": {
       "output": "../../release/fraim-hub"
@@ -153,6 +154,7 @@
     "node": ">=16.0.0"
   },
   "dependencies": {
+    "@electron/get": "^2.0.3",
     "@octokit/rest": "^22.0.1",
     "adm-zip": "^0.6.0",
     "axios": "^1.7.0",
@@ -160,10 +162,10 @@
     "commander": "^14.0.2",
     "cors": "^2.8.5",
     "dotenv": "^16.4.7",
-    "electron": "^41.2.2",
     "electron-updater": "^6.8.9",
     "express": "^5.2.1",
-    "fraim": "2.0.269",
+    "extract-zip": "^2.0.1",
+    "fraim": "2.0.270",
     "mongodb": "^7.0.0",
     "node-cron": "4.2.1",
     "node-edge-tts": "^1.2.10",

package/public/ai-hub/script.js

@@ -10510,6 +10510,7 @@ function tfAdoptServerProjects(projects) {
     tf.projects = tfApplyUniqueProjectIds(normalized);
     return;
   }
+  if (normalized.length === 0) return;
   const byPath = new Map();
   for (const project of normalized) {
     const key = tfCanonicalProjectPath(project.folderPath || project.path || project.folder || '');
@@ -12154,10 +12155,11 @@ function tfRenderAreaConvPanel(el, conv) {
 }
 
 // #594 R2: return the most-relevant org-scoped conversation to show in the Company area.
-// state.conversations is { [projectPath]: ConversationSummary[] } — flatten all.
+// Issue #1124: only look in the @company bucket. Scanning all buckets caused project-scoped
+// org-learning-synthesis runs to hijack the Company tab.
 function tfActiveOrgConv() {
   const orgJobs = new Set(['organization-onboarding', 'organizational-learning-synthesis']);
-  const convs = Object.values(state.conversations || {}).flat().filter((c) => orgJobs.has(c.jobId));
+  const convs = ((state.conversations || {})[COMPANY_CONV_KEY] || []).filter((c) => orgJobs.has(c.jobId));
   // Prefer running > waiting (needs coaching) > most recently updated completed.
   return (
     convs.find((c) => c.status === 'running') ||
@@ -12309,13 +12311,18 @@ function tfRenderCompany() {
   const rail = document.getElementById('company-rail');
   if (rail) {
     rail.innerHTML = '';
-    const orgConvActive = !!tfActiveOrgConv();
+    const orgConv = tfActiveOrgConv();
+    const orgConvActive = !!orgConv;
     const infoBtn = document.createElement('button');
     infoBtn.type = 'button';
     infoBtn.className = 'area-rail-info-btn' + (orgConvActive ? '' : ' info-active');
     infoBtn.textContent = '📋 Company Info';
     infoBtn.addEventListener('click', () => tfToggleAreaView('company', 'info'));
     rail.appendChild(infoBtn);
+    // Issue #1124: when a company-scoped org conv exists, add a visible rail entry so
+    // the user can see and navigate to it. Previously the rail had only the static info
+    // button and the conversation was unreachable from the left nav.
+    if (orgConv) rail.appendChild(tfBuildManagerRunItem(orgConv));
     // #693 R1 (PR round 2): the "Company jobs" launcher list is retired. Its jobs
     // now run from the section they populate — Run Organization Onboarding in
     // "Context & rules", Synthesize company learnings in "Company learnings".
@@ -15129,7 +15136,11 @@ function tfRefreshAfterBootstrap() {
   // for the session as a dot + "run fraim setup"; re-populate here so a later
   // bootstrap that resolves the identity heals the avatar without a reload.
   tfPopulateAccountMenu();
-  tfAdoptServerProjects(state.bootstrap && Array.isArray(state.bootstrap.projects) ? state.bootstrap.projects : []);
+  // Do NOT re-apply state.bootstrap.projects here. The bootstrap list intentionally
+  // excludes conversation-store projects (Issue #975 perf opt); applying it after
+  // tfRefreshProjectsFromServerInBackground has already populated tf.projects with the
+  // full list would strip those conv-store projects and empty the overview.
+  // tfEnsureCurrentProject handles any missing active project without wiping the list.
   tfEnsureCurrentProject();
   tfRenderProjectTabs();
   if (tf.area === 'company') tfRenderCompany();