@tea-agent/loop-agent 0.44.0-next.5 → 0.44.0-next.6

package/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 ## [Unreleased]
 
+- 修复 main 分支的 next 发布链在类型检查阶段内存溢出失败的问题：完整源码与测试的类型图已超过 Node 默认约 2 GiB 堆上限，类型检查进程因此中止（exit 134），导致 `next` 发布无法完成。此前该上限只在部分验证入口生效，其余入口直接运行类型检查就会因默认堆不足而失败；现把上限固化到类型检查命令本身，各验证入口与本地开发统一生效，不再依赖各入口自行声明。
+
+- 修复 Operator Chat 冷启动卡在检查面板的问题：模型列表和 runtime-snapshot 改为读工作区目录，不再为了展示技能或系统提示去打开 Pi 历史 JSONL；发消息、切换模型、reload 仍会激活会话。会话栏也不再等 Pi 重开，工作区列表未返回前不再把侧栏滤空。
+
+- 修复 Operator Chat 在工作区尚未选中时抢先请求仓库树和能力目录、浏览器 Network 出现 400 的问题；等 `workspaceId` 就绪后再请求，不再把启动竞态显示成功能异常。
+
+- 修复 Console 成功更新后历史接棒记录仍占用操作位、导致工作区初始化持续被拒绝的问题；通用「需要核对」提示现在引导先核实实际执行结果，不再误导为重新更新程序。
+
+- Console 更新前保留当前实例身份，修复重启断线后首次响应已来自新进程时仍等待超时、无法自动刷新的问题；关闭重开设置保留该身份，所有刷新等待分支均反馈超时。
+- 修复观测页「执行历史」把仍在重试的节点误报为「最终失败」的问题：只要节点最后一个已记录的尝试失败，就会显示「N 次 · 最终失败」，即使该节点仍在运行、重试已经排队，会让人误判运行已结束。现在节点处于运行/已启动/暂停状态时改为「N 次 · 最近一次失败，仍在重试」，真正到达终态才显示「最终失败」；修复轮次的多轮标签同样处理。
+
+- 修复 Console「更新程序」被一条卡住的旧操作永久堵死的问题：停在「等待核对」的操作记录已被启动对账跳过、自身无法再推进，却又被当成「仍在运行」，导致之后每次更新都提示「另一个 Console 操作正在进行」。现将其明确归为已结束、不再占用操作位，并在恢复页保留可见；同时补全「已安装成功但接棒失败」记录的自动收敛，不再永久停留。
+
+- Console 操作文案改为面向操作者的说明并给出下一步：等待超时不再伪装成「需要核对」，改为提示操作可能仍在后台运行；「源内容已变更」「前端拆分状态被并发修改」等原本直接展示英文原文的错误，改为说明原因与具体处理步骤；恢复页按钮与提示去掉 reconcile / supersede / orphan / Human Gate 等术语。
+
+- 修复后端测试 DAG 模板遗漏 `upstream-unavailable` 重试类别的问题：内置模板的 Markdown 计划节点缺少该类别，与运行时生成器不一致，导致照模板配置的项目少一类重试；现已补齐，并把模板漂移检查扩展到重试策略字段，避免同类不一致再次漏过。
+
+- Operator Chat 右侧辅助栏改为三个表面：仓库、会话、工作台。点上下文环进入「会话 / 上下文」，文件和终端不再与会话检查挤在同一条标签上；工作台用内侧图标轨切换终端、浏览器和数据库。
+
+- Operator Chat 侧栏折叠后改为 56px 图标轨：可直接点新建会话、搜索、添加工作区和设置，不再留下空槽。
+- Operator Chat 的 `@` 文件面板改为按当前目录一层浏览：空 `@` 不再倒出整库路径，点文件默认隐藏，Tab 进入目录、Enter 选定，插入仍是 `@path` 文本。文件行改为左对齐菜单，不再被全局按钮样式居中成胶囊；目录右侧常驻进入箭头，浮层圆角与投影贴近 DSH 菜单。
+- Pi SDK 运行时依赖升级：`@earendil-works/pi-ai` 与 `@earendil-works/pi-coding-agent` 从精确 pin `0.83.0` 升到 `0.84.4`（顺带修复其携带的 `undici` 高危漏洞与 `brace-expansion` DoS 告警）。适配 0.84 破坏性变更：`getApiKeyAndHeaders` 返回的 headers 现可含 `null` 删除标记、`setRuntimeApiKey` 第三参改为认证取消选项；扩展加载 fixture 改为 ESM（pi-ai 子路径导出不再提供 CJS 条件）。SDK 契约探针文案、发布包契约测试与自举 canary 同步对齐 0.84.4。
+
 - 修复 Windows 上 pi 节点零提交失败的读写守卫误报：libuv 在 win32 的 `fstat` 返回卷序列号而 `lstat` 恒为 0，跨 API 比较必然失败并误报“文件在打开期间被替换”；现新建共享身份比较 helper，win32 跳过跨 API `dev` 比较但保留 `ino` 与其余全部防护，Console 仓库预览同类比较一并修复（用户 0.42.1/0.43.0 两次实测上报）。
 - 修复研发工作流对 Git submodule 的误拦截：父仓库 `git status` 只能看到 submodule 目录级条目，子仓库内合法写入会被误判 `empty-diff`（脏基线）或越界（净基线），导致 verify/review/closeout 全部跳过；现在状态采集会展开到已初始化子仓库的文件级事实（含嵌套 submodule、中文/带引号路径解码、未初始化与采集失败时如实报错不吞证据），合法子仓库写入正常进入验证链，真实越界仍按文件精确拦截，无 submodule 仓库行为字节级不变。
 

package/dist/build-stamp.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "version": "0.44.0-next.5",
-  "gitSha": "da4e19a774406e1fe79611807fd241e56e6e4c17",
-  "builtAt": "2026-09-16T02:11:12.294Z"
+  "version": "0.44.0-next.6",
+  "gitSha": "11c9ac87f792e61b1bc31b1ef2aeacb48a6334d4",
+  "builtAt": "2026-09-16T11:49:07.558Z"
 }

package/dist/executors/pi-sdk-executor.js

@@ -40,21 +40,21 @@ export async function installPiProviderRequestBudget(session, reserve, onFailure
     const agent = session.agent;
     const original = agent?.streamFunction;
     if (!agent || typeof original !== "function")
-        throw Error("FRONTEND_PROVIDER_BUDGET_UNSUPPORTED: SDK actual request stream unavailable");
+        throw new Error("FRONTEND_PROVIDER_BUDGET_UNSUPPORTED: SDK actual request stream unavailable");
     const { createAssistantMessageEventStream } = await import("@earendil-works/pi-ai");
     agent.streamFunction = async (...args) => {
         try {
             if (args[2]?.signal?.aborted)
-                throw Error("FRONTEND_PROVIDER_REQUEST_ABORTED");
+                throw new Error("FRONTEND_PROVIDER_REQUEST_ABORTED");
             if (capacity) {
                 const measurement = measureFrontendRequestEnvelope(args[1], args[0], capacity.policy);
                 capacity.observe(measurement);
                 if (measurement.exceedsEstimate)
-                    throw Error(`FRONTEND_CONTEXT_ESTIMATE_EXCEEDED: estimated=${measurement.estimatedTokens} available=${measurement.availableInputTokens}; estimator=${measurement.estimatorVersion}; registry capability is not a measured gateway limit`);
+                    throw new Error(`FRONTEND_CONTEXT_ESTIMATE_EXCEEDED: estimated=${measurement.estimatedTokens} available=${measurement.availableInputTokens}; estimator=${measurement.estimatorVersion}; registry capability is not a measured gateway limit`);
             }
             await reserve();
             if (args[2]?.signal?.aborted)
-                throw Error("FRONTEND_PROVIDER_REQUEST_ABORTED");
+                throw new Error("FRONTEND_PROVIDER_REQUEST_ABORTED");
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
@@ -124,7 +124,7 @@ export function setPiSdkImportOverrideForTests(fn) {
 export function setPiSdkModuleOverrideForTests(fn) {
     sdkModuleOverrideForTests = fn;
 }
-/** Check whether the Pi SDK runtime dependency satisfies the 0.83.0 runtime contract. */
+/** Check whether the Pi SDK runtime dependency satisfies the 0.84.4 runtime contract. */
 export async function checkPiSdkAvailability(_repoRoot) {
     if (sdkSessionFactoryOverride) {
         return { ok: true, detail: "pi SDK session factory override active" };
@@ -140,10 +140,10 @@ export async function checkPiSdkAvailability(_repoRoot) {
             typeof ModelRuntime?.create !== "function") {
             return {
                 ok: false,
-                detail: "pi SDK incompatible: requires createAgentSession, getAgentDir, and ModelRuntime.create (0.83.0 contract)",
+                detail: "pi SDK incompatible: requires createAgentSession, getAgentDir, and ModelRuntime.create (0.84.4 contract)",
             };
         }
-        return { ok: true, detail: "pi SDK 0.83.0 contract available" };
+        return { ok: true, detail: "pi SDK 0.84.4 contract available" };
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);

package/dist/infrastructure/console/operation-store.js

@@ -6,6 +6,24 @@ import { buildFrontendSplitAggregateCloseout, computeFrontendSplitDigest, finali
 import { frontendCloseoutFactsSchema, frontendTestHandoffSchema, } from "../../workflows/dag/frontend-closeout.js";
 import { listJsonFiles, readJsonIfExists, sha256Json, writeSecureJson, } from "./app-data.js";
 export const TERMINAL_OPERATION_STATES = new Set(["succeeded", "failed", "timed-out", "restarting"]);
+/**
+ * Operation states that hold an admission slot. needs-reconcile requires
+ * inspection but does not itself prove a live operation; callers still check
+ * DAG/Worker/chat activity separately. restarting is the terminal receipt of
+ * a successful Console handoff, retained across boots, not a live slot.
+ */
+export const OCCUPIED_OPERATION_STATES = new Set(["queued", "starting", "running"]);
+/** True when the state can still make progress and therefore holds the slot. */
+export function isOperationOccupied(state) {
+    return OCCUPIED_OPERATION_STATES.has(state);
+}
+/**
+ * True when no further state transition will ever occur: a business terminal
+ * (succeeded/failed/timed-out/restarting) or a stranded needs-reconcile.
+ */
+export function isOperationSettled(state) {
+    return TERMINAL_OPERATION_STATES.has(state) || state === "needs-reconcile";
+}
 function operationFile(appData, operationId) {
     return path.join(appData.operations, `${operationId}.json`);
 }
@@ -359,14 +377,11 @@ export class OperationStore {
         for (const op of await this.list()) {
             if (TERMINAL_OPERATION_STATES.has(op.state))
                 continue;
-            // A consoleUpdateAndInit whose record already proves a requested
-            // handoff died before writing its terminal state: the update and
-            // restart themselves succeeded — the booting process IS the
-            // handoff target. Mark it succeeded instead of surfacing the
-            // generic needs-reconcile failure copy to the operator.
+            // A consoleUpdateAndInit that proved its handoff before the process
+            // died must not be reported as a stranded failure: the booting
+            // process IS the handoff target, so the update actually succeeded.
             if (op.action === "consoleUpdateAndInit" &&
-                op.state === "needs-reconcile" &&
-                isProvenConsoleUpdateHandoff(op.result)) {
+                isProvenConsoleUpdateHandoff(op)) {
                 changed.push(await this.update(op.operationId, {
                     state: "succeeded",
                     errorCode: undefined,
@@ -398,17 +413,34 @@ export function isTerminalOperationState(state) {
     return TERMINAL_OPERATION_STATES.has(state);
 }
 /**
- * True when a consoleUpdateAndInit result proves the handoff was requested
- * (install verified + init clean + new Console spawned). Used by boot
- * reconcile to close the record as succeeded even though the old process
- * died before writing its terminal state.
+ * True when a consoleUpdateAndInit record proves the handoff actually
+ * succeeded (install verified + new Console spawned), so boot reconcile can
+ * close it as succeeded even though the dying process never wrote its
+ * terminal state.
+ *
+ * The proof reads the maintenance projection rather than only `result.state`.
+ * The old check required `result.state === "restarting"`, but the executor
+ * writes `state` and `maintenance` together (`console-update-and-init.ts`),
+ * so any path that recorded the handoff proof together with a non-restarting
+ * `state` — most importantly the `needs-reconcile` record that
+ * `acceptConsoleUpdateAndInit` writes when the executor throws *after* a
+ * successful handoff — could never satisfy it. Such records were stranded
+ * forever: boot reconcile skipped them and they blocked later updates.
+ *
+ * `handoff.status === "requested"` is only ever set on the success path, and
+ * `package.status === "failed"` explicitly disqualifies a record, so this
+ * stays fail-closed for genuine failures.
  */
-function isProvenConsoleUpdateHandoff(result) {
+export function isProvenConsoleUpdateHandoff(operation) {
+    if (!operation || operation.action !== "consoleUpdateAndInit")
+        return false;
+    const result = operation.result;
     if (!result || typeof result !== "object")
         return false;
     const shape = result;
-    return (shape.state === "restarting" &&
-        shape.maintenance?.handoff?.status === "requested");
+    if (shape.maintenance?.handoff?.status !== "requested")
+        return false;
+    return shape.maintenance?.package?.status !== "failed";
 }
 export function clipPreview(text, max = 4096) {
     if (text.length <= max)

package/dist/shared/wizard-local-telemetry.js

@@ -12,7 +12,8 @@ function deleteHeaderCaseInsensitive(headers, name) {
 }
 function configuredHeader(headers, name) {
     const key = Object.keys(headers ?? {}).find((entry) => entry.toLowerCase() === name.toLowerCase());
-    return key ? headers?.[key] : undefined;
+    const value = key ? headers?.[key] : undefined;
+    return typeof value === "string" ? value : undefined;
 }
 function setStaticHeader(headers, configured, name, defaultValue) {
     deleteHeaderCaseInsensitive(headers, name);

package/dist/worker/console/chat/pi-runtime.js

@@ -296,6 +296,14 @@ export function createWizardLocalHeadersExtension(options) {
 }
 export { THINKING_LEVELS, RuntimeSnapshotUnavailableError, projectRuntimeSnapshot, };
 export { createDefaultPiSdkBindings } from "./pi-runtime/sdk-bindings.js";
+/** Catalog listing must not load skills/extensions/context — those belong to reopen. */
+const CATALOG_RESOURCE_LOADER_OPTIONS = Object.freeze({
+    noContextFiles: true,
+    noSkills: true,
+    noExtensions: true,
+    noPromptTemplates: true,
+    noThemes: true,
+});
 export { extractAssistantContentBlocks, extractAssistantText, isAssistantSdkMessage };
 export function buildRequestContextEvent(input) {
     const systemPrompt = input.session.state?.systemPrompt ?? input.session.systemPrompt ?? "";
@@ -440,6 +448,8 @@ export class ConsolePiRuntime {
     mainlineLeaves = new Map();
     /** Per-sessionId single-flight materialization (create fast-path / readiness fence). */
     sessionInit = new Map();
+    /** Concurrent reopen of the same historical JSONL shares one in-flight promise. */
+    reopenInFlight = new Map();
     /** Resolved model binding after materialization (create may return before this is known). */
     sessionModels = new Map();
     /** Durable session mode; record is the source of truth, this is the live handle cache. */
@@ -1251,11 +1261,68 @@ export class ConsolePiRuntime {
             entries: manager.getBranch?.() ?? [],
         };
     }
+    /**
+     * Workspace-scoped model catalog. A live session's ModelRuntime is reused
+     * when present; otherwise services are created without opening the Pi
+     * conversation JSONL so the picker is not blocked on cold reopen.
+     */
+    workspaceModelRuntime;
+    workspaceInspection;
+    async getWorkspaceModelRuntime() {
+        if (!this.workspaceModelRuntime) {
+            this.workspaceModelRuntime = (async () => {
+                const agentDir = await safeGetAgentDir(this.bindings);
+                const { services } = await this.bindings.createServices({
+                    cwd: this.options.cwd,
+                    agentDir,
+                    resourceLoaderOptions: { ...CATALOG_RESOURCE_LOADER_OPTIONS },
+                });
+                return services.modelRuntime;
+            })().catch((error) => {
+                this.workspaceModelRuntime = undefined;
+                throw error;
+            });
+        }
+        return this.workspaceModelRuntime;
+    }
+    /**
+     * Full OPEN-surface services for inspect UIs. No SessionManager / JSONL.
+     * Cached without sessionId so todo/goal extensions stay off the shared scope.
+     */
+    async getWorkspaceInspectionServices() {
+        if (!this.workspaceInspection) {
+            this.workspaceInspection = (async () => {
+                const agentDir = await safeGetAgentDir(this.bindings);
+                const appendSystemPrompt = composeChatSystemPromptParts({
+                    sessionMode: DEFAULT_CONSOLE_CHAT_SESSION_MODE,
+                    workflowPrompt: OPERATOR_CHAT_SYSTEM_PROMPT_BASE,
+                });
+                const { services } = await this.bindings.createServices({
+                    cwd: this.options.cwd,
+                    agentDir,
+                    resourceLoaderOptions: await this.buildResourceLoaderOptions({
+                        appendSystemPrompt,
+                    }),
+                });
+                return {
+                    modelRuntime: services.modelRuntime,
+                    resourceLoader: services
+                        .resourceLoader,
+                    settingsManager: services.settingsManager,
+                };
+            })().catch((error) => {
+                this.workspaceInspection = undefined;
+                throw error;
+            });
+        }
+        return this.workspaceInspection;
+    }
     async listModels(sessionId) {
-        await this.ensureSessionReady(sessionId);
-        const modelRuntime = this.modelRuntimes.get(sessionId);
-        if (!this.sessions.has(sessionId) || !modelRuntime)
-            throw new Error(`chat session not active: ${sessionId}`);
+        const live = this.modelRuntimes.get(sessionId);
+        if (live && this.sessions.has(sessionId)) {
+            return this.bindings.listAvailableModels({ modelRuntime: live });
+        }
+        const modelRuntime = await this.getWorkspaceModelRuntime();
         return this.bindings.listAvailableModels({ modelRuntime });
     }
     async applyModel(sessionId, model) {
@@ -1518,11 +1585,11 @@ export class ConsolePiRuntime {
         return { ok: true, revision: this.revisions.get(sessionId) ?? 0 };
     }
     /**
-     * Project the unified live runtime snapshot (design §2.2). The current Pi
-     * session is the single source of truth: real system prompt, real model /
-     * thinking selection (auto + effective), the session modelRuntime model
-     * list, and the session ResourceLoader inventories. Undefined when the
-     * session is not active — callers fail closed instead of fabricating data.
+     * Project the unified runtime snapshot (design §2.2). A live Pi session is
+     * the source of truth when present. Inspect GETs may pass
+     * `workspaceProjection` to render ResourceLoader inventories without
+     * opening the conversation JSONL. Unknown ids without that hint stay
+     * undefined so callers fail closed.
      */
     /**
      * ConsolePiRuntime.listSlashCommands
@@ -1541,18 +1608,27 @@ export class ConsolePiRuntime {
         return collectSlashCommands({ session, resourceLoader });
     }
     async getRuntimeSnapshot(sessionId, options) {
-        try {
-            await this.ensureSessionReady(sessionId);
-        }
-        catch (error) {
-            if (error instanceof PiSessionInitFailedError)
-                throw error;
-            // Inactive / unknown session: fail closed with undefined (no fabricated snapshot).
-            return undefined;
+        const initializing = this.sessionInit.get(sessionId)?.status === "initializing";
+        if (this.sessions.has(sessionId) || initializing) {
+            try {
+                await this.ensureSessionReady(sessionId);
+            }
+            catch (error) {
+                if (error instanceof PiSessionInitFailedError)
+                    throw error;
+                if (options?.workspaceProjection) {
+                    return this.projectWorkspaceRuntimeSnapshot(sessionId, options);
+                }
+                return undefined;
+            }
         }
         const session = this.sessions.get(sessionId);
-        if (!session)
+        if (!session) {
+            if (options?.workspaceProjection) {
+                return this.projectWorkspaceRuntimeSnapshot(sessionId, options);
+            }
             return undefined;
+        }
         const services = this.serviceScopes.get(sessionId);
         const modelRuntime = this.modelRuntimes.get(sessionId);
         const resourceLoader = services?.resourceLoader;
@@ -1653,6 +1729,116 @@ export class ConsolePiRuntime {
             hasBash: true,
         });
     }
+    resolveWorkspaceThinkingSelection(sessionId, stored) {
+        const live = this.thinkingSelections.get(sessionId);
+        if (live)
+            return live;
+        if (!stored || stored === "auto")
+            return "auto";
+        if (THINKING_LEVELS.includes(stored)) {
+            return stored;
+        }
+        return "auto";
+    }
+    /**
+     * Inspect projection without SessionManager.open. Used only when the Agent
+     * is not live and the caller confirmed a durable session record.
+     */
+    async projectWorkspaceRuntimeSnapshot(sessionId, options) {
+        const hint = options.workspaceProjection ?? {};
+        const sessionMode = hint.sessionMode ?? this.sessionModeOf(sessionId);
+        let inspection;
+        try {
+            inspection = await this.getWorkspaceInspectionServices();
+        }
+        catch (error) {
+            throw new RuntimeSnapshotUnavailableError(`workspace runtime projection failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const resourceLoader = inspection.resourceLoader;
+        const settingsManager = inspection.settingsManager;
+        const thinkingSelection = this.resolveWorkspaceThinkingSelection(sessionId, hint.thinkingLevel);
+        const effectiveThinkingLevel = settingsManager?.getDefaultThinkingLevel?.() ??
+            (thinkingSelection === "auto" ? undefined : thinkingSelection);
+        const rawSystemPrompt = resourceLoader?.getSystemPrompt?.() ||
+            composeChatSystemPrompt({
+                sessionMode,
+                workflowPrompt: OPERATOR_CHAT_SYSTEM_PROMPT_BASE,
+            });
+        if (!rawSystemPrompt) {
+            throw new RuntimeSnapshotUnavailableError("system prompt projection failed: workspace prompt was empty");
+        }
+        let models = [];
+        try {
+            models = this.bindings
+                .listAvailableModels({ modelRuntime: inspection.modelRuntime })
+                .map((entry) => ({
+                provider: entry.provider,
+                id: entry.id,
+                ...(entry.name ? { name: entry.name } : {}),
+                hasCredentials: entry.hasCredentials,
+            }));
+        }
+        catch (error) {
+            throw new RuntimeSnapshotUnavailableError(`model enumeration failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const thinkingLevels = [
+            { value: "auto" },
+            ...THINKING_LEVELS.map((value) => ({ value })),
+        ];
+        let skillPrefs = { schemaVersion: 1, skills: {} };
+        let skillPrefsError;
+        if (resourceLoader) {
+            try {
+                skillPrefs = await this.loadSkillAutoInvocationPreferences();
+            }
+            catch (error) {
+                skillPrefsError = error;
+            }
+        }
+        const activeTools = chatActiveToolBaseline(sessionMode);
+        const inventories = await collectRuntimeInventories({
+            resourceLoader,
+            skillPrefs,
+            skillPrefsError,
+            agentDir: await safeGetAgentDir(this.bindings),
+            cwd: this.options.cwd,
+            tools: [],
+            activeToolNames: activeTools,
+        });
+        const storedModel = this.sessionModels.get(sessionId);
+        const provider = storedModel?.provider ?? hint.modelProvider;
+        const modelId = storedModel?.modelId ?? hint.modelId;
+        return projectRuntimeSnapshot({
+            sessionId,
+            revision: this.revisions.get(sessionId) ?? 0,
+            loadedAt: new Date().toISOString(),
+            selection: {
+                ...(provider && modelId
+                    ? { model: { provider, id: modelId } }
+                    : {}),
+                thinkingSelection,
+                ...(effectiveThinkingLevel
+                    ? { effectiveThinkingLevel: effectiveThinkingLevel }
+                    : {}),
+            },
+            models,
+            thinkingLevels,
+            systemPrompt: {
+                ...(options.includeRaw ? { raw: rawSystemPrompt } : {}),
+                text: rawSystemPrompt,
+                sha256: createHash("sha256").update(rawSystemPrompt).digest("hex"),
+                characters: rawSystemPrompt.length,
+            },
+            activeTools,
+            contextFiles: inventories.contextFiles,
+            skills: inventories.skills,
+            extensions: inventories.extensions,
+            packages: inventories.packages,
+            mcp: inventories.mcp,
+            diagnostics: inventories.diagnostics,
+            hasBash: true,
+        });
+    }
     /**
      * Re-open a previously persisted Chat session after Console restart or
      * browser refresh (roadmap M1-S04 / S05).
@@ -1667,6 +1853,19 @@ export class ConsolePiRuntime {
      * than silently creating a fresh empty session and losing prior context.
      */
     async reopenSession(init) {
+        const sessionId = init.sessionId;
+        const existing = this.reopenInFlight.get(sessionId);
+        if (existing)
+            return existing;
+        const pending = this.reopenSessionExclusive(init).finally(() => {
+            if (this.reopenInFlight.get(sessionId) === pending) {
+                this.reopenInFlight.delete(sessionId);
+            }
+        });
+        this.reopenInFlight.set(sessionId, pending);
+        return pending;
+    }
+    async reopenSessionExclusive(init) {
         await this.syncAimaxAuthToken();
         const sessionId = init.sessionId;
         const sessionMode = this.rememberSessionMode(sessionId, init.sessionMode ?? this.sessionModeOf(sessionId));

package/dist/worker/console/chat/repo-browser.js

@@ -127,6 +127,55 @@ export async function listRepoDirectory(repoRoot, rawPath) {
         throw error;
     }
 }
+/** Composer `@` palette keeps the first page of a directory listing scannable. */
+export const FILE_PALETTE_LIMIT = 50;
+/**
+ * Split an `@` token query into a directory listing target and basename filter.
+ * Empty or slash-free queries stay on the workspace root (M3 fuzzy is out of
+ * scope). A trailing slash lists that directory with an empty fragment.
+ */
+export function parseFilePaletteQuery(rawQuery) {
+    const query = rawQuery.replaceAll("\\", "/").replace(/^\/+/u, "");
+    const slash = query.lastIndexOf("/");
+    if (slash < 0)
+        return { directory: "", fragment: query };
+    return {
+        directory: query.slice(0, slash),
+        fragment: query.slice(slash + 1),
+    };
+}
+export function projectFilePaletteEntries(entries, fragment) {
+    const showDots = fragment.startsWith(".");
+    const needle = fragment.toLowerCase();
+    const projected = [];
+    for (const entry of entries) {
+        if (!showDots && entry.name.startsWith("."))
+            continue;
+        if (needle !== "" && !entry.name.toLowerCase().includes(needle))
+            continue;
+        const isDir = entry.kind === "directory";
+        projected.push({
+            path: isDir ? `${entry.path}/` : entry.path,
+            isDir,
+        });
+        if (projected.length >= FILE_PALETTE_LIMIT)
+            break;
+    }
+    return projected;
+}
+/** One-level `@` file palette listing. Unreadable or out-of-repo queries are empty. */
+export async function listChatFilePalette(repoRoot, rawQuery) {
+    const { directory, fragment } = parseFilePaletteQuery(rawQuery);
+    try {
+        const listed = await listRepoDirectory(repoRoot, directory);
+        return projectFilePaletteEntries(listed.entries, fragment);
+    }
+    catch (error) {
+        if (error instanceof RepoBrowserError)
+            return [];
+        throw error;
+    }
+}
 export async function readRepoPreview(repoRoot, rawPath) {
     const guard = await guardReadPath(repoRoot, rawPath);
     if (!guard.ok)