@tea-agent/loop-agent 0.32.1 → 0.33.1

package/CHANGELOG.md

@@ -2,11 +2,89 @@
 
 ## [Unreleased]
 
+## [0.33.1] - 2026-08-10
+
+### 重点更新
+
+- Operate 与 Inspect 合并为统一的双层导航壳，取代旧的三层堆叠栏
+- 在「操作」与「观测」模式间切换时保持对象上下文，支持一键带参数返回恢复现场
+- 夜间信息架构收敛，总览新增「昨夜班次」条带，移除冗余的并列 tab
+- 全面加固窄屏适配与可访问性，优化共享资产加载失败时的降级体验
+
+### 新增
+
+- 新增共享壳唯一实现 operator-chrome.css/js，包含全局品牌带与工作区下划线 tab
+- Inspect 总览新增「昨夜班次」条带，支持通过/失败/需人工/待 harvest 状态一眼可见
+- OperatorSurfaceHealthV1 新增 repoName 字段，统一上移仓库身份展示
+- 新增 operator-chrome 契约测试，覆盖 tab 映射、模型、对象连续与返回路径
+
+### 改进
+
+- 模式切换不丢对象：恢复页持有 DAG 时切「观测」直达同一 DAG 画布，并提供来源 chip 支持一键返回
+- 夜间信息架构收敛：Inspect 顶栏移除「夜间任务」并列 tab，#/night 深链详情保留并提供「在操作台管理 →」入口
+- 仓库身份上移：Inspect 总览移除重复的内联仓库横幅，面包屑从 site-header 移入内容区页头
+- Console 改用 CSP 友好的原生动态导入，共享资产加载失败时保留最小可用导航与错误状态
+- 窄屏（1100px/760px）下新鲜度与 Pi 状态收敛为紧凑图标语法，避免整页横向溢出
+
+### 修复
+
+- 修复 Inspect 壳重渲染时 #header-refresh 新鲜度文案被 health 回填或 hash 切换清空的问题
+- 补齐仓库身份浮层的 aria-controls/aria-expanded/dialog 名称，支持外部点击与 Esc 关闭并恢复按钮焦点
+- 修复关闭来源 chip 时误删 node/page 等对象页查询参数的问题，现仅移除 from 参数
+- 移除 Console 中 new Function 的间接导入与 SVG 图标的 innerHTML 注入面，提升安全性
+- 修复 hash 导航与 destroy 时监听与宿主 class 未完整清理的问题
+
+## [0.33.0] - 2026-08-09
+
+### 重点更新
+
+- Operator Console 工作区导航升级为 hash 路由，支持页面刷新保留状态及浏览器前进后退，并新增模型与设置页面入口
+- 夜间辅助调度器（NightAuxTicker）改为自动启动，移除手动开关，简化操作流程
+- Observe DAG 运行历史页交互全面优化，改进分页器布局、自定义选择器与复制反馈体验
+- 执行器支持 provider/model 显式引用格式，消除运行时模型路由的歧义
+
+### 新增
+
+- Operator Console 工作区导航新增 hash 虚拟路径（#/tasks、#/night、#/models、#/settings），支持刷新恢复与浏览器历史导航
+- 新增模型（Models）与设置（Settings）页面入口
+- 夜间辅助调度器（NightAuxTicker）现默认自动启动，无需手动开启即可维持夜间调度活跃度
+- Observe 新增统一的自定义选择器菜单，支持键盘导航与自适应定位
+- Observe 新增 DAG 运行历史分页功能
+
+### 改进
+
+- Operator Console 工作区导航顺序调整，将对话（Tasks）置于首位
+- 夜间任务面板的健康状态栏简化为纯文本状态展示，移除旧的手动开关
+- Observe 夜页头部操作按钮样式统一
+- Observe DAG 历史分页器视觉布局升级为精致的分段设计，并优化窄屏下的显示
+- 执行器 Pi 层级支持 provider/model 引用格式，规范化解析字符串与对象两种配置写法，提升模型路由准确性
+
+### 修复
+
+- 修复 Observe 自定义选择器键盘焦点异常的问题
+- 修复 Observe DAG 历史分页器在窄视口下布局溢出的问题
+- 修复 Observe 复制反馈按钮的边框样式显示异常，恢复无边框设计
+- 优化 Observe DAG 节点错误摘要展示，将失败行备注压缩为紧凑的两行摘要，避免撑高表格
+
 ## [0.32.1] - 2026-08-09
 
+### 新增
+
+- Observe：新增 DAG 运行历史页 `#/dags`：分页表格、hash 恢复 page/pageSize、手动刷新；只读 `GET /api/dag-runs?page=&pageSize=` 返回轻量列表，排除 dry-run/init-only，省略 nodes/edges 等重字段
+- Dashboard「最近 DAG 运行」卡片右上增加「查看全部」入口，进入完整历史页；卡片仍保留最近 10 条
+
+### 修复
+
+- Observe DAG 历史页：分页摘要与失败态使用本地固定可信文案；首次 Loading 与后续动态分页/刷新控件分离；双路径失败共用 aria-live；分页失败不污染列表；默认直连真实 `/api/dag-runs`
+- Observe DAG 历史页 review 收口：取消在途 abort 中途仍式 GET 推进 requestSeq，防止旧响应覆盖缓存页；run-id 复制按钮独立 1.5s 成功计时；图标恢复；手动刷新替换当前页缓存；失效页码 bump prefetch generation 并拒绝陈旧预取写回；`totalPages>7` 页码窗口收紧为首页/末页/当前±1（无紧邻填补）；`.dags-pagination.is-busy` 降级为上方 `opacity`
+- Observe DAG 节点表格：失败行备注改为两行错误摘要，避免完整 errorPreview 撑高表格；完整错误仍在节点检查器输出中查看
+
 ### 改进
 
 - Operator Console 前端重构视觉层级与代码结构：`OperatorChat.tsx`（3656→407 行）、`App.tsx`（3044→182 行）、`NightJobsWorkbench.tsx`（852→90 行）按职责拆为 `operator-chat/`、`app/`、`pages/`、`shell/`、`night/` 模块，消息流 / 工具卡 / gate 卡 / composer / 侧栏各自独立；样式统一为单一语义 token 层，人工决策 gate 卡以决策卡规格（橙色左边条 + 浮起阴影 + 状态徽标 + 未决时吸附 composer 上方）突出，工具过程卡默认退后
+- Observe：DAG 历史 pageSize 与节点检查器「执行分次」改为统一自定义选择器（触发器 + listbox；键盘/ARIA/焦点/自适应定位）；不改动 hash-only 分页、attempt raw key / 默认最新 / 节点切换重置语义
+- Observe DAG 历史页：复制改为图标反馈（成功勾号 + 页面 aria-live；失败右下角短暂 Toast）；数字分页器改为精致分段布局；hash 单一事实源；缓存 + AbortController + 相邻页低优先级预取，减少翻页双重加载与长时间等待
+
 - Agent Worker Production Readiness v1 Phase 8：在已发布 `@0.32.0` 上完成 published-tarball deterministic campaign 与 burn-in day 0 开窗；scorecard 仍为 **`NOT_READY`**（待 burn-in 累计、live Pi canary、live Closeout、C4/C7 进程 crash）
 
 ### 修复

package/dist/executors/model-routing.js

@@ -9,14 +9,24 @@ export const DEFAULT_DAG_MODELS = {
  * DAG executor model tier keys that may carry a per-complexity override.
  */
 const EXECUTOR_MODEL_TIERS = ["LOW", "MED", "HIGH"];
+/** Format harness tier selection for DAG Pi model routing (provider/model when set). */
+export function formatExecutorTierModelRef(selection) {
+    return selection.provider
+        ? `${selection.provider}/${selection.model}`
+        : selection.model;
+}
 /** Resolve one tier to a model and optional explicit thinking override. */
 export function resolveExecutorTierSelection(execConfig, tier) {
     const tierSelection = normalizeExecutorTierValue(execConfig?.[tier]);
     if (tierSelection)
         return tierSelection;
     const defaultModel = execConfig?.defaultModel;
-    if (defaultModel && defaultModel !== "default")
+    if (defaultModel && defaultModel !== "default") {
+        const parsedDefault = normalizeExecutorTierValue(defaultModel);
+        if (parsedDefault)
+            return parsedDefault;
         return { model: defaultModel };
+    }
     return { model: DEFAULT_DAG_EXECUTOR_MODELS.pi[tier] };
 }
 /**
@@ -32,9 +42,9 @@ export function resolveExecutorTierSelection(execConfig, tier) {
  */
 export function resolveExecutorModelMatrix(_executor, execConfig) {
     return {
-        LOW: resolveExecutorTierSelection(execConfig, "LOW").model,
-        MED: resolveExecutorTierSelection(execConfig, "MED").model,
-        HIGH: resolveExecutorTierSelection(execConfig, "HIGH").model,
+        LOW: formatExecutorTierModelRef(resolveExecutorTierSelection(execConfig, "LOW")),
+        MED: formatExecutorTierModelRef(resolveExecutorTierSelection(execConfig, "MED")),
+        HIGH: formatExecutorTierModelRef(resolveExecutorTierSelection(execConfig, "HIGH")),
     };
 }
 /** Resolve only explicitly configured per-tier thinking values. */

package/dist/governance/manifest-types.js

@@ -11,16 +11,27 @@ export const worktreeManifestConfigSchema = z.object({
 });
 export const taskExecutorSchema = z.enum(["pi"]);
 export const CURSOR_TASK_EXECUTOR_REMOVED_ERROR = 'task executor "cursor" is no longer supported; governed runtime is Pi-only';
-/** Per-tier model override: bare model id string, or `{ model, thinking? }`. */
+/** Per-tier model override: bare model id string, or `{ provider?, model, thinking? }`. */
 export const executorTierModelSchema = z.union([
     z.string(),
     z
         .object({
+        provider: z.string().min(1).optional(),
         model: z.string().min(1),
         thinking: z.string().optional(),
     })
         .strict(),
 ]);
+function parseProviderModelReference(value) {
+    const slash = value.indexOf("/");
+    if (slash < 0)
+        return { model: value };
+    const provider = value.slice(0, slash);
+    const model = value.slice(slash + 1);
+    if (!provider || !model)
+        return { model: value };
+    return { provider, model };
+}
 /** Normalize an executors.pi LOW|MED|HIGH value. */
 export function normalizeExecutorTierValue(value) {
     if (value === null || value === undefined)
@@ -28,18 +39,34 @@ export function normalizeExecutorTierValue(value) {
     if (typeof value === "string") {
         if (value === "default" || value.length === 0)
             return undefined;
-        return { model: value };
+        const parsed = parseProviderModelReference(value);
+        return parsed.provider
+            ? { model: parsed.model, provider: parsed.provider }
+            : { model: parsed.model };
     }
     if (typeof value !== "object" || Array.isArray(value))
         return undefined;
-    const model = value.model;
-    if (typeof model !== "string" || model.length === 0 || model === "default") {
+    const record = value;
+    const modelRaw = record.model;
+    if (typeof modelRaw !== "string" ||
+        modelRaw.length === 0 ||
+        modelRaw === "default") {
         return undefined;
     }
-    const thinking = value.thinking;
+    const explicitProvider = typeof record.provider === "string" && record.provider.length > 0
+        ? record.provider
+        : undefined;
+    const parsed = parseProviderModelReference(modelRaw);
+    const provider = explicitProvider ?? parsed.provider;
+    const model = explicitProvider
+        ? parsed.provider && parsed.provider === explicitProvider
+            ? parsed.model
+            : modelRaw
+        : parsed.model;
+    const thinking = record.thinking;
     return typeof thinking === "string" && thinking.length > 0
-        ? { model, thinking }
-        : { model };
+        ? { model, ...(provider ? { provider } : {}), thinking }
+        : { model, ...(provider ? { provider } : {}) };
 }
 export const executorManifestSchema = z
     .object({

package/dist/worker/console/chat/model-resolver.js

@@ -6,11 +6,8 @@
  * `snapshot.available` model list (preferring providers whose model entry is
  * backed by credentials).
  *
- * Rationale: harness.json only stores a modelId per tier (e.g. "gpt-5.5"), not
- * a provider. The Pi SDK `getModel(provider, modelId)` requires a provider, so
- * we search `available` for entries whose `id` matches the modelId and pick the
- * first whose provider resolves to a configured/credentialled source. This
- * mirrors how the user's wizard-local / configured providers surface models.
+ * harness.json tiers may be bare model ids, `provider/model` strings, or
+ * `{ provider?, model, thinking? }` objects — see normalizeExecutorTierValue.
  *
  * This module is deliberately framework-light: it takes a repoRoot + an
  * optional model-list snapshot and returns a `{provider, modelId}` descriptor.
@@ -18,44 +15,61 @@
  */
 import { readFile } from "node:fs/promises";
 import path from "node:path";
+import { normalizeExecutorTierValue } from "../../../governance/manifest-types.js";
 /** Tier keys in harness executors.pi that may override the default. */
 const EXECUTOR_TIERS = ["LOW", "MED", "HIGH"];
-function modelIdFromTierValue(value) {
-    if (typeof value === "string") {
-        return value && value !== "default" ? value : undefined;
+async function readHarnessExecutorsPi(repoRoot) {
+    try {
+        const raw = await readFile(path.join(repoRoot, "harness.json"), "utf-8");
+        const manifest = JSON.parse(raw);
+        return manifest.executors?.pi;
     }
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
+    catch {
         return undefined;
     }
-    const model = value.model;
-    return typeof model === "string" && model && model !== "default"
-        ? model
-        : undefined;
+}
+/**
+ * Read one executors.pi tier as normalized provider + modelId.
+ */
+export async function readHarnessPiTierSelection(repoRoot, tier = "MED") {
+    const pi = await readHarnessExecutorsPi(repoRoot);
+    if (!pi)
+        return undefined;
+    const tierSelection = normalizeExecutorTierValue(pi[tier]);
+    if (tierSelection) {
+        return {
+            modelId: tierSelection.model,
+            ...(tierSelection.provider ? { provider: tierSelection.provider } : {}),
+            ...(tierSelection.thinking ? { thinking: tierSelection.thinking } : {}),
+        };
+    }
+    const defaultSelection = normalizeExecutorTierValue(pi.defaultModel);
+    if (!defaultSelection)
+        return undefined;
+    return {
+        modelId: defaultSelection.model,
+        ...(defaultSelection.provider
+            ? { provider: defaultSelection.provider }
+            : {}),
+        ...(defaultSelection.thinking
+            ? { thinking: defaultSelection.thinking }
+            : {}),
+    };
 }
 /**
  * Read executors.pi.<tier> from the repo harness.json. Returns undefined when
  * harness.json is absent or the tier is unset / "default" sentinel.
  *
  * Default tier = MED (matches DAG executor model matrix convention).
+ * When provider is explicit, returns `provider/model` for DAG-compat callers.
  */
 export async function readHarnessPiModelTier(repoRoot, tier = "MED") {
-    try {
-        const raw = await readFile(path.join(repoRoot, "harness.json"), "utf-8");
-        const manifest = JSON.parse(raw);
-        const pi = manifest.executors?.pi;
-        if (!pi)
-            return undefined;
-        const tierModel = modelIdFromTierValue(pi[tier]);
-        if (tierModel)
-            return tierModel;
-        const defaultModel = pi.defaultModel;
-        if (defaultModel && defaultModel !== "default")
-            return defaultModel;
-        return undefined;
-    }
-    catch {
+    const selection = await readHarnessPiTierSelection(repoRoot, tier);
+    if (!selection)
         return undefined;
-    }
+    return selection.provider
+        ? `${selection.provider}/${selection.modelId}`
+        : selection.modelId;
 }
 /**
  * Search the SDK's available-model list for entries matching a modelId.
@@ -71,7 +85,16 @@ export async function readHarnessPiModelTier(repoRoot, tier = "MED") {
  *      in the SDK's configuredProviders set).
  *   3. Stable list order otherwise.
  */
-export function findProviderForModelId(modelId, available) {
+export function findProviderForModelId(modelId, available, options) {
+    const preferred = options?.preferredProvider?.trim();
+    if (preferred) {
+        const exact = available.find((m) => m.provider === preferred &&
+            (m.id === modelId ||
+                m.id === `${preferred}/${modelId}` ||
+                m.id.endsWith(`/${modelId}`)));
+        if (exact)
+            return exact;
+    }
     const matches = available.filter((m) => {
         if (m.id === modelId)
             return true;
@@ -95,6 +118,51 @@ export function findProviderForModelId(modelId, available) {
     };
     return [...matches].sort((a, b) => score(a) - score(b))[0];
 }
+function resolveTierDescriptor(selection, available) {
+    if (selection.provider) {
+        const entry = findProviderForModelId(selection.modelId, available, {
+            preferredProvider: selection.provider,
+        });
+        return {
+            provider: selection.provider,
+            resolved: Boolean(entry),
+        };
+    }
+    const entry = findProviderForModelId(selection.modelId, available);
+    return { provider: entry?.provider, resolved: Boolean(entry) };
+}
+/**
+ * Resolve harness executors.pi tiers (LOW/MED/HIGH) to provider descriptors.
+ * Unresolved tiers (modelId not in available list) omit provider.
+ */
+export async function resolveHarnessPiExecutorMatrix(repoRoot, available) {
+    const rows = [];
+    for (const tier of EXECUTOR_TIERS) {
+        const selection = await readHarnessPiTierSelection(repoRoot, tier);
+        if (!selection)
+            continue;
+        const resolved = resolveTierDescriptor(selection, available);
+        rows.push({
+            tier,
+            modelId: selection.modelId,
+            provider: resolved.provider,
+            resolved: resolved.resolved,
+        });
+    }
+    return rows;
+}
+/** Map Pi ModelRuntime snapshot.available to resolver entries. */
+export function mapSnapshotAvailableModels(snapshot) {
+    const available = snapshot.available ?? [];
+    const configured = snapshot.configuredProviders;
+    const isConfigured = (provider) => configured instanceof Set ? configured.has(provider) : false;
+    return available.map((m) => ({
+        id: m.id,
+        name: m.name,
+        provider: m.provider,
+        hasCredentials: isConfigured(m.provider),
+    }));
+}
 /**
  * Resolve the Chat default model descriptor. Returns undefined when no model
  * can be resolved (harness unset + no snapshot match).
@@ -104,15 +172,27 @@ export function findProviderForModelId(modelId, available) {
  * @param options.tier harness tier to read (default MED)
  */
 export async function resolveDefaultChatModel(repoRoot, available, options) {
-    const modelId = await readHarnessPiModelTier(repoRoot, options?.tier ?? "MED");
-    if (!modelId)
+    const selection = await readHarnessPiTierSelection(repoRoot, options?.tier ?? "MED");
+    if (!selection)
         return undefined;
-    const entry = findProviderForModelId(modelId, available);
+    if (selection.provider) {
+        const entry = findProviderForModelId(selection.modelId, available, {
+            preferredProvider: selection.provider,
+        });
+        if (!entry)
+            return undefined;
+        return {
+            provider: selection.provider,
+            modelId: selection.modelId,
+            label: entry.name,
+        };
+    }
+    const entry = findProviderForModelId(selection.modelId, available);
     if (!entry)
         return undefined;
     return {
         provider: entry.provider,
-        modelId,
+        modelId: selection.modelId,
         label: entry.name,
     };
 }

package/dist/worker/console/chat/workspace-landing.js

@@ -13,14 +13,58 @@ function configuredWorkspace(value) {
     if (normalized === "chat" ||
         normalized === "tasks" ||
         normalized === "recovery" ||
-        normalized === "night") {
+        normalized === "night" ||
+        normalized === "models" ||
+        normalized === "settings") {
         return normalized;
     }
     return undefined;
 }
+function readWorkspaceParams(query) {
+    const read = (key) => query.get(key)?.trim() || undefined;
+    return {
+        ...(read("taskId") ? { taskId: read("taskId") } : {}),
+        ...(read("dagRunId") ? { dagRunId: read("dagRunId") } : {}),
+        ...(read("fromNodeId") ? { fromNodeId: read("fromNodeId") } : {}),
+        ...(read("featureId") ? { featureId: read("featureId") } : {}),
+    };
+}
+/** Parse `#/tasks?taskId=…` hash routes (Observe-style virtual paths). */
+export function parseConsoleHashRoute(hashValue) {
+    const raw = String(hashValue ?? "").replace(/^#/, "");
+    if (!raw)
+        return null;
+    const qIndex = raw.indexOf("?");
+    const pathPart = qIndex >= 0 ? raw.slice(0, qIndex) : raw;
+    const queryPart = qIndex >= 0 ? raw.slice(qIndex + 1) : "";
+    const path = (pathPart || "/").split("?")[0] || "/";
+    if (path === "/" || path === "")
+        return null;
+    const segment = path.replace(/^\//, "").split("/")[0];
+    const workspace = configuredWorkspace(segment);
+    if (!workspace)
+        return null;
+    return { workspace, ...readWorkspaceParams(new URLSearchParams(queryPart)) };
+}
+function parseLegacyWorkspaceHref(location) {
+    const query = new URLSearchParams(location.search);
+    const hash = location.hash.startsWith("#")
+        ? location.hash.slice(1)
+        : location.hash;
+    const hashQuery = new URLSearchParams(hash);
+    const workspace = configuredWorkspace(query.get("workspace") ??
+        query.get("landing") ??
+        hashQuery.get("workspace"));
+    if (!workspace)
+        return null;
+    return { workspace, ...readWorkspaceParams(query) };
+}
 function workspaceFromLocation(location) {
     if (!location)
         return undefined;
+    const hashRoute = parseConsoleHashRoute(location.hash);
+    if (hashRoute)
+        return hashRoute.workspace;
     const query = new URLSearchParams(location.search);
     const queryValue = configuredLanding(query.get("landing") ?? query.get("workspace"));
     if (queryValue)
@@ -36,31 +80,23 @@ export function resolveDefaultLanding(input) {
         configuredLanding(input.env) ??
         "tasks");
 }
-export function buildWorkspaceHref(workspace, params = {}) {
-    const query = new URLSearchParams({ workspace });
+/** Hash path segment for Console virtual routing (no leading `#`). */
+export function buildConsoleHashPath(workspace, params = {}) {
+    const query = new URLSearchParams();
     for (const [key, value] of Object.entries(params)) {
         if (value?.trim())
             query.set(key, value.trim());
     }
-    return `/?${query.toString()}`;
+    const qs = query.toString();
+    const base = `/${workspace}`;
+    return qs ? `${base}?${qs}` : base;
+}
+export function buildWorkspaceHref(workspace, params = {}) {
+    return `#${buildConsoleHashPath(workspace, params)}`;
+}
+export function parseConsoleRoute(location) {
+    return (parseConsoleHashRoute(location.hash) ?? parseLegacyWorkspaceHref(location));
 }
 export function parseWorkspaceHref(location) {
-    const query = new URLSearchParams(location.search);
-    const hash = location.hash.startsWith("#")
-        ? location.hash.slice(1)
-        : location.hash;
-    const hashQuery = new URLSearchParams(hash);
-    const workspace = configuredWorkspace(query.get("workspace") ??
-        query.get("landing") ??
-        hashQuery.get("workspace"));
-    if (!workspace)
-        return null;
-    const read = (key) => query.get(key)?.trim() || undefined;
-    return {
-        workspace,
-        ...(read("taskId") ? { taskId: read("taskId") } : {}),
-        ...(read("dagRunId") ? { dagRunId: read("dagRunId") } : {}),
-        ...(read("fromNodeId") ? { fromNodeId: read("fromNodeId") } : {}),
-        ...(read("featureId") ? { featureId: read("featureId") } : {}),
-    };
+    return parseConsoleRoute(location);
 }

package/dist/worker/console/doctor.js

@@ -178,6 +178,7 @@ export async function runConsoleDoctor(options) {
     const pi = await probePiReadiness({
         override: options.piReadinessProbe,
         siblingControllerOk: Boolean(controllerIdentity && "packageVersion" in controllerIdentity),
+        repoRoot,
     });
     return {
         ok: true,

package/dist/worker/console/night-aux-ticker.js

@@ -22,6 +22,11 @@ export class NightAuxTicker {
         this.deps = deps;
         this.intervalSec = Math.max(15, Math.min(3600, deps.intervalSec ?? DEFAULT_CLOCK_INTERVAL_SEC));
         this.now = deps.now ?? (() => new Date());
+        if (deps.autoStart !== false) {
+            this.enabled = true;
+            this.startTimer();
+            void this.fire("enable");
+        }
     }
     status() {
         return {

package/dist/worker/console/operator-surface-health.js

@@ -9,6 +9,7 @@ export function buildOperatorSurfaceHealthV1(input) {
         ok: true,
         product: "loop-operator-console",
         repoFingerprint: repoFingerprintV1(input.repoRoot),
+        repoName: input.repoRoot.split(/[\\/]/).filter(Boolean).pop() ?? "repository",
         packageName,
         packageVersion,
         piReadiness: input.piReadiness,

package/dist/worker/console/pi-readiness.js

@@ -3,6 +3,7 @@
  * setup-required | ready | degraded — no pure form fallback.
  */
 import path from "node:path";
+import { mapSnapshotAvailableModels, resolveHarnessPiExecutorMatrix, } from "./chat/model-resolver.js";
 const SETUP_BLOCKED = Object.freeze([
     "newTask",
     "importPrd",
@@ -27,13 +28,6 @@ const DEGRADED_BLOCKED = Object.freeze([
     "standaloneTaskRerun",
     // new Interview may resume; brand-new apply/run still blocked
 ]);
-/** Default Interview / DAG model matrix (provider, modelId). */
-const INTERVIEW_MODEL_CANDIDATES = Object.freeze([
-    ["openai", "gpt-5.5"],
-    ["openai", "gpt-5.3-codex-spark"],
-    ["zai", "glm-5.2"],
-    ["zhipu", "glm-5.2"],
-]);
 export function classifyPiReadiness(probe) {
     if (!probe.sdkAvailable ||
         !probe.authReady ||
@@ -92,7 +86,8 @@ function hasProviderConfig(snapshot) {
  * Kept inside worker/console (dynamic import) so Worker does not depend on
  * executors; contract matches pi-sdk-executor 0.80.10.
  */
-export async function discoverPiReadinessProbe() {
+export async function discoverPiReadinessProbe(options) {
+    const repoRoot = options?.repoRoot ?? process.cwd();
     let sdk;
     try {
         sdk = (await import("@earendil-works/pi-coding-agent"));
@@ -173,12 +168,16 @@ export async function discoverPiReadinessProbe() {
     const snapshot = runtime.snapshot ?? {};
     const availableCount = countAvailableModels(snapshot);
     const providerConfigured = hasProviderConfig(snapshot);
-    const resolvedInterviewModels = [];
+    const availableModels = mapSnapshotAvailableModels(snapshot);
+    const harnessMatrix = await resolveHarnessPiExecutorMatrix(repoRoot, availableModels);
+    const resolvedHarnessModels = [];
     if (typeof runtime.getModel === "function") {
-        for (const [provider, modelId] of INTERVIEW_MODEL_CANDIDATES) {
+        for (const row of harnessMatrix) {
+            if (!row.provider)
+                continue;
             try {
-                if (runtime.getModel(provider, modelId)) {
-                    resolvedInterviewModels.push(`${provider}/${modelId}`);
+                if (runtime.getModel(row.provider, row.modelId)) {
+                    resolvedHarnessModels.push(`${row.tier}/${row.modelId}@${row.provider}`);
                 }
             }
             catch {
@@ -186,8 +185,16 @@ export async function discoverPiReadinessProbe() {
             }
         }
     }
+    const harnessMatrixSummary = harnessMatrix.length > 0
+        ? harnessMatrix
+            .map((row) => {
+            const resolved = resolvedHarnessModels.some((entry) => entry.startsWith(`${row.tier}/${row.modelId}@`));
+            return `${row.tier}/${row.modelId}${resolved ? `@${row.provider}` : ":missing"}`;
+        })
+            .join(",")
+        : "none";
     const authReady = availableCount > 0 || providerConfigured;
-    const modelsAvailable = availableCount > 0 || resolvedInterviewModels.length > 0;
+    const modelsAvailable = availableCount > 0 || resolvedHarnessModels.length > 0;
     let interviewSessionOk = false;
     let sessionMessage;
     if (!authReady || !modelsAvailable) {
@@ -200,9 +207,9 @@ export async function discoverPiReadinessProbe() {
     }
     else {
         try {
-            sdk.SessionManager.inMemory(process.cwd());
+            sdk.SessionManager.inMemory(repoRoot);
             interviewSessionOk = true;
-            sessionMessage = `Interview session preflight ok (${availableCount} available model(s); matrix=${resolvedInterviewModels.join(",") || "none"})`;
+            sessionMessage = `Interview session preflight ok (${availableCount} available model(s); harnessPi=${harnessMatrixSummary})`;
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
@@ -220,7 +227,7 @@ export async function discoverPiReadinessProbe() {
                 ? `credentials/providers ready (available=${availableCount}, providerConfig=${providerConfigured})`
                 : "no available models and no stored/configured provider credentials (set Pi auth or provider API keys)",
             modelsMessage: modelsAvailable
-                ? `models ready (available=${availableCount}, interviewMatrix=${resolvedInterviewModels.join(",") || "none"})`
+                ? `models ready (available=${availableCount}, harnessPi=${harnessMatrixSummary})`
                 : "no available models for Interview",
             sessionMessage,
         },
@@ -235,7 +242,9 @@ export async function probePiReadiness(options) {
         return buildPiReadinessReport(options.override);
     }
     try {
-        const probe = await discoverPiReadinessProbe();
+        const probe = await discoverPiReadinessProbe({
+            repoRoot: options?.repoRoot,
+        });
         if (options?.siblingControllerOk && !probe.details) {
             probe.details = {};
         }

package/dist/worker/console/server.js

@@ -63,6 +63,7 @@ export async function createConsoleServer(options) {
     const assessments = new AssessmentStore(appData);
     const readiness = await probePiReadiness({
         override: options.piReadinessProbe,
+        repoRoot,
     });
     let readinessCache = readiness;
     const artifactRoot = path.join(appData.root, "client-artifacts", appData.fingerprint);
@@ -79,6 +80,7 @@ export async function createConsoleServer(options) {
     const refreshReadiness = async () => {
         readinessCache = await probePiReadiness({
             override: options.piReadinessProbe,
+            repoRoot,
         });
         actionContext.readiness = readinessCache;
         return readinessCache;