@dsh-workbench/shared 0.3.11 → 1.0.0-beta.0

package/src/host/adapter-types.ts

@@ -0,0 +1,105 @@
+import type {
+  BundleCancellation,
+  BundleChange,
+  BundleInspection,
+  BundleInstallRequest,
+  BundleRegistries,
+  BundleRegistry,
+} from '../contract/protocol/bundle-install.js';
+
+export type InstalledModule =
+  | {
+      readonly kind: 'module';
+      readonly pkg: string;
+      readonly unit: string;
+      readonly version: string;
+      readonly registry?: string;
+      readonly local?: boolean;
+    }
+  | { readonly kind: 'not-module'; readonly pkg: string }
+  | { readonly kind: 'unknown'; readonly pkg: string };
+
+export interface ProfileModule {
+  readonly pkg: string;
+  readonly unit: string;
+  readonly version: string;
+  readonly registry?: string;
+  readonly local?: boolean;
+}
+
+export interface ProfilePackage {
+  readonly pkg: string;
+  readonly version: string;
+  readonly registry?: string;
+  readonly local?: boolean;
+}
+
+export interface BundleManager {
+  registries(): Promise<BundleRegistries | null>;
+  inspect(spec: string, registry?: BundleRegistry): Promise<BundleInspection | null>;
+  install(request: BundleInstallRequest): Promise<BundleChange | null>;
+  remove(name: string): Promise<BundleChange | null>;
+  setEnabled?(name: string, enabled: boolean): Promise<BundleChange | null>;
+  cancel(requestId: string): Promise<BundleCancellation | null>;
+}
+
+export interface RegistryEntry {
+  readonly scope: string;
+  readonly registry: string;
+}
+
+export interface RegistryNotebook {
+  sources(): readonly RegistryEntry[];
+  remember(entries: readonly RegistryEntry[]): readonly string[];
+}
+
+export interface SelfUpdatePaths {
+  readonly dir: string;
+  readonly script: string;
+  readonly marker: string;
+  readonly log: string;
+}
+
+export interface SelfUpdateRequest {
+  readonly dshHome: string;
+  readonly profile: string;
+  readonly pkg: string;
+  readonly from: string;
+  readonly to: string;
+  readonly pinned: boolean;
+}
+
+export interface SelfUpdateStart {
+  readonly started: boolean;
+  readonly paths: SelfUpdatePaths;
+  readonly forward: string;
+}
+
+export interface OpencliResolution {
+  readonly command: string;
+  readonly source: 'env' | 'isolated' | 'path';
+  readonly isolated: string | null;
+}
+
+export function scopeOf(pkg: string): string | null {
+  const slash = pkg.indexOf('/');
+  return pkg.startsWith('@') && slash > 1 ? pkg.slice(0, slash) : null;
+}
+
+export function normalizeRegistry(url: string): string {
+  const trimmed = url.trim();
+  return trimmed.endsWith('/') ? trimmed : `${trimmed}/`;
+}
+
+export function sameRegistry(a: string | null | undefined, b: string | null | undefined): boolean {
+  if (a === null || a === undefined || b === null || b === undefined) return false;
+  if (a.trim() === '' || b.trim() === '') return false;
+  return normalizeRegistry(a) === normalizeRegistry(b);
+}
+
+export function registryFailure(change: { application?: string; packageResult?: { kind?: string; output?: string }; errorDetail?: string }): boolean {
+  if (change.application !== 'failed') return false;
+  if (change.packageResult?.kind === 'not-found') return true;
+  const output = change.packageResult?.output ?? change.errorDetail ?? '';
+  return /ERR_PNPM_[A-Z_]*FETCH/.test(output);
+}

package/src/host/adapters.ts

@@ -0,0 +1,44 @@
+import type { DshHostContext } from '../api/dsh.js';
+import type { DataReader } from '../contract/data.js';
+import type {
+  EnvSupplyPort,
+  HostActions,
+  ModulePort,
+  PluginSurface,
+  ProbePort,
+  ProfilePort,
+  RuntimePort,
+} from './port-types.js';
+
+export const WORKBENCH_ADAPTERS = 'workbenchAdapters';
+
+export const ADAPTER_SET_API_VERSION = 1;
+
+export const SUPPORTED_ADAPTER_API_VERSIONS: readonly number[] = [ADAPTER_SET_API_VERSION];
+
+export interface AdapterSet {
+  readonly apiVersion: number;
+  readonly id: string;
+  readonly version: string;
+  readonly data: DataReader;
+  readonly supply: EnvSupplyPort;
+  readonly modules: ModulePort;
+  readonly profile: ProfilePort;
+  readonly probe: ProbePort;
+  readonly runtime: RuntimePort;
+  readonly plugins: PluginSurface;
+  readonly actions: HostActions;
+}
+
+export type CoreAdapterSet = Pick<
+  AdapterSet,
+  'apiVersion' | 'id' | 'version' | 'data' | 'supply' | 'profile' | 'probe'
+>;
+
+export type WorkbenchAdapters = AdapterSet;
+
+export function adaptersOf(ctx: DshHostContext): AdapterSet {
+  const adapters = ctx.get<AdapterSet>(WORKBENCH_ADAPTERS, false);
+  if (adapters !== undefined) return adapters;
+  throw new Error('workbenchAdapters 未提供');
+}

package/src/host/browser.ts

@@ -0,0 +1,3 @@
+export const BROWSER_SCREEN_SESSION = 'workbench';
+export const BROWSER_READ_SESSION = 'workbench-read';
+export const BROWSER_RECORD_SESSION = 'workbench-rec';

package/src/host/changelog.ts

@@ -0,0 +1,212 @@
+import dayjs from 'dayjs';
+
+export const CHANGELOG_FILE = 'CHANGELOG.md';
+
+export const CHANGELOG_KINDS = ['added', 'changed', 'fixed', 'removed', 'security', 'deprecated'] as const;
+
+export type ChangelogKind = (typeof CHANGELOG_KINDS)[number];
+
+export interface ChangelogSection {
+  readonly version: string;
+  readonly body: string;
+}
+
+export interface ChangelogEntryOptions {
+  readonly version: string;
+  readonly kind?: ChangelogKind | undefined;
+  readonly note: string;
+  readonly date?: string | undefined;
+}
+
+const KIND_LABELS: Readonly<Record<ChangelogKind, string>> = {
+  added: '✨ 新增',
+  changed: '⚡ 改进',
+  fixed: '🐛 修复',
+  removed: '🗑️ 移除',
+  security: '🔒 安全',
+  deprecated: '⚠️ 弃用',
+};
+
+const VERSION_HEADING = /^##[ \t]+\[?v?(\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?)\]?[ \t]*(?:-[ \t]*.*)?$/;
+const ANY_SECTION = /^##[ \t]/;
+const SUBSECTION = /^###[ \t]/;
+
+export function changelogVersion(value: string): string {
+  return String(value ?? '')
+    .trim()
+    .replace(/^v/, '');
+}
+
+export function changelogDate(now: Date = new Date()): string {
+  return dayjs(now).format('YYYY-MM-DD');
+}
+
+export function normalizeChangelogText(text: string): string {
+  return String(text ?? '').replace(/\r\n?/g, '\n');
+}
+
+function linesOf(text: string): string[] {
+  return normalizeChangelogText(text).split('\n');
+}
+
+function bodyOf(rows: readonly string[]): string {
+  return rows.join('\n').trim();
+}
+
+function sectionRange(
+  rows: readonly string[],
+  version: string,
+): { readonly start: number; readonly end: number } | undefined {
+  const wanted = changelogVersion(version);
+  for (let index = 0; index < rows.length; index += 1) {
+    const row = rows[index] ?? '';
+    if (!ANY_SECTION.test(row)) continue;
+    const match = VERSION_HEADING.exec(row);
+    if (match === null || changelogVersion(match[1] ?? '') !== wanted) continue;
+    let end = rows.length;
+    for (let next = index + 1; next < rows.length; next += 1) {
+      if (ANY_SECTION.test(rows[next] ?? '')) {
+        end = next;
+        break;
+      }
+    }
+    return { start: index, end };
+  }
+  return undefined;
+}
+
+export function changelogSkeleton(): string {
+  return '# 更新日志\n';
+}
+
+export function parseChangelog(text: string): readonly ChangelogSection[] {
+  const rows = linesOf(text);
+  const sections: ChangelogSection[] = [];
+  let current: { readonly version: string; readonly from: number } | undefined;
+  for (let index = 0; index < rows.length; index += 1) {
+    const row = rows[index] ?? '';
+    if (!ANY_SECTION.test(row)) continue;
+    if (current !== undefined) {
+      sections.push({ version: current.version, body: bodyOf(rows.slice(current.from, index)) });
+    }
+    const match = VERSION_HEADING.exec(row);
+    current =
+      match === null
+        ? undefined
+        : { version: changelogVersion(match[1] ?? ''), from: index + 1 };
+  }
+  if (current !== undefined) {
+    sections.push({ version: current.version, body: bodyOf(rows.slice(current.from)) });
+  }
+  return sections;
+}
+
+export function changelogSectionOf(text: string, version: string): string | undefined {
+  const wanted = changelogVersion(version);
+  return parseChangelog(text).find((one) => one.version === wanted)?.body;
+}
+
+export function changelogHasEntry(text: string, version: string): boolean {
+  const body = changelogSectionOf(text, version);
+  if (body === undefined) return false;
+  return body
+    .split('\n')
+    .map((one) => one.trim())
+    .some((one) => one !== '' && !one.startsWith('#') && !one.startsWith('<!--') && !/^`[^`]*`$/.test(one));
+}
+
+function bulletsOf(note: string): string[] {
+  return note
+    .split('\n')
+    .map((one) => one.trim())
+    .filter((one) => one !== '')
+    .map((one) => `- ${one}`);
+}
+
+function blockOf(options: ChangelogEntryOptions, label: string, bullets: readonly string[]): string[] {
+  const date = (options.date ?? '').trim();
+  return [
+    `## v${changelogVersion(options.version)}`,
+    ...(date === '' ? [] : ['', `\`${date}\``]),
+    '',
+    `### ${label}`,
+    '',
+    ...bullets,
+  ];
+}
+
+function insertBlock(rows: readonly string[], at: number, block: readonly string[]): string[] {
+  const before = rows.slice(0, at);
+  while (before.length > 0 && (before[before.length - 1] ?? '').trim() === '') before.pop();
+  const after = rows.slice(at);
+  while (after.length > 0 && (after[0] ?? '').trim() === '') after.shift();
+  const out = [...before];
+  if (out.length > 0) out.push('');
+  out.push(...block);
+  if (after.length > 0) {
+    out.push('');
+    out.push(...after);
+  }
+  return out;
+}
+
+function newSectionAt(rows: readonly string[]): number {
+  for (let index = 0; index < rows.length; index += 1) {
+    if (/^##[ \t]+\[?unreleased\]?[ \t]*$/i.test(rows[index] ?? '')) {
+      for (let next = index + 1; next < rows.length; next += 1) {
+        if (ANY_SECTION.test(rows[next] ?? '')) return next;
+      }
+      return rows.length;
+    }
+  }
+  for (let index = 0; index < rows.length; index += 1) {
+    if (ANY_SECTION.test(rows[index] ?? '')) return index;
+  }
+  return rows.length;
+}
+
+export function appendChangelogEntry(text: string, options: ChangelogEntryOptions): string {
+  const kind: ChangelogKind = options.kind ?? 'changed';
+  const label = KIND_LABELS[kind];
+  const bullets = bulletsOf(options.note);
+  if (bullets.length === 0) return normalizeChangelogText(text);
+  const blocks = blockOf(options, label, bullets);
+  const source = normalizeChangelogText(text).trim() === '' ? changelogSkeleton() : normalizeChangelogText(text);
+  const rows = linesOf(source);
+  const range = sectionRange(rows, options.version);
+  if (range === undefined) return `${insertBlock(rows, newSectionAt(rows), blocks).join('\n').replace(/\n+$/, '')}\n`;
+  let subsection = -1;
+  for (let index = range.start + 1; index < range.end; index += 1) {
+    const heading = (rows[index] ?? '').trim();
+    if (SUBSECTION.test(heading) && heading.includes(label)) {
+      subsection = index;
+      break;
+    }
+  }
+  if (subsection === -1) {
+    const out = [...rows];
+    out.splice(range.end, 0, '', `### ${label}`, '', ...bullets);
+    return `${normalizeWhitespace(out)}\n`;
+  }
+  let end = range.end;
+  for (let index = subsection + 1; index < range.end; index += 1) {
+    if (SUBSECTION.test(rows[index] ?? '')) {
+      end = index;
+      break;
+    }
+  }
+  const out = [...rows];
+  let at = end;
+  while (at > subsection + 1 && (out[at - 1] ?? '').trim() === '') at -= 1;
+  out.splice(at, 0, ...bullets);
+  return `${normalizeWhitespace(out)}\n`;
+}
+
+function normalizeWhitespace(rows: readonly string[]): string {
+  const out: string[] = [];
+  for (const row of rows) {
+    if (row.trim() === '' && out.length > 0 && (out[out.length - 1] ?? '').trim() === '') continue;
+    out.push(row);
+  }
+  return out.join('\n').replace(/\n+$/, '');
+}

package/src/host/channel-plugin.ts

@@ -0,0 +1,55 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { isolatedHome, toolchainOpencliDir, vendorPeerLink, vendorPluginsDir } from './paths.js';
+import { quoteShellArg } from './shell-text.js';
+
+export const CHANNEL_PLUGIN_NAME = 'opencli-plugin-workbench';
+export const CHANNEL_PLUGIN_SITE = 'workbench';
+
+export interface ChannelPluginPlan {
+  readonly dest: string;
+  readonly version: string;
+  readonly commands: readonly string[];
+  readonly line: string;
+}
+
+function textOf(value: unknown): string {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+export function channelVersionOf(dir: string): string | undefined {
+  try {
+    const parsed: unknown = JSON.parse(readFileSync(join(dir, 'opencli-plugin.json'), 'utf8'));
+    if (typeof parsed !== 'object' || parsed === null) return undefined;
+    const version = textOf((parsed as Record<string, unknown>)['version']);
+    return version === '' ? undefined : version;
+  } catch {
+    return undefined;
+  }
+}
+
+export function channelPluginPlan(options: {
+  readonly channelDir: string;
+  readonly command?: string;
+}): ChannelPluginPlan | undefined {
+  const version = channelVersionOf(options.channelDir);
+  if (version === undefined) return undefined;
+  const command = options.command ?? 'opencli';
+  const dest = join(vendorPluginsDir(), CHANNEL_PLUGIN_NAME);
+  const peer = vendorPeerLink();
+  const commands = [
+    `rm -rf ${quoteShellArg(dest)} && mkdir -p ${quoteShellArg(dest)} && cp -R ${quoteShellArg(options.channelDir)}/. ${quoteShellArg(dest)}/`,
+    `rm -rf ${quoteShellArg(peer.dir)} && mkdir -p ${quoteShellArg(peer.parent)} && ln -s ${quoteShellArg(toolchainOpencliDir())} ${quoteShellArg(peer.dir)}`,
+    `(${quoteShellArg(command)} plugin uninstall ${quoteShellArg(CHANNEL_PLUGIN_SITE)} || true)`,
+    `${quoteShellArg(command)} plugin install ${quoteShellArg(dest)}`,
+  ];
+  return { dest, version, commands, line: commands.join(' && ') };
+}
+
+export function channelInstalledVersion(): string | undefined {
+  return channelVersionOf(join(vendorPluginsDir(), CHANNEL_PLUGIN_NAME));
+}
+
+export function channelSiteInstalled(): boolean {
+  return existsSync(join(isolatedHome(), '.opencli', 'plugins', CHANNEL_PLUGIN_SITE));
+}

package/src/host/cli.ts

@@ -0,0 +1,11 @@
+import type { DshHostContext } from '../api/dsh.js';
+import type { CliPort } from '../contract/cli.js';
+import { adaptersOf } from './adapters.js';
+
+export function cliPortOf(ctx: DshHostContext): CliPort {
+  return { command: adaptersOf(ctx).runtime.opencliCommand(ctx).command };
+}
+
+export function cliCommandOf(ctx: DshHostContext): string {
+  return cliPortOf(ctx).command;
+}

package/src/host/command-name.ts

@@ -0,0 +1,15 @@
+function baseName(value: string): string {
+  const parts = value.trim().split(/[\\/]/);
+  return parts[parts.length - 1] ?? '';
+}
+
+function isOpencli(name: string): boolean {
+  return name === 'opencli' || name === 'opencli.cmd' || name === 'opencli.exe';
+}
+
+export function commandNamesMatch(declared: string, resolved: string): boolean {
+  const left = baseName(declared);
+  const right = baseName(resolved);
+  if (left === '' || right === '') return false;
+  return left === right || (isOpencli(left) && isOpencli(right));
+}

package/src/host/data-error.ts

@@ -0,0 +1,21 @@
+export class WorkbenchDataError extends Error {
+  readonly code: string;
+  readonly detail?: string;
+  readonly hint?: string;
+  readonly project?: unknown;
+  readonly helpUrl?: string;
+
+  constructor(
+    code: string,
+    message: string,
+    extra: { detail?: string; hint?: string; project?: unknown; helpUrl?: string } = {},
+  ) {
+    super(message);
+    this.name = 'WorkbenchDataError';
+    this.code = code;
+    if (extra.detail !== undefined) this.detail = extra.detail;
+    if (extra.hint !== undefined) this.hint = extra.hint;
+    if (extra.project !== undefined) this.project = extra.project;
+    if (extra.helpUrl !== undefined) this.helpUrl = extra.helpUrl;
+  }
+}

package/src/host/data-root.ts

@@ -5,6 +5,8 @@ export function dshHome(): string {
 }
 
 export function workbenchRoot(): string {
+  const configured = process.env.DSH_WORKBENCH_HOME?.trim();
+  if (configured !== undefined && configured !== '') return configured;
   return `${dshHome()}/workbench`;
 }
 

package/src/host/diy-debug.ts

@@ -1,3 +1,4 @@
+import { clockOf } from './time.js';
 /**
  * 调试约定的两个相位：`debugging` 正占着用户的屏，`paused` 已暂停但仍持着约定。
  */
@@ -156,5 +157,5 @@ export function createDebugStore(): DebugStore {
  * @returns 形如「会话 x（自 HH:mm:ssZ 起在调试 y）」的中文串。
  */
 export function debugOwnerText(state: DebugState): string {
-  return `会话 ${state.sessionId}（自 ${new Date(state.startedAt).toISOString().slice(11, 19)}Z 起在调试 ${state.unit}）`;
+  return `会话 ${state.sessionId}（自 ${clockOf(state.startedAt)}Z 起在调试 ${state.unit}）`;
 }

package/src/host/diy-record.ts

@@ -1,3 +1,4 @@
+import { clockOf } from './time.js';
 /**
  * 录制交接的三个相位：`armed` 等用户在外站页面上动手，`recording` 正在录，`finished` 录完待取。
  */
@@ -274,6 +275,6 @@ export function createRecordStore(): RecordStore {
  * @returns 形如「会话 x（自 HH:mm:ssZ 起在录 y 的「动作」）」的中文串。
  */
 export function recordOwnerText(state: RecordState): string {
-  const at = new Date(state.startedAt).toISOString().slice(11, 19);
+  const at = clockOf(state.startedAt);
   return `会话 ${state.sessionId}（自 ${at}Z 起在录 ${state.unit} 的「${state.action}」）`;
 }

package/src/host/facts.ts

@@ -1,5 +1,6 @@
-import type { UnitManifest } from '../api/unit.js';
-import { FACT_SCOPE_SUFFIX } from '../api/facts.js';
+import { randomUUID } from 'node:crypto';
+import type { UnitManifest } from '../contract/unit.js';
+import { FACT_SCOPE_SUFFIX } from '../contract/facts.js';
 
 export interface FactChange {
   readonly rev: number;
@@ -19,7 +20,7 @@ export interface FactLog {
 }
 
 export function createFactLog(options: { readonly epoch?: string } = {}): FactLog {
-  const epoch = options.epoch ?? `e${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`;
+  const epoch = options.epoch ?? `e${randomUUID()}`;
   let rev = 0;
   const last = new Map<string, number>();
   const listeners = new Set<(change: FactChange) => void>();

package/src/host/git.ts

@@ -1,6 +1,6 @@
 import type { DshShell } from '../api/dsh.js';
-import { quoteShellArg, tailLines } from './shell-text.js';
-import { runShell } from './shell.js';
+import { quoteShellArg, tailLines } from '../host/shell-text.js';
+import { runShell } from '../host/shell.js';
 
 export type OriginRead =
   | { readonly kind: 'ok'; readonly remote: string }

package/src/host/http.ts

@@ -7,7 +7,7 @@ import {
   type ProvisionHandler,
   type ProvisionRequest,
 } from './provision.js';
-import { WorkbenchDataError } from '../host/opencli.js';
+import { WorkbenchDataError } from './data-error.js';
 import { writeResultForClient } from './write-result.js';
 
 export type RouteHandler = (search: URLSearchParams) => Promise<unknown> | unknown;

package/src/host/lib-capabilities.ts

@@ -0,0 +1,52 @@
+/**
+ * 跨平台库的「能力 → 首选实现」表：外壳 arch 的 S68 与 DIY 模块的 `source` 判据共用这一份，
+ * 避免两边各写一张表后漂开。
+ *
+ * 能力名是「做什么」，`preferred` 是「用什么」；两者不是同一个层级（类似 datetime → dayjs）。
+ * 手写轮子的指纹只认最常见的直连写法；`importsPreferred()` 负责判断这个文件是否已经在用首选库。
+ */
+export interface LibCapability {
+  readonly capability: string;
+  readonly preferred: string;
+  readonly pattern: RegExp;
+  readonly why: string;
+}
+
+/** 手写轮子的硬指纹；按能力名稳定排序，方便两边报告与测试对照。 */
+export const LIB_CAPABILITIES: readonly LibCapability[] = [
+  {
+    capability: 'process-spawn',
+    preferred: 'execa',
+    pattern: /from\s+['"]node:child_process['"]/,
+    why: '自己起进程要用 execa；同步/跨平台差异交给它',
+  },
+  {
+    capability: 'cli-locate',
+    preferred: 'which',
+    pattern: /\bprocess\.env\.(?:PATH|PATHEXT)\b/,
+    why: '自己扫 PATH/PATHEXT 要用 which（它处理 PATHEXT 与 Path 大小写）',
+  },
+  {
+    capability: 'file-lock',
+    preferred: 'proper-lockfile',
+    pattern: /\bprocess\.kill\([^)]*,\s*0\)|flag:\s*['"]wx['"]/,
+    why: '自己抢文件锁要用 proper-lockfile（stale / 重试 / 跨平台）',
+  },
+  {
+    capability: 'atomic-state',
+    preferred: 'write-file-atomic',
+    pattern: /writeFileSync\([^)]*\.(?:sync\.json|self-update\.json)/,
+    why: '自己直写状态文件要用 write-file-atomic（防写一半）',
+  },
+];
+
+/**
+ * 这个文件是否已经 import 了某个首选库（静态或动态 import 都算）。
+ * @param source 文件全文。
+ * @param preferred 首选库包名。
+ * @returns 有 import 就 `true`。
+ */
+export function importsPreferred(source: string, preferred: string): boolean {
+  const escaped = preferred.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return new RegExp(`(?:from\\s*|import\\s*\\(\\s*)['"]${escaped}['"]`).test(source);
+}

package/src/host/lib-install.ts

@@ -0,0 +1,18 @@
+import type { LibNeed, SupplySource } from '../contract/needs.js';
+import { npmRegistryOf } from './plugin-source.js';
+import { quoteShellArg } from './shell-text.js';
+import { libsPrefix, npmCacheDir } from './paths.js';
+
+export type NpmSource = Extract<SupplySource, { kind: 'npm' }>;
+
+export function libInstallCommand(options: {
+  readonly need: LibNeed;
+  readonly source: NpmSource;
+  readonly version?: string | undefined;
+}): string {
+  const { need, source, version } = options;
+  const registry = npmRegistryOf(source, process.env);
+  const spec = version ?? need.version ?? 'latest';
+  const registryFlag = registry.ok ? ` --registry ${quoteShellArg(registry.value)}` : '';
+  return `npm i --prefix ${quoteShellArg(libsPrefix())} ${quoteShellArg(`${need.name}@${spec}`)}${registryFlag} --cache ${quoteShellArg(npmCacheDir())}`;
+}

package/src/host/long-task.ts

@@ -1,4 +1,5 @@
-import { runsRouteOf, type LongTaskStatus, type LongTaskStep } from '../api/long-task.js';
+import { epochOf } from './time.js';
+import { runsRouteOf, type LongTaskStatus, type LongTaskStep } from '../contract/long-task.js';
 
 const LIVE: ReadonlySet<string> = new Set<LongTaskStatus>(['running', 'needs-login']);
 
@@ -104,7 +105,7 @@ export function createLongTaskRegistry<S extends LongTaskBase>(deps: LongTaskDep
     },
 
     current(workspace) {
-      const floor = Date.parse(now()) - recentMs;
+      const floor = epochOf(now()) - recentMs;
       const newest = new Map<string, LongTaskBase>();
       for (const snapshot of runs.values()) {
         if (snapshot.workspace !== workspace) continue;
@@ -112,7 +113,7 @@ export function createLongTaskRegistry<S extends LongTaskBase>(deps: LongTaskDep
       }
       return [...newest.values()]
         .filter(
-          (snapshot) => LIVE.has(snapshot.status) || Date.parse(snapshot.at) >= floor,
+          (snapshot) => LIVE.has(snapshot.status) || epochOf(snapshot.at) >= floor,
         )
         .reverse()
         .map((snapshot) => ({ ...deps.view(snapshot as S), id: snapshot.id }));