fraim-hub 2.0.325 → 2.0.327

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

@@ -17,22 +17,19 @@ const conversation_search_projection_1 = require("./conversation-search-projecti
 // They are NOT filesystem paths and must never be passed through path.resolve.
 exports.MANAGER_SCOPE_KEY = '@manager';
 exports.COMPANY_SCOPE_KEY = '@company';
-// Fields stripped from a header (the light shape the list UI renders). Everything else
-// (id, title, jobId, jobTitle, agentName, personaKey, status, runId, createdAt, lastUpdatedAt,
-// scope, reviewHandoff, ...) is kept. Client-only runtime flags are omitted too so stale index
-// cache state cannot make the frontend skip lazy body hydration.
-const HEADER_OMITTED_FIELDS = [
-    'messages',
-    'events',
-    'artifacts',
-    'run',
-    'handoffSummary',
-    '_bodyLoaded',
-    '_stopping',
-    '_priorEvents',
-    '_priorMessages',
+// Issue #1765: public list metadata is opt-in. These fields feed the shared Projects,
+// Manager and Company rail identity, ordering, status, trigger and delegation controls
+// (buildAreaRunButton / conversationUiState in public/ai-hub/script.js). New body fields
+// must never silently enlarge every list response or short-circuit lazy hydration.
+const HEADER_FIELDS = [
+    'id', 'projectPath', 'scope', 'invokedArea', 'title', 'jobId', 'jobTitle',
+    'agentName', 'configuredAgentId', 'configuredAgentLabel', 'baseHostId', 'personaKey',
+    'runId', 'status', 'pauseReason', 'createdAt', 'lastUpdatedAt', 'issueNumber',
+    'sourceTrigger', 'blocked', 'stopped', 'reviewApproved', 'compareMode', 'compareRunId',
+    'managedByRunId', 'managedByPersonaKey', 'managedReviewStatus', 'delegationTaskId',
+    'humanCoachingDisabled', 'personaSnapshot', 'reviewHandoff',
 ];
-const HEADER_OMITTED_FIELD_SET = new Set(HEADER_OMITTED_FIELDS);
+const HEADER_FIELD_SET = new Set([...HEADER_FIELDS, 'personaSnapshot', 'delegation', 'reviewHandoff']);
 /**
  * Issue #708: resolve the conversation store bucket key for a given scope.
  * - 'manager'/'company' → a stable sentinel key (project-independent home).
@@ -340,7 +337,7 @@ function normalizeConversation(projectPath, raw) {
         status: value.status,
         // Issue #904: carry pauseReason explicitly so it survives the ...value spread round-trip.
         ...(value.pauseReason !== undefined && { pauseReason: value.pauseReason }),
-        createdAt: value.createdAt ?? new Date().toISOString(),
+        createdAt: value.createdAt ?? value.lastUpdatedAt ?? new Date().toISOString(),
         lastUpdatedAt: value.lastUpdatedAt ?? value.createdAt ?? new Date().toISOString(),
     };
 }
@@ -361,18 +358,23 @@ function newestFirst(a, b) {
     return timestampValue(b.lastUpdatedAt) - timestampValue(a.lastUpdatedAt);
 }
 function toHeader(conv) {
-    const header = { ...conv };
-    const delegation = compactDelegationForHeader(header.delegation);
-    for (const field of HEADER_OMITTED_FIELDS)
-        delete header[field];
-    if (delegation)
-        header.delegation = delegation;
-    for (const field of Object.keys(header)) {
-        if (field.startsWith('_'))
-            delete header[field];
+    const header = pickHeaderFields(conv, HEADER_FIELDS);
+    if (conv.delegation !== undefined) {
+        header.delegation = compactDelegationForHeader(conv.delegation) ?? null;
     }
     return header;
 }
+function pickHeaderFields(raw, fields) {
+    const result = {};
+    if (!raw || typeof raw !== 'object')
+        return result;
+    const value = raw;
+    for (const field of fields) {
+        if (Object.prototype.hasOwnProperty.call(value, field))
+            result[field] = value[field];
+    }
+    return result;
+}
 function compactDelegationForHeader(raw) {
     if (!raw || typeof raw !== 'object')
         return undefined;
@@ -402,15 +404,15 @@ function compactDelegationForHeader(raw) {
     };
 }
 function headerNeedsSanitization(header) {
-    const value = header;
-    return Object.keys(value).some((field) => HEADER_OMITTED_FIELD_SET.has(field) || field.startsWith('_'));
+    return Object.keys(header).some((field) => !HEADER_FIELD_SET.has(field));
 }
 function sanitizeBucketIndex(index) {
     let changed = false;
     const headers = index.headers.map((header) => {
+        const compact = toHeader(header);
         if (headerNeedsSanitization(header))
             changed = true;
-        return toHeader(header);
+        return compact;
     }).sort(newestFirst);
     const activeId = index.activeId && headers.some((header) => header.id === index.activeId) ? index.activeId : null;
     if (activeId !== index.activeId)

package/dist/src/ai-hub/desktop-installer-setup.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readInstallerSetupApiKey = readInstallerSetupApiKey;
+exports.repairInstallerIdeMcpEntries = repairInstallerIdeMcpEntries;
+exports.runDesktopInstallerSetup = runDesktopInstallerSetup;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const project_fraim_paths_1 = require("../core/utils/project-fraim-paths");
+const ide_detector_1 = require("../cli/setup/ide-detector");
+const auto_mcp_setup_1 = require("../cli/setup/auto-mcp-setup");
+const fraim_mcp_latest_launcher_1 = require("../cli/mcp/fraim-mcp-latest-launcher");
+const managed_node_runtime_1 = require("../cli/utils/managed-node-runtime");
+const win32_cmd_spawn_1 = require("../cli/utils/win32-cmd-spawn");
+function readInstallerSetupApiKey(configPath = path_1.default.join((0, project_fraim_paths_1.getUserFraimDirPath)(), 'config.json')) {
+    if (!fs_1.default.existsSync(configPath))
+        return null;
+    try {
+        const parsed = JSON.parse(fs_1.default.readFileSync(configPath, 'utf8'));
+        return typeof parsed.apiKey === 'string' && parsed.apiKey.trim() ? parsed.apiKey.trim() : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function repairInstallerIdeMcpEntries(options = {}) {
+    const logger = options.logger ?? console;
+    const fraimKey = readInstallerSetupApiKey(options.configPath);
+    if (!fraimKey) {
+        logger.log('[fraim-installer-setup] no existing config.json apiKey; IDE MCP repair will run from first-run');
+        return { status: 'skipped', ideCount: 0, reason: 'missing-config-api-key' };
+    }
+    const detectedIDEs = (options.detectInstalledIDEs ?? ide_detector_1.detectInstalledIDEs)();
+    const ideNames = detectedIDEs.map((ide) => ide.name).filter(Boolean);
+    if (ideNames.length === 0) {
+        logger.log('[fraim-installer-setup] no supported IDEs detected for MCP repair');
+        return { status: 'skipped', ideCount: 0, reason: 'no-detected-ides' };
+    }
+    const previousNonInteractive = process.env.FRAIM_NON_INTERACTIVE;
+    process.env.FRAIM_NON_INTERACTIVE = '1';
+    try {
+        await (options.autoConfigureMCP ?? auto_mcp_setup_1.autoConfigureMCP)(fraimKey, ideNames);
+        logger.log(`[fraim-installer-setup] repaired MCP config for ${ideNames.length} detected IDE(s)`);
+        return { status: 'repaired', ideCount: ideNames.length };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.warn(`[fraim-installer-setup] IDE MCP repair skipped after error: ${message}`);
+        return { status: 'failed', ideCount: ideNames.length, reason: message };
+    }
+    finally {
+        if (previousNonInteractive === undefined)
+            delete process.env.FRAIM_NON_INTERACTIVE;
+        else
+            process.env.FRAIM_NON_INTERACTIVE = previousNonInteractive;
+    }
+}
+function warmInstallerCliCache() {
+    const cliShim = (0, fraim_mcp_latest_launcher_1.getFraimCliShimPath)();
+    const options = { env: process.env, encoding: 'utf8', stdio: 'inherit' };
+    const result = process.platform === 'win32'
+        ? (0, win32_cmd_spawn_1.spawnViaCmdExe)(cliShim, ['--version'], options)
+        : (0, child_process_1.spawnSync)(cliShim, ['--version'], options);
+    if (result.status !== 0) {
+        throw new Error(`FRAIM CLI bootstrap exited with code ${result.status ?? 'unknown'}.`);
+    }
+}
+async function runDesktopInstallerSetup(logger = console) {
+    await (0, managed_node_runtime_1.ensureManagedNpm)({
+        onProgress: (message) => logger.log(`[fraim-installer-setup] ${message}`),
+    });
+    (0, fraim_mcp_latest_launcher_1.ensureFraimMcpLatestLauncher)();
+    warmInstallerCliCache();
+    await repairInstallerIdeMcpEntries({ logger });
+    logger.log('[fraim-installer-setup] stable CLI and MCP launchers are ready');
+}

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

@@ -20,6 +20,10 @@ async function bootstrapFrom(entryPath) {
     await entry.bootstrap();
 }
 async function launch() {
+    if (process.argv.includes('--fraim-installer-setup')) {
+        await bootstrapFrom(BUNDLED_ENTRY_PATH);
+        return;
+    }
     // Issue #1415: deterministic escape hatch for integration testing — skips the real npm
     // resolution (and its dependence on whatever happens to be published at test time) so a test can
     // prove the Electron main-process boot chain itself (resolveHubAppEntry -> require -> bootstrap

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

@@ -20,7 +20,7 @@ const window_open_decision_1 = require("./window-open-decision");
 const bundled_asset_resolver_1 = require("./bundled-asset-resolver");
 const server_2 = require("../first-run/server");
 const session_service_1 = require("../first-run/session-service");
-const fraim_mcp_latest_launcher_1 = require("../cli/mcp/fraim-mcp-latest-launcher");
+const desktop_installer_setup_1 = require("./desktop-installer-setup");
 const desktop_auto_updater_1 = require("./desktop-auto-updater");
 const hub_app_materializer_1 = require("./hub-app-materializer");
 const hub_instance_reconciliation_1 = require("./hub-instance-reconciliation");
@@ -89,13 +89,6 @@ function applyUserDataOverride() {
     fs_1.default.mkdirSync(userDataDir, { recursive: true });
     electron_1.app.setPath('userData', userDataDir);
 }
-function configurePackagedFraimRuntime() {
-    if (!electron_1.app.isPackaged && process.env.FRAIM_DESKTOP_FIRST_RUN !== '1')
-        return;
-    process.env.FRAIM_PACKAGED_CLI_EXECUTABLE = process.execPath;
-    process.env.FRAIM_PACKAGED_CLI_SCRIPT = (0, hub_app_materializer_1.resolvePackagedCliScriptPath)(__dirname);
-    (0, fraim_mcp_latest_launcher_1.ensureFraimMcpLatestLauncher)();
-}
 function shouldShowEmbeddedFirstRun() {
     if (!electron_1.app.isPackaged && process.env.FRAIM_DESKTOP_FIRST_RUN !== '1')
         return false;
@@ -153,6 +146,16 @@ async function configureAutoUpdater() {
     });
     return result.action === 'installing';
 }
+async function runPackagedInstallerRepair() {
+    if (!electron_1.app.isPackaged || process.env.FRAIM_INSTALLER_LIFECYCLE_TEST === '1')
+        return;
+    try {
+        await (0, desktop_installer_setup_1.runDesktopInstallerSetup)(console);
+    }
+    catch (error) {
+        console.warn('[fraim] packaged installer repair failed:', error);
+    }
+}
 // Issue #1415: shared by every path that needs to know "is a newer FRAIM Hub published than the
 // one currently running" — the automatic second-instance/activate recheck below, and the
 // manually-triggered restart from the web UI's update badge (see restartToLatestNow). Compares
@@ -655,6 +658,12 @@ async function bootstrap() {
         preferredPort: options.preferredPort,
         hasProjectPath: Boolean(options.projectPath),
     });
+    if (process.argv.includes('--fraim-installer-setup')) {
+        await electron_1.app.whenReady();
+        await (0, desktop_installer_setup_1.runDesktopInstallerSetup)(console);
+        electron_1.app.exit(0);
+        return;
+    }
     electron_1.app.on('child-process-gone', (_event, details) => {
         (0, hub_main_diagnostics_1.recordHubMainDiagnostic)('app.child_process_gone', details);
     });
@@ -679,7 +688,6 @@ async function bootstrap() {
     });
     await electron_1.app.whenReady();
     electron_1.app.setName(displayName(options.runtimeId));
-    configurePackagedFraimRuntime();
     // Issue #1415 (follow-up): app.requestSingleInstanceLock() above only sees another instance of
     // *this same identity* — it cannot see a Hub already running via a different launch path (e.g.
     // `npx fraim-hub`'s raw electron.exe, confirmed live to end up under a different userData scope
@@ -710,6 +718,7 @@ async function bootstrap() {
     // First-launch housekeeping (idempotent, fast on subsequent runs)
     if (process.env.FRAIM_INSTALLER_LIFECYCLE_TEST !== '1') {
         ensureLoginItem();
+        await runPackagedInstallerRepair();
         const installingUpdate = await configureAutoUpdater();
         if (installingUpdate)
             return;

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

@@ -603,7 +603,7 @@ function stringifyMentorCallArgs(rawArgs) {
 }
 function resultTextFromValue(value) {
     if (typeof value === 'string')
-        return value.trim() || null;
+        return value.trim() ? value : null;
     if (Array.isArray(value)) {
         const parts = value
             .map((entry) => resultTextFromValue(entry))
@@ -693,6 +693,9 @@ function parseMicroEventsSignal(hostId, line) {
         }
         else if (itemType !== 'agent_message' && itemType !== 'error') {
             events.push(microEventFromNonMentorToolCall(item) || { kind: 'tool_call', text: itemType });
+            const output = resultTextFromValue(item.result ?? item.output ?? item.aggregated_output);
+            if (output)
+                events.push({ kind: 'tool_result', text: output });
         }
     }
     if (item && item.type === 'mcp_tool_call' && isFraimTool(readToolName(item), 'seekMentoring')) {
@@ -724,7 +727,7 @@ function parseMicroEventsSignal(hostId, line) {
         }
         else if (root.type === 'tool.execution_complete') {
             const resultText = resultTextFromValue(data.result ?? data.output ?? data.content);
-            events.push({ kind: 'tool_call', text: resultText ? `${rootType}: ${resultText}` : rootType });
+            events.push({ kind: 'tool_result', text: resultText || rootType });
             rootTypeHandled = true;
         }
     }

package/dist/src/ai-hub/hub-app-materializer.js

@@ -5,11 +5,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HUB_APP_ENTRY_RELATIVE = exports.HUB_APP_PACKAGE_NAME = void 0;
 exports.redactCredentialLikeSubstrings = redactCredentialLikeSubstrings;
-exports.resolvePackagedCliScriptPath = resolvePackagedCliScriptPath;
 exports.planHubAppMaterialization = planHubAppMaterialization;
 exports.resolveHubAppCacheDir = resolveHubAppCacheDir;
 exports.isHubAppCacheComplete = isHubAppCacheComplete;
 exports.listCachedHubAppVersions = listCachedHubAppVersions;
+exports.runNpmInstall = runNpmInstall;
 exports.ensureMaterializedHubApp = ensureMaterializedHubApp;
 exports.resolveHubAppEntry = resolveHubAppEntry;
 const fs_1 = __importDefault(require("fs"));
@@ -55,19 +55,6 @@ function redactCredentialLikeSubstrings(text) {
 exports.HUB_APP_PACKAGE_NAME = 'fraim-hub';
 /** Relative path, from a materialized (or bundled) package root, to the Electron main entry. */
 exports.HUB_APP_ENTRY_RELATIVE = path_1.default.join('dist', 'src', 'ai-hub', 'desktop-main.js');
-/**
- * Where the packaged CLI/MCP shim (`ensureFraimMcpLatestLauncher()`) should find `fraim`'s CLI
- * script, derived from `desktop-main.ts`'s own directory (`<packageRoot>/dist/src/ai-hub/`) rather
- * than Electron's `app.getAppPath()`. `desktop-launcher.ts` may have loaded `desktop-main.js` from a
- * materialized `fraim-hub@<latest>` copy under `~/.fraim/bin/hub-app/<version>/` rather than from
- * the original app.asar, and `app.getAppPath()` always names the latter regardless of which copy is
- * actually running. `moduleDir` tracks whichever copy is really executing. Kept in this
- * Electron-free module (rather than inlined in `desktop-main.ts`) so it is unit-testable without an
- * Electron `app` object.
- */
-function resolvePackagedCliScriptPath(moduleDir) {
-    return path_1.default.join(moduleDir, '..', '..', '..', 'node_modules', 'fraim', 'bin', 'fraim.js');
-}
 function pickNewestComplete(cachedVersions) {
     const versions = cachedVersions.filter((entry) => entry.complete).map((entry) => entry.version);
     if (versions.length === 0)
@@ -178,16 +165,19 @@ function listCachedHubAppVersions(fraimDir = (0, project_fraim_paths_1.getUserFr
  * every dependency to that top level; nothing here relies on nested-dependency resolution.
  *
  * The `npm` executable itself is resolved via `ensureManagedNpm()` (system PATH, an already-managed
- * runtime, or a freshly downloaded one) rather than assumed present on PATH — a genuinely GUI-only
- * install (native installer only, no CLI ever run) has neither system npm nor FRAIM's own managed
- * one, since first-run's embedded-desktop path only needs Electron's own bundled Node for its own
- * purposes and never downloads a standalone npm (see managed-node-runtime.ts's own header comment).
+ * runtime, or a freshly downloaded one) rather than assumed present on PATH. Installer setup
+ * prepares that shared runtime, while this fallback also supports older installs and recovery
+ * when installer setup did not finish.
  */
 function runNpmInstall(npmPath, args) {
+    // POSIX npm uses /usr/bin/env node. A GUI launch may have no system Node
+    // on PATH even after ensureManagedNpm has downloaded a complete runtime.
+    const npmPathValue = [path_1.default.dirname(npmPath), process.env.PATH].filter(Boolean).join(path_1.default.delimiter);
+    const env = { ...process.env, PATH: npmPathValue, ...(process.platform === 'win32' ? { Path: npmPathValue } : {}) };
     if (process.platform !== 'win32') {
-        return (0, child_process_1.spawnSync)(npmPath, args, { encoding: 'utf8' });
+        return (0, child_process_1.spawnSync)(npmPath, args, { encoding: 'utf8', env });
     }
-    return (0, win32_cmd_spawn_1.spawnViaCmdExe)(npmPath, args, { encoding: 'utf8' });
+    return (0, win32_cmd_spawn_1.spawnViaCmdExe)(npmPath, args, { encoding: 'utf8', env });
 }
 const defaultInstallPackage = async (version, destDir) => {
     fs_1.default.mkdirSync(destDir, { recursive: true });

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

@@ -6,16 +6,11 @@ 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 types_1 = require("./types");
 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');
-    }
+    return node_path_1.default.join((0, project_fraim_paths_1.getUserFraimDirPath)(), 'ai-hub-event-logs');
 }
 function hashSegment(value, length = 24) {
     return node_crypto_1.default.createHash('sha256').update(value || 'unknown').digest('hex').slice(0, length);
@@ -23,20 +18,39 @@ function hashSegment(value, length = 24) {
 function safeRunFileName(runId) {
     return `${hashSegment(runId, 40)}.jsonl`;
 }
+function parseEntry(line) {
+    try {
+        const value = JSON.parse(line);
+        if (typeof value.text !== 'string' || !['stdout', 'stderr', 'system'].includes(value.channel))
+            return null;
+        return { createdAt: typeof value.createdAt === 'string' ? value.createdAt : new Date(0).toISOString(), channel: value.channel, text: value.text,
+            ...(types_1.AI_HUB_MICRO_EVENT_KINDS.includes(value.hubKind) ? { hubKind: value.hubKind } : {}),
+            ...(typeof value.hostId === 'string' ? { hostId: value.hostId } : {}),
+            ...(Array.isArray(value.microEvents) ? { microEvents: value.microEvents.filter((event) => event && types_1.AI_HUB_MICRO_EVENT_KINDS.includes(event.kind) && typeof event.text === 'string') } : {}) };
+    }
+    catch {
+        return null;
+    }
+}
 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`;
+        if (!this.resolveReadableLogPath(logPath) || !this.resolveReadableLogPath(metaPath))
+            throw new Error('Event archive path is outside its root');
+        node_fs_1.default.mkdirSync(dir, { recursive: true });
         const createdAt = entry.createdAt || new Date().toISOString();
         const line = {
             createdAt,
             channel: entry.channel,
             text: entry.text,
+            ...(entry.hubKind ? { hubKind: entry.hubKind } : {}),
+            ...(entry.hostId ? { hostId: entry.hostId } : {}),
+            ...(entry.microEvents ? { microEvents: entry.microEvents } : {}),
         };
         node_fs_1.default.appendFileSync(logPath, `${JSON.stringify(line)}\n`, 'utf8');
         const prior = this.readMeta(metaPath, runId, logPath);
@@ -48,6 +62,8 @@ class AiHubRawEventLogStore {
             eventCount: prior.eventCount + 1,
             createdAt: prior.createdAt || createdAt,
             updatedAt: createdAt,
+            ownerPid: process.pid,
+            ...(entry.hostId || prior.hostId ? { hostId: entry.hostId || prior.hostId } : {}),
             ...(prior.truncated ? { truncated: true } : {}),
         };
         node_fs_1.default.writeFileSync(metaPath, `${JSON.stringify(ref, null, 2)}\n`, 'utf8');
@@ -60,22 +76,90 @@ class AiHubRawEventLogStore {
         const lines = node_fs_1.default.readFileSync(logPath, 'utf8').split(/\r?\n/).filter(Boolean);
         const entries = [];
         for (const line of lines) {
+            const entry = parseEntry(line);
+            if (entry)
+                entries.push(entry);
+        }
+        return entries;
+    }
+    markEnded(ref, endedAt) {
+        const logPath = this.resolveReadableLogPath(ref.path);
+        if (!logPath || !node_fs_1.default.existsSync(logPath))
+            return ref;
+        if (!this.resolveReadableLogPath(`${logPath}.meta.json`))
+            throw new Error('Event archive metadata is outside its root');
+        const next = { ...this.readMeta(`${logPath}.meta.json`, ref.runId, logPath), endedAt };
+        delete next.ownerPid;
+        node_fs_1.default.writeFileSync(`${logPath}.meta.json`, `${JSON.stringify(next, null, 2)}\n`, 'utf8');
+        return next;
+    }
+    /** Read display-ready entries in chronological order without reconstructing host output. */
+    async readMicroEvents(refs) {
+        const events = [];
+        let missingArchives = 0;
+        let legacyArchives = 0;
+        for (const ref of refs) {
+            const logPath = this.resolveReadableLogPath(ref.path);
+            if (!logPath) {
+                missingArchives++;
+                continue;
+            }
+            let size;
+            try {
+                size = (await node_fs_1.default.promises.stat(logPath)).size;
+            }
+            catch (error) {
+                if (error.code === 'ENOENT') {
+                    missingArchives++;
+                    continue;
+                }
+                throw error;
+            }
+            if (!size)
+                continue;
+            let hasLegacyEntries = false;
+            // Snapshot the size; only newline-terminated records are committed. The
+            // stream owns its descriptor and decodes UTF-8 across chunk boundaries.
+            const stream = node_fs_1.default.createReadStream(logPath, { encoding: 'utf8', end: size - 1 });
+            let pending = '';
+            let lineNumber = 0;
             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,
-                    });
+                for await (const chunk of stream) {
+                    const lines = (pending + chunk).split('\n');
+                    pending = lines.pop();
+                    for (const line of lines) {
+                        const entry = parseEntry(line);
+                        const id = `${ref.runId}:${lineNumber++}`;
+                        if (!entry)
+                            continue;
+                        const displayed = entry.hubKind ? [{ kind: entry.hubKind, text: entry.text }] : entry.microEvents;
+                        if (!displayed) {
+                            hasLegacyEntries = true;
+                            continue;
+                        }
+                        displayed.forEach((event, index) => events.push({
+                            id: `${id}:${index}`, kind: event.kind, text: event.text,
+                            channel: event.kind === 'manager_input' ? 'manager' : entry.channel, createdAt: entry.createdAt,
+                        }));
+                    }
+                    await new Promise((resolve) => setImmediate(resolve));
                 }
             }
-            catch {
-                // Corrupt diagnostic lines are ignored; callers fall back to other session sources.
+            catch (error) {
+                if (error.code === 'ENOENT') {
+                    missingArchives++;
+                    continue;
+                }
+                throw error;
             }
+            finally {
+                stream.destroy();
+            }
+            if (hasLegacyEntries)
+                legacyArchives++;
         }
-        return entries;
+        events.sort((a, b) => Date.parse(a.createdAt) - Date.parse(b.createdAt));
+        return { events, archiveAvailable: refs.length > missingArchives, missingArchives, legacyArchives };
     }
     readMeta(metaPath, runId, logPath) {
         if (!node_fs_1.default.existsSync(metaPath)) {
@@ -90,6 +174,9 @@ class AiHubRawEventLogStore {
                 eventCount: typeof parsed.eventCount === 'number' ? parsed.eventCount : 0,
                 createdAt: typeof parsed.createdAt === 'string' ? parsed.createdAt : '',
                 updatedAt: typeof parsed.updatedAt === 'string' ? parsed.updatedAt : '',
+                ...(typeof parsed.endedAt === 'string' ? { endedAt: parsed.endedAt } : {}),
+                ...(typeof parsed.ownerPid === 'number' ? { ownerPid: parsed.ownerPid } : {}),
+                ...(typeof parsed.hostId === 'string' ? { hostId: parsed.hostId } : {}),
                 ...(parsed.truncated ? { truncated: true } : {}),
             };
         }
@@ -104,7 +191,30 @@ class AiHubRawEventLogStore {
         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;
+        if (!comparableResolved.startsWith(comparableRootPrefix))
+            return null;
+        // A symlink inside the archive root must not grant access outside it.
+        try {
+            const real = node_fs_1.default.realpathSync(resolved);
+            const root = node_fs_1.default.realpathSync(this.rootDir) + node_path_1.default.sep;
+            return (process.platform === 'win32' ? real.toLowerCase().startsWith(root.toLowerCase()) : real.startsWith(root)) ? real : null;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                // Missing leaves still inherit the confinement of their nearest real
+                // parent, including Windows junctions inside a hashed bucket directory.
+                let parent = node_path_1.default.dirname(resolved);
+                while (!node_fs_1.default.existsSync(parent) && parent !== node_path_1.default.dirname(parent))
+                    parent = node_path_1.default.dirname(parent);
+                if (!node_fs_1.default.existsSync(this.rootDir))
+                    return resolved;
+                const realParent = node_fs_1.default.realpathSync(parent);
+                const realRoot = node_fs_1.default.realpathSync(this.rootDir);
+                const relative = node_path_1.default.relative(realRoot, realParent);
+                return relative === '' || (!relative.startsWith('..') && !node_path_1.default.isAbsolute(relative)) ? resolved : null;
+            }
+            throw error;
+        }
     }
 }
 exports.AiHubRawEventLogStore = AiHubRawEventLogStore;