@dsh-workbench/core 0.3.6 → 0.3.7

package/dist/types/app/layouts/env-gate/boot-gate.d.ts

@@ -1,7 +1,14 @@
 import type { Translate } from '@dsh-workbench/shared';
 import { apiGet } from '@dsh-workbench/shared';
+/**
+ * 每一拍轮询带什么参数：平时什么都不带（宿主那边跟着正在跑的那一轮，刚跑出 `ready` 的直接回上一次），
+ * 用户按了「重试」之后的那一拍带 `hard=1`（不看新鲜度、一律重来）。首拍不再强探 —— 页面上一次
+ * 刚体检过就不必再跑一轮，两页同时刷新也只有一轮。
+ */
 export declare function createForcePlan(): {
-    next(): boolean;
+    next(): {
+        hard?: 1;
+    };
     again(): void;
 };
 export interface BootGate {

package/dist/types/app/layouts/rightbar/market-busy.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 一条「市场自己正在动它」的事实最多认多久（毫秒）：从发布那一刻起算，到点自动撤。
+ * 取的是工作台那一跳同一条窗口 —— 一次替换最长等这么久；正常落地会由发布方先撤掉。
+ */
+export declare const MARKET_BUSY_MS = 180000;
+/**
+ * 这一刻哪些单元算「正在被动」：发布过、且没到 {@link MARKET_BUSY_MS} 的那些 id。
+ * 给纯函数与判据用；React 里读 {@link useMarketBusy}（同一份，只是走订阅）。
+ */
+export declare function marketBusyIds(): ReadonlySet<string>;
+/**
+ * 发布「哪几个单元正被市场自己动」（每次整体替换）：点下去那一刻发，落地/失败后发空数组。
+ * 同一个 id 连续发布不会顺延它的期限；空数组等于全撤。
+ */
+export declare function publishMarketBusy(ids: readonly string[]): void;
+/**
+ * 订阅这份事实的变化（发布内容真变了、或有条目到期才通知）。返回退订函数。
+ */
+export declare function subscribeMarketBusy(listener: () => void): () => void;
+/**
+ * 组件里读「正被市场自己动的单元」：返回的集合在两次通知之间是同一份引用，可以直接进渲染。
+ */
+export declare function useMarketBusy(): ReadonlySet<string>;
+/**
+ * 把「市场正在动哪个单元」挂到这一拍上：`id` 变了就整体替换发布，`null` 等于撤。
+ * 卸载那一下**不清**（更新还在跑，徽标不该改口）；到 {@link MARKET_BUSY_MS} 由自己到期兜底。
+ */
+export declare function usePublishMarketBusy(id: string | null): void;

package/dist/types/app/layouts/rightbar/market-hint.d.ts

@@ -12,5 +12,12 @@ export interface MarketHintInput {
     readonly installed?: readonly InstalledWorkbenchModule[] | undefined;
     readonly plugins?: readonly InstalledPlugin[] | null | undefined;
     readonly workbench?: WorkbenchVersion | null | undefined;
+    readonly busy?: ReadonlySet<string> | undefined;
 }
+/**
+ * 左栏市场入口那枚徽标这一刻该说什么：`problem`（模块异常）> `restart`（重启后生效）> `updates`（有新版本），
+ * 都没有就 `null`。读法与市场页同一份数据、同一套造行函数。
+ * `busy` 里的单元（正被市场自己更新/卸载的那一单元）当它不在名单里：更新是「先卸再装」，
+ * 卸的那一半会让它从名册里消失，不排掉就会在跑的过程中报一次假的「重启后生效」。
+ */
 export declare function marketHintOf(input: MarketHintInput): PanelHint | null;

package/dist/types/app/layouts/sidebar/DebugFooterAction.d.ts

@@ -1,4 +1,5 @@
-import type { DebugState, SessionsSnapshot, SnapshotSelectorHook, Translate, WorkspaceSnapshot } from '@dsh-workbench/shared';
+import type { SessionsSnapshot, SnapshotSelectorHook, Translate, WorkspaceSnapshot } from '@dsh-workbench/shared';
+import type { DebugState } from '@dsh-workbench/shared/host';
 export interface DebugFooterActionProps {
     readonly wide?: boolean | undefined;
     readonly t: Translate;

package/dist/types/app/layouts/sidebar/RecordFooterAction.d.ts

@@ -1,4 +1,5 @@
-import type { RecordIntent, RecordState, Translate } from '@dsh-workbench/shared';
+import type { Translate } from '@dsh-workbench/shared';
+import type { RecordIntent, RecordState } from '@dsh-workbench/shared/host';
 export interface RecordFooterActionProps {
     readonly wide?: boolean | undefined;
     readonly t: Translate;

package/dist/types/app/layouts/sidebar/SessionList.d.ts

@@ -1,13 +1,15 @@
 import type { RenderSlot, SessionStatusSnapshot, SessionsSnapshot, SnapshotSelectorHook, Translate, WorkspaceView } from '@dsh-workbench/shared';
+import { type LongTaskPresence } from '../../../modules/sessions';
 export interface SessionListProps {
     workspace: WorkspaceView | null;
     pinnedIds: readonly string[];
     archived: readonly string[];
     panelActive: boolean;
+    longTasks: LongTaskPresence;
     useSessions: SnapshotSelectorHook<SessionsSnapshot>;
     useSessionStatus: SnapshotSelectorHook<SessionStatusSnapshot>;
     onOpen: (sessionId: string) => void;
     renderSlot: RenderSlot;
     t: Translate;
 }
-export declare function SessionList({ workspace, pinnedIds, archived, panelActive, useSessions, useSessionStatus, onOpen, renderSlot, t, }: SessionListProps): JSX.Element;
+export declare function SessionList({ workspace, pinnedIds, archived, panelActive, longTasks, useSessions, useSessionStatus, onOpen, renderSlot, t, }: SessionListProps): JSX.Element;

package/dist/types/app/layouts/sidebar/session-pick.d.ts

@@ -1,10 +1,12 @@
 import type { SessionStatusSnapshot, SessionsSnapshot, WorkspaceView } from '@dsh-workbench/shared';
+import { type LongTaskPresence } from '../../../modules/sessions';
 export interface PickProjectInput {
     readonly workspaceId: string;
     readonly items: readonly WorkspaceView[];
     readonly sessions: SessionsSnapshot;
     readonly statusById: SessionStatusSnapshot;
     readonly archivedIds: ReadonlySet<string>;
+    readonly longTasks: LongTaskPresence;
     readonly openSession: (sessionId: string) => void;
     readonly startSession: (workspaceId: string) => void;
 }

package/dist/types/app/layouts/sidebar/use-attention.d.ts

@@ -1,5 +1,5 @@
 import type { SessionStatusSnapshot, SessionsSnapshot, WorkspaceView } from '@dsh-workbench/shared';
-import { type Attention } from '../../../modules/sessions';
+import { type Attention, type LongTaskPresence } from '../../../modules/sessions';
 export interface SidebarAttentionInput {
     readonly items: readonly WorkspaceView[];
     readonly sessions: SessionsSnapshot;
@@ -7,6 +7,7 @@ export interface SidebarAttentionInput {
     readonly archived: readonly string[];
     readonly storedId: string | null;
     readonly panelActive: boolean;
+    readonly longTasks: LongTaskPresence;
 }
 export interface SidebarAttentionState {
     readonly current: WorkspaceView | null;
@@ -14,3 +15,8 @@ export interface SidebarAttentionState {
     readonly attention: Attention;
 }
 export declare function useSidebarAttention(input: SidebarAttentionInput): SidebarAttentionState;
+/**
+ * 左栏要的那份长任务归属：外壳那条读口交回「全进程还在跑的长任务」，这里折成会话侧与工作区侧。
+ * @returns 两侧的归属（谁起了 / 哪个工作区里有几趟）。
+ */
+export declare function useLongTaskPresence(): LongTaskPresence;

package/dist/types/modules/panels/model/diy-context.d.ts

@@ -88,6 +88,15 @@ export declare function showOrReason(panels: PanelsService, unit: string, worksp
     readonly ok: boolean;
     readonly reason?: string;
 };
+/**
+ * 这一次 DIY 调用落在哪个工坊上：**先认工坊自己的家**（`$DSH_HOME/workbench/diy`，宿主就是按它把工坊
+ * 登记成工作区的），**不跟着会话 cwd 走** —— 用户把自己的项目设成工作区时，cwd 往上找会撞上任意一个
+ * 带 `packages/` 的仓库，模块列表与 `shots/` 落点会一起变样（真机踩过：录制落点跑到仓库根、截图 EPERM）。
+ * 只有拿不到工坊的家时，才退回"从会话工作区往上找像工坊的目录"。
+ * @param ctx - 宿主上下文。
+ * @param exec - 这次工具调用（退回那一档要读它的会话工作区）。
+ * @returns 工坊的 packages 目录、根路径与标题。
+ */
 export declare function workshopOf(ctx: DshHostContext, exec: DshToolRunContext): Promise<{
     readonly packagesDir: string;
     readonly workspace: string | null;

package/dist/types/modules/panels/model/diy-record-beat.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/modules/panels/model/diy-record-close.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/modules/panels/model/diy-record-hook.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/modules/panels/model/diy-record-open.d.ts

@@ -0,0 +1,28 @@
+import type { DshShell } from '@dsh-workbench/shared';
+/**
+ * 两个地址是不是"同一页"：比之前先把查询串 / 锚点 / 末尾斜杠抹掉 —— `open` 导航之后
+ * 地址栏常常多一个斜杠或一串 hash，那不算开错了页。
+ * @param here - 那一页现在真实所在的地址（`location.href`）。@param want - 我们要它去的地址。@returns 同一页为 `true`。
+ */
+export declare function samePageOf(here: string, want: string): boolean;
+/**
+ * 把录制那一页开起来，并且**确认它真的开起来了**才回来。
+ *
+ * 先收掉这条会话的残留（否则新页会开进上一次留下的那扇旧窗里，不顶前台、看上去"根本没弹窗"）；
+ * 再 `tab new --window foreground` 开我们的页；**然后读一次 `location.href` 核实** —— 开出来是空白页
+ * 或别的地址时，回落到 opencli 的 `open`（它落在会话租约那个标签上）再核一次；两次都不对就
+ * `ok: false`，让调用方把这句话原样报给 agent，**不许在没开起来的页上装浮条说"已开始录制"**。
+ * @param input - 这条会话的名字 / 目标地址 / 捕获文件（收残留那一拍要用）。
+ * @returns `ok: false` 时 `at` 是那一页现在真实的地址（`''` = 空白页），`why` 是给 agent 看的一句话。
+ */
+export declare function openRecordPage(input: {
+    readonly shell: DshShell;
+    readonly command: string;
+    readonly session: string;
+    readonly url: string;
+    readonly captureFile: string;
+}): Promise<{
+    readonly ok: boolean;
+    readonly at: string;
+    readonly why: string;
+}>;

package/dist/types/modules/panels/model/diy-record-open.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/modules/panels/model/diy-record-shot.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/modules/panels/model/diy-record-text.d.ts

@@ -1,4 +1,4 @@
-import type { RecordExpect, RecordMove, RecordRefusal, RecordState } from '@dsh-workbench/shared';
+import type { RecordExpect, RecordMove, RecordRefusal, RecordState } from '@dsh-workbench/shared/host';
 export interface RecordCall {
     readonly key: string;
     readonly method: string;
@@ -20,8 +20,18 @@ export interface RecordPageRead {
     readonly here: string;
     readonly dropped: number;
     readonly unhooked: boolean;
+    readonly shots: number;
+    readonly shotsAt: number | null;
+    readonly beat: boolean;
+    readonly beatKind: string;
     readonly calls: readonly RecordCall[];
 }
+export interface RecordShotLine {
+    readonly n: number;
+    readonly at: number;
+    readonly path: string;
+    readonly error?: string;
+}
 export declare function recordPageOf(payload: Record<string, unknown> | undefined): RecordPageRead;
 export declare function filterTextOf(expect: RecordExpect | null): string;
 export declare function probeCommandOf(calls: readonly RecordCall[]): string;
@@ -61,8 +71,12 @@ export interface RecordReadFacts {
     readonly nav: boolean;
     readonly filter: string;
     readonly captureRound: string;
+    readonly shots?: readonly RecordShotLine[];
+    readonly beats?: number;
+    readonly beatMs?: number;
 }
 export declare function renderRecordRead(input: RecordReadFacts): string;
+/** 详情那一拍的原料：入参 / 出参 / 请求头那几块原文的渲染全靠它。 */
 export interface RecordDetailFacts {
     readonly found: boolean;
     readonly where: string;
@@ -83,6 +97,7 @@ export interface RecordDetailFacts {
     readonly maxBytes: number;
     readonly note: string;
 }
+/** 把字段证据表插进详情正文：接在出参那一块之后、`请求头` 那一行（或第一条附注）之前；没有锚点就接在末尾。空串原样回。 */
 export declare function renderRecordDetail(input: RecordDetailFacts): string;
 export declare function moveOrThrow(move: RecordMove, held: RecordState | null): RecordState;
 export declare function domainOf(url: string): string;

package/dist/types/modules/panels/model/diy-record-tools.d.ts

@@ -1,2 +1,3 @@
-import type { DshHostContext, RecordStore } from '@dsh-workbench/shared';
+import type { DshHostContext } from '@dsh-workbench/shared';
+import type { RecordStore } from '@dsh-workbench/shared/host';
 export declare function registerRecordTools(ctx: DshHostContext, store: RecordStore): readonly (() => void)[];

package/dist/types/modules/panels/model/diy-record.d.ts

@@ -1,16 +1,36 @@
-import type { DshHostContext, DshShell, RecordState, RecordStore } from '@dsh-workbench/shared';
+import type { DshHostContext, DshShell } from '@dsh-workbench/shared';
+import type { RecordState, RecordStore } from '@dsh-workbench/shared/host';
 import type { CaptureEntry } from './diy-record-capture';
 import type { RecordCall, RecordListRow, RecordPageRead } from './diy-record-text';
 export declare const OPEN_TIMEOUT_MS = 30000;
 export declare const SETTLE_MS = 2000;
 export declare const WAIT_CAP_MS: number;
 export declare const POLL_MS = 1000;
+/**
+ * 捕获那一层要滤掉的 URL：静态资源（`data:` 与常见后缀）。用法 `new RegExp(...).test(url)`，命中即丢。
+ */
+export declare const STATIC_URL_PATTERN = "^(data:)|(\\.(js|css|png|jpe?g|gif|svg|woff2?|ico|map|webp|mp4)(\\?|$))";
 export declare const DETAIL_MAX_BYTES = 60000;
 export declare const pauseFor: (ms: number) => Promise<void>;
 export declare function waitOf(value: unknown): number;
 export declare function foreignDomainText(design: unknown, url: string): string;
 export declare function captureFileOf(packagesDir: string, unit: string): string;
 export declare function lastCaptureFileOf(file: string): string;
+/**
+ * 这一族自己的落图路径：跟 `rec-<unit>.jsonl` 同目录、`rec-shot-` 前缀（工坊那一页的图另有名字）。
+ * @param captureFile - 这一场捕获文件；图就落在它旁边。@param unit - 单元名。@param n - 页面「已拍」计数。
+ * @returns 形如 `…/shots/rec-shot-<unit>-<n>.png` 的路径。
+ */
+export declare function shotFileOf(captureFile: string, unit: string, n: number): string;
+/**
+ * 把这一张现场图落进 `shots/`：argv **只有 `screenshot <path>`，一个视口参数都不给** —— `--full-page` 走
+ * `captureBeyondViewport`、`--width` / `--height` 走 `setDeviceMetricsOverride`：真机上按一下页面**看得见地闪**
+ * （2026-10-21 两次报过）、还可能让填了一半的表单跳位；调试族那把平时也是这一档（先 `eval` 量盒子再本地 `clip`）。
+ * 真机上这个平台整页高与视口一样（1512×698）—— `--full-page` 一点没多给，白闪。
+ * @param input - 看护那一拍的依赖（shell / 命令 / 会话 / 台账）。
+ * @param held - 当前那份约定（路径按它的 `unit` 拼）。@param n - 页面浮条上那个「已拍」计数。
+ */
+export declare function takeShotOf(input: WatchFinishDeps, held: RecordState, n: number): Promise<void>;
 export declare function startRecordCapture(shell: DshShell, command: string, session: string, file: string): Promise<boolean>;
 export interface WatchFinishDeps {
     readonly ctx: DshHostContext;
@@ -21,10 +41,29 @@ export interface WatchFinishDeps {
     readonly url: string;
     readonly captureFile: string;
 }
+/**
+ * 看护的一拍（= 一圈循环）：读数那一条 `eval` **自己在页面里最多等 `RECORD_WATCH_MS`**（浮条在他按
+ * 「开始 / 截图 / 结束」时会唤醒挂在页面上的那个 waiter ⇒ 一按就回来），所以这一轮 = **恰好一条 `eval`**：
+ * 命中就立刻做那一拍，没人按就照旧 3 秒一拍 —— 兜底周期一字未变。该落图就落图；认到「结束」就封口、
+ * **叫醒 agent**、**关掉录制窗**、收工（关窗排在叫醒之后：关窗慢 / 失败不许拖住叫醒，失败也不抛 ——
+ * 那一扇是我们为录制借来的，ADR-0064 补记）。
+ * ⚠️ 读数那条**不许**改成 opencli 的 `wait xhr`：它**读一次清一次**那只捕获环（`cdp.js:346-353`），而 reaper
+ * 也读同一只环才拿得到 body ⇒ 会把 `rec-<unit>.jsonl` 吃空。理由与实测见 `.scratch/diy-write-record/issues/06-doorbell.md` §1.1。
+ * @param input - 看护那一拍的依赖。@returns `stop` = 这条循环可以收了；`delivered` = 这一拍叫醒过 agent。
+ */
 export declare function watchFinishStepOf(input: WatchFinishDeps): Promise<{
     readonly stop: boolean;
     readonly delivered: boolean;
 }>;
+export interface WatchRoundOut {
+    readonly stop: boolean;
+    readonly delivered: boolean;
+}
+/**
+ * 看护的一轮（就是 `watchFinishStepOf`，留着这个名字是给测试与调用点一个稳定的形）。
+ * @param input - 看护那一拍的依赖。@returns 收不收工、有没有叫醒。
+ */
+export declare function watchRoundOf(input: WatchFinishDeps): Promise<WatchRoundOut>;
 export declare function watchRecordFinish(input: WatchFinishDeps): void;
 export interface CaptureRead {
     readonly text: string;

package/dist/types/modules/panels/model/diy-report.d.ts

@@ -1,4 +1,4 @@
-import type { PanelUnitReport } from '@dsh-workbench/shared';
+import type { PanelUnitReport } from '@dsh-workbench/shared/host';
 import { type WorkshopModule, type WorkshopSync, type WorkshopToolchain } from '../../../shared/api/host/diy-workshop';
 export declare const SYNC_STALE_MINUTES = 15;
 export declare const SYNC_STALE_MS: number;

package/dist/types/modules/sessions/index.d.ts

@@ -1,3 +1,3 @@
 export { currentSessionId, orderByRecency, sessionNode, orderSessionRows, sessionRows, workspaceOfSession, sessionStatuses, visiblePendingKind, type SessionNode, type SessionStatusDot, } from './model/session-node';
 export { scrollEdgesOf, type ScrollEdges } from './model/scroll-edges';
-export { attentionLabel, attentionOf, attentionOfSession, attentionSessionIdOf, attentionWordLabel, type Attention, type AttentionInput, type AttentionSeverity, type WorkspaceAttention, } from './model/attention';
+export { attentionLabel, attentionOf, attentionOfSession, attentionSessionIdOf, attentionWordLabel, longTaskPresenceOf, type Attention, type AttentionInput, type AttentionSeverity, type LongTaskPresence, type WorkspaceAttention, } from './model/attention';

package/dist/types/modules/sessions/model/attention-long-task.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/modules/sessions/model/attention.d.ts

@@ -1,9 +1,29 @@
 import type { SessionStatusSnapshot, SessionSummary, SessionsSnapshot, Translate, WorkspaceView } from '@dsh-workbench/shared';
 export type AttentionSeverity = 'warning' | 'ongoing' | 'done';
+/**
+ * 一个工作区那颗状态点：`count` 是**会话**条数（照旧，长任务没有会话可归时它是 0）；
+ * `longTask` 为真表示这一档说的是长任务而不是会话 —— 只改那句人话的措辞。
+ */
 export interface WorkspaceAttention {
     readonly severity: AttentionSeverity;
     readonly count: number;
+    readonly longTask?: boolean | undefined;
 }
+/** 还在跑的长任务按两边归：会话行那颗 loading 点看 `bySession`，项目下拉每一行看 `byWorkspace`（按工作区路径数条数）。 */
+export interface LongTaskPresence {
+    readonly bySession: ReadonlySet<string>;
+    readonly byWorkspace: ReadonlyMap<string, number>;
+}
+/**
+ * 把外壳那条长任务读口交回的行折成两侧的归属：有会话可归的进 `bySession`（那一行自己亮），
+ * 每一条都按它属于哪个工作区进 `byWorkspace`（没有会话可归的那些只有这一侧看得见）。
+ * @param rows 还在跑的长任务；每行要有它属于哪个工作区，会话那格可以没有。
+ * @returns 两侧的归属；空输入就是两侧都空。
+ */
+export declare function longTaskPresenceOf(rows: readonly {
+    readonly workspace: string;
+    readonly session?: string | undefined;
+}[]): LongTaskPresence;
 export interface Attention {
     readonly byWorkspace: ReadonlyMap<string, WorkspaceAttention>;
     readonly elsewhere: WorkspaceAttention | null;
@@ -15,13 +35,15 @@ export interface AttentionInput {
     readonly statusById: SessionStatusSnapshot;
     readonly archivedIds: ReadonlySet<string>;
     readonly currentWorkspaceId: string | null;
+    readonly longTasks?: LongTaskPresence | undefined;
 }
-export declare function attentionOfSession(summary: SessionSummary, statusById: SessionStatusSnapshot, sessions: SessionsSnapshot): AttentionSeverity | undefined;
+export declare function attentionOfSession(summary: SessionSummary, statusById: SessionStatusSnapshot, sessions: SessionsSnapshot, longTaskIds?: ReadonlySet<string>): AttentionSeverity | undefined;
 export interface AttentionPickInput {
     readonly workspace: WorkspaceView | null;
     readonly sessions: SessionsSnapshot;
     readonly statusById: SessionStatusSnapshot;
     readonly archivedIds: ReadonlySet<string>;
+    readonly longTasks?: LongTaskPresence | undefined;
 }
 export declare function attentionSessionIdOf(input: AttentionPickInput): string | null;
 export declare function attentionOf(input: AttentionInput): Attention;

package/dist/types/modules/sessions/model/session-node.d.ts

@@ -5,6 +5,7 @@ export interface SessionNode {
     readonly blank: boolean;
     readonly running: boolean;
     readonly runningSubagentCount: number;
+    readonly longTask: boolean;
     readonly completed: boolean;
     readonly pinned: boolean;
     readonly updatedAt: number;
@@ -16,7 +17,17 @@ export interface SessionStatusDot {
     readonly trailingLabel?: string;
 }
 export declare function visiblePendingKind(kind: string | undefined): string | undefined;
-export declare function sessionNode(summary: SessionSummary, statusById: SessionStatusSnapshot, list: SessionsSnapshot, pinnedIds: ReadonlySet<string>, archivedIds: ReadonlySet<string>): SessionNode;
+/**
+ * 把一条会话读成行上要的那几格。
+ * @param summary 会话摘要。
+ * @param statusById 会话状态表。
+ * @param list 会话快照（子代理花名册在这里）。
+ * @param pinnedIds 置顶的那些。
+ * @param archivedIds 归档的那些。
+ * @param longTaskIds 有长任务在跑的那些会话（外壳那条读口按“这趟是谁起的”算出来的）；不给就是都没有。
+ * @returns 行模型；`longTask` 为真表示这条会话起的某趟长任务还在跑（它自己那一轮可能早结束了）。
+ */
+export declare function sessionNode(summary: SessionSummary, statusById: SessionStatusSnapshot, list: SessionsSnapshot, pinnedIds: ReadonlySet<string>, archivedIds: ReadonlySet<string>, longTaskIds?: ReadonlySet<string>): SessionNode;
 export declare function sessionStatuses(node: SessionNode, t: Translate): SessionStatusDot[];
 export declare function currentSessionId(list: SessionsSnapshot, panelActive: boolean): string | undefined;
 export declare function orderByRecency(rows: readonly SessionSummary[]): SessionSummary[];

package/dist/types/shared/api/host/long-tasks.d.ts

@@ -0,0 +1,10 @@
+import type { LongTaskBase, LongTaskRegistry } from '@dsh-workbench/shared/host';
+import type { ShellLongTaskRow } from '../long-tasks';
+/**
+ * 把「单元 → 它那把长任务注册表」收成一条条**还在跑**的行（`live()` 已经只给活着的那几趟，
+ * 收尾的是面板那一行的事）；注册表是上一版、没有 `live()` 就跳过这个单元 —— 与停止那条动作
+ * 同一个理由：那一版里没有这份读口，不是这一版坏了。
+ * @param runs 当前挂着的单元各自那把长任务注册表（外壳进程里就这一份）。
+ * @returns 正在跑的长任务（含 `needs-login` 那种），每条带上是哪个单元起的。
+ */
+export declare function liveLongTaskRows(runs: ReadonlyMap<string, LongTaskRegistry<LongTaskBase>>): ShellLongTaskRow[];

package/dist/types/shared/api/host/preflight.d.ts

@@ -26,9 +26,15 @@ export interface PreflightSnapshot {
     readonly guidance?: PreflightGuidance;
     readonly bridgeIssues?: readonly PreflightBridgeIssue[];
 }
+/**
+ * 环境体检：`run()` 跑一次并回快照，`snapshot()` 看眼下这一拍。`run` 的取舍是：
+ * 已经有在跑的那一轮就跟它（不再排第二轮）；上一次跑出 `ready` 且不到 `PREFLIGHT_FRESH_MS`
+ * 也直接回那一份 —— 于是两页同时打开只体检一轮、第二页还不用等。`hard` 不看新鲜度、一律重来，
+ * 留给用户按的那颗「重试」；上一次是失败/没跑完的也一律重来。
+ */
 export interface Preflight {
     run(options?: {
-        force?: boolean;
+        hard?: boolean;
     }): Promise<PreflightSnapshot>;
     snapshot(): PreflightSnapshot;
 }

package/dist/types/shared/api/host/workshop-root.d.ts

@@ -4,4 +4,13 @@ export interface WorkshopRoot {
     readonly packagesDir: string;
     readonly title: string;
 }
+/**
+ * 工坊**自己的家**（`$DSH_HOME/workbench/diy`）—— 宿主启动时就是按它把工坊登记成工作区的。
+ * DIY 会话的工坊根取这一份，**不随会话 cwd 漂**：cwd 一离开工坊（用户把自己的项目设成工作区），
+ * 从 cwd 往上找会撞上任意一个"带 `packages/` 的仓库"，于是模块列表、`shots/` 落点、装机名单全跟着变样。
+ * 这一档拿不到（没有 `dshHomePath` 服务）时才退回 cwd 那套。
+ * @param ctx - 宿主上下文（要从里面取 `dshHomePath`）。
+ * @returns 工坊的家；取不到给 `null`。
+ */
+export declare function workshopHomeOf(ctx: DshHostContext): WorkshopRoot | null;
 export declare function workshopRootOf(ctx: DshHostContext, workspace: string | null): Promise<WorkshopRoot | null>;

package/dist/types/shared/api/long-tasks.d.ts

@@ -0,0 +1,19 @@
+import type { LongTaskStatus } from '@dsh-workbench/shared';
+/**
+ * 外壳自己的长任务读口：一次把**全进程还在跑的**长任务交出来（不分单元、不分工作区）——
+ * 左栏拿它点会话行与项目下拉里那颗 loading 点。
+ */
+export declare const LONG_TASKS_ROUTE = "long-tasks";
+/** 一条还在跑的长任务：左栏只要这几格，模块自己那份投影不参与。 */
+export interface ShellLongTaskRow {
+    readonly unit: string;
+    readonly id: string;
+    readonly workspace: string;
+    readonly target: string;
+    readonly status: LongTaskStatus;
+    readonly session?: string | undefined;
+}
+/** 外壳长任务读口的载荷。 */
+export interface ShellLongTasksPayload {
+    readonly runs: readonly ShellLongTaskRow[];
+}

package/dist/types/shared/hooks/panel-state-report.d.ts

@@ -1,4 +1,4 @@
-import type { PanelCardError, PanelCardPhase } from '@dsh-workbench/shared';
+import type { PanelCardError, PanelCardPhase } from '@dsh-workbench/shared/host';
 /**
  * 从路由里切出单元 id（`cmdb/runs` → `cmdb`）；切不出来（没有前缀）回 `null`。
  */

package/dist/types/shared/hooks/use-diy-debug.d.ts

@@ -1,4 +1,4 @@
-import type { DebugState } from '@dsh-workbench/shared';
+import type { DebugState } from '@dsh-workbench/shared/host';
 import type { HostWrite } from './use-host-write';
 /**
  * 调试约定的读路由（宿主侧那半同名）。

package/dist/types/shared/hooks/use-diy-record.d.ts

@@ -1,4 +1,4 @@
-import type { RecordState } from '@dsh-workbench/shared';
+import type { RecordState } from '@dsh-workbench/shared/host';
 import type { HostWrite } from './use-host-write';
 /**
  * 录制交接的读路由（宿主侧那半同名）。

package/dist/types/shared/hooks/use-shell-long-tasks.d.ts

@@ -0,0 +1,8 @@
+import { type ShellLongTaskRow } from '../api/long-tasks';
+/**
+ * 左栏那颗 loading 点读的长任务清单：**全进程还在跑的**那些（不分单元、不分工作区，每行带它属于
+ * 哪个工作区、是哪个会话起的）。起 / 走一步 / 收尾宿主都会推一条事实，收到就当场重读；那个定时器
+ * 只是兜底 —— 有在跑的按快档问，都闲着按慢档。
+ * @returns 还在跑的长任务；读数还没回来时是空数组。
+ */
+export declare function useShellLongTasks(): readonly ShellLongTaskRow[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dsh-workbench/core",
-  "version": "0.3.6",
+  "version": "0.3.7",
   "description": "个人工作台：Agent 工作台外壳（左栏 + 常驻对话 + 自研右侧数据面板）。",
   "type": "module",
   "icon": "./icon.svg",
@@ -87,7 +87,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@dsh-workbench/shared": "0.3.6"
+    "@dsh-workbench/shared": "0.3.7"
   },
   "scripts": {
     "build": "node scripts/build.mjs && node scripts/build-types.mjs",

package/skills/workbench-module-diy/BUILD.md

@@ -166,7 +166,7 @@ export function apply(ctx) {
 `card` 拿到 `{ t, world, refreshToken, onRefresh, onSummary }`（`world.current.workspace` 就是当前项目），
 返回一棵元素树。**三态用外壳给的组件，别自己画**：
 加载 → `kit.components.SkeletonRows`；空 → `kit.components.EmptyState`（不带按钮）；
-出错 → `kit.components.BlockerState` + `kit.components.blockerOfError(error, t)`。
+出错 → `kit.components.BlockerState` + `kit.lib.blockerOfError(error, t)`。
 ⚠️ **`idle` 是独立的一格**（没工作区、或取数被 `enabled: false` 关掉时），不许画成"空" ——
 "空"和"还没开始"是两件事，说错了他会去查他根本没配的东西。
 

package/skills/workbench-module-diy/FAMILY.md

@@ -45,7 +45,7 @@
 | 工具 | 干什么 |
 |---|---|
 | `_record_prepare` | 开一扇窗**顶到最前**（**要用户点头一次**）、装浮条、臂上捕获。参数 `unit` / `url` / `doing`，可选 `expect:{method,urlContains}`；**不给 `url` 当场拒**，**跨域也当场拒**（那个模块的 `design.json` 说过读源时，只许同域录；还没说过就不拦）。返回带 `wrote: false` |
-| `_record_read` | 取那一段的**清单**：`rows`（每行 `index` / `key` / `at` / `method` / `url` / `status` / `ct` / `size` / `source` / `hasRequest` / `hasResponse` / `likelyWrite` / `marked`）· `hookCaught`（钩子这一段**原始**条数）· `capturedLines` / `capturedInSegment` / `capturedOutside` · `dropped` · `noBody` · `nav` · `captureRound`（会话捕获**最近一轮**成没成：`ok` / `fail` / 空 = 还没回）。**清单一条都不删、也不回体**：页面钩子（`[t0,t1]` 段）与会话捕获（整场按段切）合并，**同名只配掉一条钩子行**（缺的 key / 入参 / 出参由捕获那条补上）；捕获里两条同 method+url 是**两次真调用，都留着**。**`expect` 不再是过滤器**：它只给命中的行标 ⭐，⭐ 排在前面（不然只列最后十几条时它可能不在正文里）；不设 expect 时 ⭐ = 非 GET 或带 request body。要哪一条的原文就带它的 `key`（或 `index`）去 `_record_detail`。没按开始 / 还在录都如实说，不假装"没有请求"。可选 `waitMs`（默认 0 = 立刻回，帽 15 分钟）：等不到就回 `timedOut` 并挂一条 notice 叫醒你 —— **一场就是一个周期（开始 → 结束）**，结束之后要再录就**重新 `_record_prepare` 一场**（同场没有"再按一次开始"这回事）。**他按「结束录制」不用他再跟你说一声**：录制期间宿主每 3 秒自己看一眼那一页（浮条在目标页里、推不到宿主；宿主能叫醒你的通道只有 `deliverDebugNotice`），一看到 `finished` 就推状态并发一条 notice 叫你来 `read` |
+| `_record_read` | 取那一段的**清单**：`rows`（每行 `index` / `key` / `at` / `method` / `url` / `status` / `ct` / `size` / `source` / `hasRequest` / `hasResponse` / `likelyWrite` / `marked`）· `hookCaught`（钩子这一段**原始**条数）· `capturedLines` / `capturedInSegment` / `capturedOutside` · `dropped` · `noBody` · `nav` · `captureRound`（会话捕获**最近一轮**成没成：`ok` / `fail` / 空 = 还没回）。**清单一条都不删、也不回体**：页面钩子（`[t0,t1]` 段）与会话捕获（整场按段切）合并，**同名只配掉一条钩子行**（缺的 key / 入参 / 出参由捕获那条补上）；捕获里两条同 method+url 是**两次真调用，都留着**。**`expect` 不再是过滤器**：它只给命中的行标 ⭐，⭐ 排在前面（不然只列最后十几条时它可能不在正文里）；不设 expect 时 ⭐ = 非 GET 或带 request body。**正文每一行把它要的两样直接摆出来**：`· [0] ⭐ POST 站点/路径（捕获 · 入参 有 · 出参 40 B · at 1792583917392）` —— 开头那串就是 `key` 原文（opencli 给的，可能带 `#2`），`at` 是毫秒时间戳；**没有 `key` 的钩子行**写成 `method url（钩子 · … · 无 key）`，那种行只在还开着时按 `index` 取得到。要哪一条的原文就带它的 `key`（或 `index`）去 `_record_detail`。没按开始 / 还在录都如实说，不假装"没有请求"。可选 `waitMs`（默认 0 = 立刻回，帽 15 分钟）：等不到就回 `timedOut` 并挂一条 notice 叫醒你 —— **一场就是一个周期（开始 → 结束）**，结束之后要再录就**重新 `_record_prepare` 一场**（同场没有"再按一次开始"这回事）。**他按「结束录制」不用他再跟你说一声**：录制期间宿主每 3 秒自己看一眼那一页（浮条在目标页里、推不到宿主；宿主能叫醒你的通道只有 `deliverDebugNotice`），一看到 `finished` 就推状态并发一条 notice 叫你来 `read` |
 | `_record_detail` | 取**某一条**的原文：入参（`request.body`）与出参（`response body`），外加请求头（可能含凭据，别落进 `design.json`）。参数 `key`（清单里那一条，原样给、含 `#2` 这种后缀）或 `index`（清单里的序号，只在那一场还开着时可用）；**同一个 key 跨轮会重名**（opencli 的 key 计数器每批重置），所以再带上清单里那行的 `at` 才钉得住是哪一次（不给就取最早那条，并在正文里说重名几次）。可选 `unit` —— 那一场**收工之后**要给 unit，我去读 `shots/rec-<unit>.jsonl.last`（`_record_stop` 会把原文留成 `.last`，下一场 prepare 开录时清掉它）。取不到时如实说"两边都没有"，并给兜底：DevTools 复制 curl。可选 `maxBody`（默认 60000 字符，0 = 不限） |
 | `_record_stop` | 停捕获、收掉那个标签、清状态（**收工前先读一次捕获文件**，与 read 同一套切段 / 合并；**原文另存成 `.last`**，所以收工之后还能 `_record_detail`；没挪成就不说"原文留在…"）。回一段能直接落 `design.json` 的原文（`probeCommand`）—— **只认第一条带 body 的**；一条都没有就回空串，并如实说"只有方法 / URL，body 拿不到 —— 补到 body 再落"（没 body 的写命令落下去是一条**会打错的**命令）。**先 read（或先 detail 完）再 stop** |