Merge remote-tracking branch 'origin/master' into worktree/default-pi-ai-providers

# Conflicts:
#	apps/cli/README.i18n.yaml

apps/cli/README.i18n.yaml

@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write apps/cli/README.md
-README.md: 902db2681571aa291bab88ed05f886d07dbf9543
-README.zh.md: 4105a62058201520f2fc1017fe047966f493b0d3
+README.md: 6b3a31a30a941e67341a518a7e32b1bf99eee8b0
+README.zh.md: 133c721612012b8fd1327344ae4e2951d05047cb

apps/cli/README.md

@@ -4,7 +4,7 @@ English | [中文](README.zh.md)
 
 The `dsh` command-line entry follows the `apps/` assembly tier: `apps/*` are product assemblies over `packages/*` libraries. Plain `dsh` boots the interactive TUI coding agent, `dsh -p "task"` runs one headless turn, and `dsh web` serves the browser UI.
 
-Argv is parsed once through a [Commander](https://github.com/tj/commander.js) adapter ([`src/args.ts`](src/args.ts)): one program whose default (no subcommand) is the TUI/headless surface (`--config`, `-p`/`--prompt`, `--resume`) and whose `web` subcommand is the browser UI. `src/bin.ts` switches on the resolved mode and dynamic-imports only that mode's module. `dsh --help` lists every mode and `dsh web --help` renders the web usage, `dsh --version` prints this app's version, and an unknown option or a mistyped `--resume` fails loud (stderr, exit 1) instead of misrouting. `dsh web`'s `--host`/`--port` are unvalidated pass-through overrides: the `dsh-host-webserver` schema is the single source of both the default (the shipped `cordis.yml` value when a flag is absent) and validity, and rejects a bad value at boot.
+Argv is parsed once through a [Commander](https://github.com/tj/commander.js) adapter ([`src/args.ts`](src/args.ts)): one program whose default (no subcommand) is the TUI/headless surface (`--config`, `-p`/`--prompt`, `--resume`) and whose `web` subcommand is the browser UI. `src/bin.ts` switches on the resolved mode and dynamic-imports only that mode's module. `dsh --help` lists every mode and `dsh web --help` renders the web usage, `dsh --version` prints this app's version, and an unknown option or a mistyped `--resume` fails loud (stderr, exit 1) instead of misrouting. `dsh web`'s `--host`/`--port` are unvalidated pass-through overrides: the `dsh-host-webserver` schema is the single source of both the default (the shipped `cordis.yml` value when a flag is absent) and validity, and rejects a bad value at boot. `--trusted-host` appends named authorities for the /api browser-trust fence; an all-interfaces bind additionally derives the machine's LAN IP literals itself ([`src/app-cli-entry.ts`](src/app-cli-entry.ts)), so the printed LAN URL works without flags.
 
 The TUI surface:
 
@@ -28,4 +28,6 @@ Symlink the source-running launcher onto your PATH; it resolves the checkout thr
 ln -sf "$(pwd)/bin/dsh" ~/.local/bin/dsh
 ```
 
+Source launches run `apps/cli/src/bin.ts` through Node's `--experimental-transform-types`; `scripts/tspath-loader.ts` only projects tsconfig `paths` into module resolution and does not transform code. Every module reachable from the CLI source entry follows Node's transform-types contract: erased bindings use `import type`, exports use native ESM, and the graph contains no TSX/JSX or transforms that only tsx/esbuild provides. The loader reads `TSX_TSCONFIG_PATH` when set (relative paths resolve from the invoking cwd), otherwise the repository's root tsconfig, using the root TypeScript development tool rather than an application dependency. It maps a workspace import only for a package self-reference or a declared runtime dependency. The TUI configs resolve bare plugins through `examples/package.json`, while the Web/headless `cordis.yml` resolves them through this package's `dependencies`; `verify-cordis-config` requires every configured bare plugin to be declared, while allowing unrelated dependencies.
+
 `pnpm run dsh` runs the same entry from the repo root and forwards arguments directly, for example `pnpm run dsh -p "task"`. The built form (`lib/bin.js`, via `pnpm run build`) boots the same config under plain Node.

apps/cli/README.zh.md

@@ -4,7 +4,7 @@
 
 `dsh` 命令行入口遵循 `apps/` 组装层：`apps/*` 是位于 `packages/*` 库之上的产品组装。直接运行 `dsh` 会启动交互式 TUI 编码 agent（智能体），`dsh -p "task"` 运行一个无头轮次，`dsh web` 则提供浏览器 UI。
 
-Argv 只会通过 [Commander](https://github.com/tj/commander.js) 适配器（[`src/args.ts`](src/args.ts)）解析一次：同一个程序的默认形式（无子命令）是 TUI／无头界面（`--config`、`-p`/`--prompt`、`--resume`），`web` 子命令则是浏览器 UI。`src/bin.ts` 按解析后的 mode 分支，仅动态导入该 mode 的模块。`dsh --help` 列出所有 mode，`dsh web --help` 渲染 Web 用法，`dsh --version` 打印此应用的版本；未知选项或拼错的 `--resume` 会明确报错（stderr，退出码 1），而不会被错路由。`dsh web` 的 `--host`/`--port` 是未验证的直通覆盖：`dsh-host-webserver` schema 是默认值（标志缺失时使用已交付的 `cordis.yml` 值）和有效性的唯一真源，并在启动时拒绝错误值。
+Argv 只会通过 [Commander](https://github.com/tj/commander.js) 适配器（[`src/args.ts`](src/args.ts)）解析一次：同一个程序的默认形式（无子命令）是 TUI／无头界面（`--config`、`-p`/`--prompt`、`--resume`），`web` 子命令则是浏览器 UI。`src/bin.ts` 按解析后的 mode 分支，仅动态导入该 mode 的模块。`dsh --help` 列出所有 mode，`dsh web --help` 渲染 Web 用法，`dsh --version` 打印此应用的版本；未知选项或拼错的 `--resume` 会明确报错（stderr，退出码 1），而不会被错路由。`dsh web` 的 `--host`/`--port` 是未验证的直通覆盖：`dsh-host-webserver` schema 是默认值（标志缺失时使用已交付的 `cordis.yml` 值）和有效性的唯一真源，并在启动时拒绝错误值。`--trusted-host` 为 /api 浏览器信任栅栏追加具名权威；全接口绑定还会自行推导本机的 LAN IP 字面量（[`src/app-cli-entry.ts`](src/app-cli-entry.ts)），因此打印出的 LAN URL 无需任何标志即可使用。
 
 TUI 界面：
 
@@ -28,4 +28,6 @@ Web 和无头界面启动同一个共享组合（`cordis.yml`）：两者都将
 ln -sf "$(pwd)/bin/dsh" ~/.local/bin/dsh
 ```
 
+源码启动会通过 Node 的 `--experimental-transform-types` 运行 `apps/cli/src/bin.ts`；`scripts/tspath-loader.ts` 只会将 tsconfig 的 `paths` 映射投射到模块解析中，而不会转换代码。从 CLI 源码入口可达的每个模块都遵守 Node transform-types 契约：会被擦除的绑定使用 `import type`，export 使用原生 ESM，整个依赖图不含 TSX/JSX，也不依赖仅由 tsx/esbuild 提供的转换。设置 `TSX_TSCONFIG_PATH` 时，loader 会读取该路径（相对路径从调用方的 cwd 解析），否则读取仓库根 tsconfig；它使用根目录的 TypeScript 开发工具，而不是应用依赖。仅当 workspace import 是包自身引用或已声明的运行时依赖时，loader 才会映射该 import。TUI 配置通过 `examples/package.json` 解析裸插件，而 Web／无头 `cordis.yml` 则通过本包的 `dependencies` 解析；`verify-cordis-config` 要求每个已配置的裸插件均已声明，同时允许存在无关依赖。
+
 `pnpm run dsh` 从仓库根目录运行同一入口并直接转发参数，例如 `pnpm run dsh -p "task"`。构建形式（`lib/bin.js`，通过 `pnpm run build`）会在普通 Node 下启动同一配置。

apps/cli/cordis.yml

@@ -188,6 +188,18 @@
 - id: commands
   name: '@deepseek-ai/dsh-commands'
 
+# Goal service + automatic same-session continuation + the /goal command.
+# The GoalService registers the 'goal' session projection unit; the web
+# GoalBar reads it through useProjection.
+- id: goal
+  name: '@deepseek-ai/dsh-goal'
+
+- id: goal-session
+  name: '@deepseek-ai/dsh-goal-session'
+
+- id: command-goal
+  name: '@deepseek-ai/dsh-command-goal'
+
 # Plan mode registers /plan (the first real command on the web surface).
 # Section text mirrors examples/tui-agent/cordis.yml (the reference
 # deployment); plan-mode throws at load on an empty section.
@@ -263,6 +275,13 @@
 # The API gateway: the transport-agnostic dispatch face every client shape
 # shares. provider/model are the host default routing — the profile json's
 # mapping target (user config overrides these engineering defaults).
+# Directory-picking package, dual-face: the node half serves the gateway's
+# host.* picker RPCs, the browser half fills ui-workspace's directory-flow
+# slots — one row composes the whole interaction. Swap point: mount
+# '-native' instead for the host-display OS chooser.
+- id: directory-picker
+  name: '@deepseek-ai/dsh-host-directory-picker-browse'
+
 - id: api-gateway
   name: '@deepseek-ai/dsh-host-apiproxy'
   config:
@@ -339,10 +358,18 @@
 - id: ui-subagent
   name: '@deepseek-ai/dsh-client-ui-subagent'
 
+# Goal surface: GoalBar in the input dock over the goal session projection.
+- id: ui-goal
+  name: '@deepseek-ai/dsh-client-ui-goal'
+
 # Model selection: the /model popupSelect + composer seat over session.models.
 - id: ui-model
   name: '@deepseek-ai/dsh-client-ui-model'
 
+# Plan control: the composer plan seat over the plan projection + /plan channel.
+- id: ui-plan
+  name: '@deepseek-ai/dsh-client-ui-plan'
+
 - id: ui-question
   name: '@deepseek-ai/dsh-client-ui-question'
 

apps/cli/package.json

@@ -28,9 +28,11 @@
     "@deepseek-ai/dsh-client-runtime": "workspace:^",
     "@deepseek-ai/dsh-client-ui-command": "workspace:^",
     "@deepseek-ai/dsh-client-ui-conversation": "workspace:^",
+    "@deepseek-ai/dsh-client-ui-goal": "workspace:^",
     "@deepseek-ai/dsh-client-ui-layout": "workspace:^",
     "@deepseek-ai/dsh-client-ui-model": "workspace:^",
     "@deepseek-ai/dsh-client-ui-models": "workspace:^",
+    "@deepseek-ai/dsh-client-ui-plan": "workspace:^",
     "@deepseek-ai/dsh-client-ui-question": "workspace:^",
     "@deepseek-ai/dsh-client-ui-settings": "workspace:^",
     "@deepseek-ai/dsh-client-ui-settings-general": "workspace:^",
@@ -42,12 +44,17 @@
     "@deepseek-ai/dsh-client-ui-trajectory": "workspace:^",
     "@deepseek-ai/dsh-client-ui-workspace": "workspace:^",
     "@deepseek-ai/dsh-code-runtime-worker": "workspace:^",
+    "@deepseek-ai/dsh-command-goal": "workspace:^",
     "@deepseek-ai/dsh-commands": "workspace:^",
     "@deepseek-ai/dsh-compact-basic": "workspace:^",
     "@deepseek-ai/dsh-frontend": "workspace:^",
     "@deepseek-ai/dsh-fs-local": "workspace:^",
     "@deepseek-ai/dsh-fs-policy": "workspace:^",
+    "@deepseek-ai/dsh-goal": "workspace:^",
+    "@deepseek-ai/dsh-goal-session": "workspace:^",
     "@deepseek-ai/dsh-host-apiproxy": "workspace:^",
+    "@deepseek-ai/dsh-host-directory-picker-browse": "workspace:^",
+    "@deepseek-ai/dsh-host-directory-picker-native": "workspace:^",
     "@deepseek-ai/dsh-host-webserver": "workspace:^",
     "@deepseek-ai/dsh-llm": "workspace:^",
     "@deepseek-ai/dsh-llm-deepseek": "workspace:^",

apps/cli/src/app-cli-entry.ts

@@ -9,6 +9,7 @@
 
 import { readFileSync } from 'node:fs'
 import { createRequire } from 'node:module'
+import { networkInterfaces } from 'node:os'
 import { join, resolve } from 'node:path'
 import { pathToFileURL } from 'node:url'
 import { Context } from 'cordis'
@@ -25,6 +26,41 @@ import type {} from '@deepseek-ai/dsh-host-webserver'
 const PROFILE_DIR = '.dsh-tmp-profile'
 const PROFILE_FILE = 'config.json'
 
+/** The webserver schema's all-interfaces bind literal: gates LAN-authority derivation here and the printed LAN URL in web.ts. */
+const ALL_INTERFACES_HOST = '0.0.0.0'
+
+/**
+ * Non-internal IPv4 interface addresses of this machine — the IP-literal
+ * authorities an all-interfaces bind is reachable by on the LAN.
+ * @returns the addresses in interface order (possibly empty).
+ */
+function lanIPv4Addresses(): string[] {
+  return Object.values(networkInterfaces()).flat()
+    .filter((iface): iface is NonNullable<typeof iface> => iface !== undefined && iface.family === 'IPv4' && !iface.internal)
+    .map(iface => iface.address)
+}
+
+/**
+ * One LAN-trust resolution for one invocation, sampled exactly once: the
+ * machine's LAN IP literals when the effective bind is all-interfaces, and
+ * the `trustedHosts` value built from them plus the explicit extras. The
+ * single sample is deliberate — display must advertise only addresses the
+ * fence was configured with, so both read this snapshot. Derived entries are
+ * port-less IP literals: DNS rebinding needs an attacker-controlled name, so
+ * an IP-literal Host is safe on any port, and the bound port may be
+ * OS-assigned, unknowable pre-boot.
+ * @param bindHost - the effective webserver bind host (CLI flag, else the yml default).
+ * @param extra - `--trusted-host` values, in argv order.
+ * @returns the sampled LAN addresses and the connection row's `trustedHosts` value (each possibly empty).
+ */
+export function resolveLanTrust(
+  bindHost: string | undefined,
+  extra: readonly string[],
+): { lanAddresses: string[]; trustedHosts: string[] } {
+  const lanAddresses = bindHost === ALL_INTERFACES_HOST ? lanIPv4Addresses() : []
+  return { lanAddresses, trustedHosts: [...lanAddresses, ...extra] }
+}
+
 /** One profile-json key mapped onto a yml row's config field. */
 interface ProfileMapping {
   jsonPath: string
@@ -79,6 +115,8 @@ export interface AppCLIEntryOptions {
   port?: number
   /** Parent directory for name-created Workspaces; undefined uses the gateway's cwd fallback. */
   workspaceRoot?: string
+  /** Extra authorities for the /api browser-trust fence (`host` or `host:port`), appended to the derived LAN IP literals. */
+  trustedHosts?: string[]
 }
 
 /**
@@ -91,6 +129,14 @@ export class AppCLIEntry {
   /** The root context, set by {@link run}. */
   ctx!: Context
 
+  /**
+   * LAN IPv4 addresses sampled once at patch composition — the exact snapshot
+   * the /api trust fence was configured with. Display reads this instead of
+   * re-sampling, so the advertised LAN URL can never name an address the
+   * fence rejects. Empty unless the effective bind is all-interfaces.
+   */
+  lanAddresses: readonly string[] = []
+
   private patches: PatchOptions[] = []
 
   constructor(private readonly options: AppCLIEntryOptions) {}
@@ -152,6 +198,13 @@ export class AppCLIEntry {
     if (this.options.port !== undefined) put('webserver', 'port', this.options.port)
     if (this.options.workspaceRoot !== undefined) put('api-gateway', 'workspaceRoot', this.options.workspaceRoot)
 
+    // Source 2b: authorities for the /api browser-trust fence (rationale on
+    // resolveLanTrust).
+    const ymlHost = (rows.get('webserver')?.config as { host?: string } | undefined)?.host
+    const { lanAddresses, trustedHosts } = resolveLanTrust(this.options.host ?? ymlHost, this.options.trustedHosts ?? [])
+    this.lanAddresses = lanAddresses
+    if (trustedHosts.length > 0) put('connection', 'trustedHosts', trustedHosts)
+
     // Source 3: the frontend dist — an assembly fact of this app, never yml
     // user config. Workspace knowledge stays here.
     put('webserver', 'distIndex', this.resolveDistIndex())

apps/cli/src/args.ts

@@ -40,6 +40,8 @@ interface WebInvocation {
   port?: number
   dev: boolean
   workspaceRoot?: string
+  /** Extra authorities for the /api browser-trust fence (`host` or `host:port`); LAN IP literals are derived, not listed here. */
+  trustedHosts?: string[]
 }
 
 /** The resolved `dsh` invocation: exactly one mode. `--help`/`--version`/errors exit inside {@link parseDshArgs}. */
@@ -51,6 +53,7 @@ interface WebOptions {
   port?: string
   dev?: boolean
   workspaceRoot?: string
+  trustedHost?: string[]
 }
 
 /**
@@ -66,6 +69,7 @@ function resolveWeb(options: WebOptions): WebInvocation {
     ...options.port !== undefined && { port: Number(options.port) },
     dev: options.dev === true,
     ...options.workspaceRoot !== undefined && { workspaceRoot: options.workspaceRoot },
+    ...options.trustedHost !== undefined && { trustedHosts: options.trustedHost },
   }
 }
 
@@ -117,6 +121,7 @@ export function parseDshArgs(argv: readonly string[], version: string): DshInvoc
     .option('--port <port>', 'override the config listen port (0 requests an OS-assigned port)')
     .option('--dev', 'mount the client HMR driver and watch plugin bundles for rebuilds')
     .option('--workspace-root <path>', 'parent directory for name-created workspaces')
+    .option('--trusted-host <authority...>', 'extra authority the /api browser-trust fence accepts (host or host:port; repeatable)')
     .action((options: WebOptions) => {
       // Commander parses the parent (default-surface) options on either side of
       // the subcommand into `program.opts()`. `web` shares none of them, so a

apps/cli/src/bin.ts

@@ -30,7 +30,7 @@ const invocation = parseDshArgs(process.argv.slice(2), readVersion())
 switch (invocation.mode) {
   case 'web': {
     const { runWeb } = await import('./web.ts')
-    await runWeb(invocation.host, invocation.port, invocation.dev, invocation.workspaceRoot)
+    await runWeb(invocation.host, invocation.port, invocation.dev, invocation.workspaceRoot, invocation.trustedHosts)
     break
   }
   case 'headless': {

apps/cli/src/tsconfig-paths-loader.ts

@@ -0,0 +1,216 @@
+/**
+ * Node module resolve hook for the `dsh` source launcher. It projects the root
+ * tsconfig `paths` map into Node resolution while leaving all TypeScript syntax
+ * handling to Node's native transform-types runtime.
+ * @module @deepseek-ai/dsh/tsconfig-paths-loader
+ */
+
+import { readFile, stat } from 'node:fs/promises'
+import { dirname, extname, join, resolve } from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+import type { ResolveHookContext, ResolveFnOutput } from 'node:module'
+import ts from 'typescript'
+
+interface LoaderData {
+  tsconfigPath: string
+}
+
+interface PackageManifest {
+  name?: string
+  dependencies?: Record<string, string>
+  optionalDependencies?: Record<string, string>
+  peerDependencies?: Record<string, string>
+}
+
+interface PathRule {
+  pattern: string
+  prefix: string
+  suffix: string
+  targets: readonly string[]
+}
+
+interface PathsCompilerOptions {
+  readonly baseUrl?: string
+  readonly paths?: ts.MapLike<string[]>
+  readonly pathsBasePath?: string
+}
+
+// Node's native TypeScript transform cannot parse JSX, so `.tsx` is excluded.
+const SOURCE_EXTENSIONS = ['.ts', '.mts', '.cts'] as const
+
+/**
+ * Resolve package imports through one parsed tsconfig paths table.
+ *
+ * Manifest reads are process-scoped and memoized by path. Only matched source
+ * aliases enter the cache, bounding it to directories participating in source
+ * resolution.
+ */
+export class TsconfigPathsResolver {
+  private readonly rules: readonly PathRule[]
+  private readonly configDirectory: string
+  private readonly manifests = new Map<string, Promise<PackageManifest | undefined>>()
+
+  private constructor(configDirectory: string, paths: ts.MapLike<string[]>) {
+    this.configDirectory = configDirectory
+    this.rules = Object.entries(paths)
+      .map(([pattern, targets]) => {
+        const wildcard = pattern.indexOf('*')
+        return {
+          pattern,
+          prefix: wildcard === -1 ? pattern : pattern.slice(0, wildcard),
+          suffix: wildcard === -1 ? '' : pattern.slice(wildcard + 1),
+          targets,
+        }
+      })
+      .sort((left, right) => {
+        const leftExact = left.pattern.includes('*') ? 0 : 1
+        const rightExact = right.pattern.includes('*') ? 0 : 1
+        return rightExact - leftExact || right.prefix.length - left.prefix.length || right.suffix.length - left.suffix.length
+      })
+  }
+
+  /**
+   * Parse a tsconfig including its `extends` chain.
+   * @param tsconfigPath Absolute tsconfig path supplying `compilerOptions.paths`.
+   * @returns A resolver backed by that path table.
+   */
+  static create(tsconfigPath: string): TsconfigPathsResolver {
+    let unrecoverable: ts.Diagnostic | undefined
+    const parsed = ts.getParsedCommandLineOfConfigFile(tsconfigPath, {}, {
+      ...ts.sys,
+      onUnRecoverableConfigFileDiagnostic(diagnostic) { unrecoverable = diagnostic },
+    })
+    if (parsed === undefined) {
+      const detail = unrecoverable === undefined
+        ? 'unknown configuration error'
+        : ts.flattenDiagnosticMessageText(unrecoverable.messageText, '\n')
+      throw new Error(`dsh source loader could not parse ${tsconfigPath}: ${detail}`)
+    }
+    const options = parsed.options as PathsCompilerOptions
+    const paths = options.paths
+    if (paths === undefined) throw new Error(`dsh source loader requires compilerOptions.paths in ${tsconfigPath}`)
+    const configDirectory = options.baseUrl ?? options.pathsBasePath ?? dirname(tsconfigPath)
+    return new TsconfigPathsResolver(configDirectory, paths)
+  }
+
+  /**
+   * Resolve one bare package specifier to a source file when the importing
+   * package (or config-directory owner) declares that package at runtime.
+   * @param specifier Module specifier passed to Node.
+   * @param parentURL Importing file or Loader config-directory URL.
+   * @returns Source file URL, or `undefined` when normal Node resolution owns the request.
+   */
+  async resolve(specifier: string, parentURL: string | undefined): Promise<string | undefined> {
+    const packageName = packageNameFromSpecifier(specifier)
+    if (packageName === undefined || parentURL === undefined || !parentURL.startsWith('file:')) return undefined
+    const matched = this.match(specifier)
+    if (matched === undefined) return undefined
+    const configParent = parentURL.endsWith('/')
+    const parentPath = fileURLToPath(parentURL)
+    const startDirectory = configParent ? parentPath : dirname(parentPath)
+    if (!await this.isDeclaredRuntimeDependency(startDirectory, packageName, configParent)) return undefined
+
+    for (const target of matched.targets) {
+      const substituted = target.replace('*', matched.wildcard)
+      const candidate = await existingSourcePath(resolve(this.configDirectory, substituted))
+      if (candidate !== undefined) return pathToFileURL(candidate).href
+    }
+    return undefined
+  }
+
+  private match(specifier: string): { targets: readonly string[]; wildcard: string } | undefined {
+    for (const rule of this.rules) {
+      if (!rule.pattern.includes('*')) {
+        if (specifier === rule.pattern) return { targets: rule.targets, wildcard: '' }
+        continue
+      }
+      if (!specifier.startsWith(rule.prefix) || !specifier.endsWith(rule.suffix)) continue
+      const wildcard = specifier.slice(rule.prefix.length, specifier.length - rule.suffix.length)
+      return { targets: rule.targets, wildcard }
+    }
+    return undefined
+  }
+
+  private async isDeclaredRuntimeDependency(
+    startDirectory: string,
+    packageName: string,
+    searchAncestors: boolean,
+  ): Promise<boolean> {
+    for (let directory = startDirectory; ; directory = dirname(directory)) {
+      const manifest = await this.readManifest(join(directory, 'package.json'))
+      if (manifest !== undefined) {
+        if (declaresRuntimeDependency(manifest, packageName)) return true
+        if (!searchAncestors) return false
+      }
+      const parent = dirname(directory)
+      if (parent === directory) return false
+    }
+  }
+
+  private readManifest(path: string): Promise<PackageManifest | undefined> {
+    let pending = this.manifests.get(path)
+    if (pending !== undefined) return pending
+    pending = readFile(path, 'utf8').then(
+      content => JSON.parse(content) as PackageManifest,
+      (error: unknown) => {
+        if (error instanceof Error && (error as NodeJS.ErrnoException).code === 'ENOENT') return undefined
+        throw error
+      },
+    )
+    this.manifests.set(path, pending)
+    return pending
+  }
+}
+
+let resolver: TsconfigPathsResolver | undefined
+
+/** Initialize the hook worker from the source-launch preloader. */
+export function initialize(data: LoaderData): void {
+  resolver = TsconfigPathsResolver.create(data.tsconfigPath)
+}
+
+/** Resolve declared workspace packages to source and delegate every other request to Node. */
+export async function resolveHook(
+  specifier: string,
+  context: ResolveHookContext,
+  nextResolve: (specifier: string, context: ResolveHookContext) => Promise<ResolveFnOutput>,
+): Promise<ResolveFnOutput> {
+  const url = await resolver?.resolve(specifier, context.parentURL)
+  return url === undefined ? nextResolve(specifier, context) : { url, shortCircuit: true }
+}
+
+// Node customization hooks discover this exact export name.
+export { resolveHook as resolve }
+
+function packageNameFromSpecifier(specifier: string): string | undefined {
+  if (specifier.startsWith('.') || specifier.startsWith('/') || /^[a-z][a-z+.-]*:/i.test(specifier)) {
+    return undefined
+  }
+  const segments = specifier.split('/')
+  return specifier.startsWith('@')
+    ? segments.length >= 2 ? `${segments[0]}/${segments[1]}` : undefined
+    : segments[0] || undefined
+}
+
+function declaresRuntimeDependency(manifest: PackageManifest, packageName: string): boolean {
+  return manifest.name === packageName
+    || packageName in (manifest.dependencies ?? {})
+    || packageName in (manifest.optionalDependencies ?? {})
+    || packageName in (manifest.peerDependencies ?? {})
+}
+
+async function existingSourcePath(base: string): Promise<string | undefined> {
+  const extension = extname(base)
+  if (extension === '.tsx') return undefined
+  const candidates = extension === ''
+    ? [base, ...SOURCE_EXTENSIONS.map(extension => `${base}${extension}`), ...SOURCE_EXTENSIONS.map(extension => join(base, `index${extension}`))]
+    : [base]
+  for (const candidate of candidates) {
+    try {
+      if ((await stat(candidate)).isFile()) return candidate
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error
+    }
+  }
+  return undefined
+}

apps/cli/src/tui.ts

@@ -24,7 +24,10 @@ import {
 } from '@deepseek-ai/dsh-app-boot'
 import { resolveDshHome } from '@deepseek-ai/dsh-paths'
 import type { Context } from 'cordis'
-import type { TuiResumeHost } from '@deepseek-ai/dsh-tui'
+import {
+  TUI_GOODBYE_MESSAGE_KEY,
+  type TuiResumeHost,
+} from '@deepseek-ai/dsh-tui'
 
 const NAME = 'dsh'
 
@@ -70,8 +73,10 @@ export async function runTui(config: string | undefined, resumeSessionId: string
   const entry = process.argv[1]
   const execve = process.execve?.bind(process)
   const app: { current?: Context } = {}
+  const resumeCommand = (sessionId: string): string =>
+    `${NAME} --resume=${sessionId}${config === undefined ? '' : ` --config ${config}`}`
   const resumeHost: TuiResumeHost | undefined = entry === undefined || execve === undefined ? undefined : {
-    async handoff(sessionId): Promise<never> {
+    async handoff(sessionId, cwd): Promise<never> {
       const current = app.current
       if (current === undefined) throw new Error(`${NAME}: app boot has not completed`)
       // Rebuild argv from the parsed config plus the selected id: TUI mode's
@@ -83,6 +88,11 @@ export async function runTui(config: string | undefined, resumeSessionId: string
         `--resume=${sessionId}`,
         ...config !== undefined ? ['--config', config] : [],
       ]
+      try {
+        process.chdir(cwd)
+      } catch (error) {
+        throw new Error(`${NAME}: cannot resume in "${cwd}": ${String(error)}`)
+      }
       try {
         await current.fiber.dispose()
         execve(process.execPath, nextArgv, process.env)
@@ -101,6 +111,9 @@ export async function runTui(config: string | undefined, resumeSessionId: string
       // Inject the resume id (or undefined) so the shipped config's `!!js`
       // reads it as a bare identifier; then offer the in-place handoff host.
       hostCtx.provide(RESUME_SESSION_ID_KEY, resumeSessionId)
+      if (resumeSessionId !== undefined) {
+        hostCtx.provide(TUI_GOODBYE_MESSAGE_KEY, `To resume this session: ${resumeCommand(resumeSessionId)}`)
+      }
       if (resumeHost !== undefined) hostCtx.provide('tuiResumeHost', resumeHost)
     },
   )

apps/cli/src/web.ts

@@ -6,17 +6,14 @@
  * gates them at boot.
  */
 
-import { networkInterfaces } from 'node:os'
 import { fileURLToPath } from 'node:url'
 import { AppCLIEntry } from './app-cli-entry.ts'
 
 const CONFIG_PATH = fileURLToPath(new URL('../cordis.yml', import.meta.url))
 
-// Display-only mirrors of the webserver schema's allowed hosts: the loopback
-// address the local URL always prints, and the all-interfaces value that gates
-// LAN-address discovery. Not a source of truth — the schema is.
+// Display-only mirror of the webserver schema's loopback host: the address the
+// local URL always prints. Not a source of truth — the schema is.
 const LOOPBACK_HOST = '127.0.0.1'
-const ALL_INTERFACES_HOST = '0.0.0.0'
 
 /**
  * Serve the browser UI from the shipped config tree. `host`/`port` are passed
@@ -25,12 +22,14 @@ const ALL_INTERFACES_HOST = '0.0.0.0'
  * @param port - the listen port (`0` requests an OS-assigned port), or `undefined` to keep the config default.
  * @param dev - mount the client HMR driver and watch plugin bundles for rebuilds.
  * @param workspaceRoot - parent directory for name-created workspaces, or `undefined` for the gateway's cwd fallback.
+ * @param trustedHosts - extra authorities for the /api browser-trust fence, or `undefined` for the derived LAN literals alone.
  */
 export async function runWeb(
   host: string | undefined,
   port: number | undefined,
   dev: boolean,
   workspaceRoot: string | undefined,
+  trustedHosts: string[] | undefined,
 ): Promise<void> {
   const entry = new AppCLIEntry({
     configPath: CONFIG_PATH,
@@ -38,6 +37,7 @@ export async function runWeb(
     ...host !== undefined && { host },
     ...port !== undefined && { port },
     ...workspaceRoot !== undefined && { workspaceRoot },
+    ...trustedHosts !== undefined && { trustedHosts },
   })
   const { ctx, port: boundPort } = await entry.run()
 
@@ -48,12 +48,11 @@ export async function runWeb(
     void Promise.resolve(ctx.fiber.dispose()).finally(() => { process.exit(code) })
   }
 
-  const lanCandidate = host === ALL_INTERFACES_HOST
-    ? Object.values(networkInterfaces()).flat()
-      .find(iface => iface !== undefined && iface.family === 'IPv4' && !iface.internal)
-    : undefined
+  // The entry's boot-time snapshot, not a fresh sample: the printed LAN URL
+  // must name an address the /api trust fence was configured with.
+  const lanCandidate = entry.lanAddresses[0]
   const localUrl = `http://${LOOPBACK_HOST}:${boundPort}`
-  console.log(`dsh web: ${localUrl}${lanCandidate === undefined ? '' : ` (LAN: http://${lanCandidate.address}:${boundPort})`}`)
+  console.log(`dsh web: ${localUrl}${lanCandidate === undefined ? '' : ` (LAN: http://${lanCandidate}:${boundPort})`}`)
 
   process.on('SIGTERM', () => { shutdown(0) })
   process.on('SIGINT', () => { shutdown(130) })

apps/cli/tests/args.spec.ts

@@ -35,6 +35,9 @@ describe('parseDshArgs', () => {
     // at boot); the adapter only coerces the port string to a number.
     expect(parse(['web', '--host', '0.0.0.0', '--port', '8080', '--dev', '--workspace-root', '/w']))
       .toEqual({ mode: 'web', host: '0.0.0.0', port: 8080, dev: true, workspaceRoot: '/w' })
+    // --trusted-host is variadic and repeatable; authorities pass through unvalidated.
+    expect(parse(['web', '--trusted-host', 'harness.internal:3080', 'lab.internal', '--trusted-host', '10.0.0.9']))
+      .toEqual({ mode: 'web', dev: false, trustedHosts: ['harness.internal:3080', 'lab.internal', '10.0.0.9'] })
   })
 
   it('exits nonzero instead of silently starting fresh or dropping inputs', () => {

apps/cli/tests/trusted-hosts.spec.ts

@@ -0,0 +1,33 @@
+/** Single-sample LAN-trust resolution for the /api browser-trust fence (`resolveLanTrust`). */
+
+import { describe, expect, it, vi } from 'vitest'
+import { resolveLanTrust } from '../src/app-cli-entry.ts'
+
+vi.mock('node:os', () => ({
+  networkInterfaces: () => ({
+    lo0: [
+      { family: 'IPv4', internal: true, address: '127.0.0.1' },
+    ],
+    en0: [
+      { family: 'IPv6', internal: false, address: 'fe80::1' },
+      { family: 'IPv4', internal: false, address: '192.168.1.5' },
+    ],
+    en1: [
+      { family: 'IPv4', internal: false, address: '10.0.0.7' },
+    ],
+    utun0: undefined,
+  }),
+}))
+
+describe('resolveLanTrust', () => {
+  it('samples non-internal IPv4 addresses once for an all-interfaces bind: trust and display share them', () => {
+    const { lanAddresses, trustedHosts } = resolveLanTrust('0.0.0.0', ['harness.internal:3080'])
+    expect(lanAddresses).toEqual(['192.168.1.5', '10.0.0.7'])
+    expect(trustedHosts).toEqual(['192.168.1.5', '10.0.0.7', 'harness.internal:3080'])
+  })
+
+  it('derives nothing for a loopback or unresolved bind — extras alone stand, no LAN URL to print', () => {
+    expect(resolveLanTrust('127.0.0.1', [])).toEqual({ lanAddresses: [], trustedHosts: [] })
+    expect(resolveLanTrust(undefined, ['lab.internal'])).toEqual({ lanAddresses: [], trustedHosts: ['lab.internal'] })
+  })
+})

apps/cli/tests/tsconfig-paths-loader.spec.ts

@@ -0,0 +1,180 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import type { ResolveFnOutput, ResolveHookContext } from 'node:module'
+import { tmpdir } from 'node:os'
+import { dirname, join } from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { initialize, resolveHook, TsconfigPathsResolver } from '../src/tsconfig-paths-loader.ts'
+
+class ResolverFixture {
+  readonly root = mkdtempSync(join(tmpdir(), 'dsh-tsconfig-paths-'))
+
+  path(relativePath: string): string {
+    return join(this.root, relativePath)
+  }
+
+  write(relativePath: string, content = 'export {}\n'): string {
+    const path = this.path(relativePath)
+    mkdirSync(dirname(path), { recursive: true })
+    writeFileSync(path, content)
+    return path
+  }
+
+  writeJson(relativePath: string, value: unknown): string {
+    return this.write(relativePath, `${JSON.stringify(value)}\n`)
+  }
+
+  createResolver(paths: Record<string, string[]>): TsconfigPathsResolver {
+    const tsconfigPath = this.writeJson('tsconfig.json', { compilerOptions: { paths } })
+    return TsconfigPathsResolver.create(tsconfigPath)
+  }
+
+  parentURL(relativePath = 'consumer/src/nested/index.ts'): string {
+    return pathToFileURL(this.path(relativePath)).href
+  }
+
+  dispose(): void {
+    rmSync(this.root, { recursive: true, force: true })
+  }
+}
+
+const fixtures: ResolverFixture[] = []
+
+function fixture(): ResolverFixture {
+  const value = new ResolverFixture()
+  fixtures.push(value)
+  return value
+}
+
+afterEach(() => {
+  for (const value of fixtures.splice(0)) value.dispose()
+})
+
+describe('TsconfigPathsResolver', () => {
+  it('orders exact, longer-prefix, and longer-suffix path rules', async () => {
+    const files = fixture()
+    files.writeJson('consumer/package.json', {
+      dependencies: {
+        '@scope/feature-name': '*',
+        '@scope/feature-other': '*',
+        '@scope/plain-suffix': '*',
+      },
+    })
+    files.write('targets/exact.ts')
+    files.write('targets/prefix/other.ts')
+    files.write('targets/generic/feature-other.ts')
+    files.write('targets/suffix/plain.ts')
+    files.write('targets/generic/plain-suffix.ts')
+    const resolver = files.createResolver({
+      '@scope/*': ['./targets/generic/*'],
+      '@scope/*-suffix': ['./targets/suffix/*'],
+      '@scope/feature-*': ['./targets/prefix/*'],
+      '@scope/feature-name': ['./targets/exact.ts'],
+    })
+
+    await expect(resolver.resolve('@scope/feature-name', files.parentURL()))
+      .resolves.toBe(pathToFileURL(files.path('targets/exact.ts')).href)
+    await expect(resolver.resolve('@scope/feature-other', files.parentURL()))
+      .resolves.toBe(pathToFileURL(files.path('targets/prefix/other.ts')).href)
+    await expect(resolver.resolve('@scope/plain-suffix', files.parentURL()))
+      .resolves.toBe(pathToFileURL(files.path('targets/suffix/plain.ts')).href)
+  })
+
+  it('resolves only self-references and runtime dependencies from the nearest ancestor manifest', async () => {
+    const files = fixture()
+    files.writeJson('consumer/package.json', {
+      name: 'self-package',
+      dependencies: { dependency: '*' },
+      optionalDependencies: { optional: '*' },
+      peerDependencies: { peer: '*' },
+    })
+    for (const name of ['self-package', 'dependency', 'optional', 'peer', 'undeclared']) {
+      files.write(`targets/${name}.ts`)
+    }
+    const resolver = files.createResolver(Object.fromEntries(
+      ['self-package', 'dependency', 'optional', 'peer', 'undeclared']
+        .map(name => [name, [`./targets/${name}`]]),
+    ))
+
+    for (const name of ['self-package', 'dependency', 'optional', 'peer']) {
+      await expect(resolver.resolve(name, files.parentURL()))
+        .resolves.toBe(pathToFileURL(files.path(`targets/${name}.ts`)).href)
+    }
+    await expect(resolver.resolve('undeclared', files.parentURL())).resolves.toBeUndefined()
+  })
+
+  it('probes native TypeScript extensions and index files but excludes TSX and missing targets', async () => {
+    const files = fixture()
+    const names = ['plain-ts', 'module-mts', 'common-cts', 'directory', 'tsx-implicit', 'tsx-explicit', 'missing']
+    files.writeJson('consumer/package.json', {
+      dependencies: Object.fromEntries(names.map(name => [name, '*'])),
+    })
+    files.write('targets/plain.ts')
+    files.write('targets/module.mts')
+    files.write('targets/common.cts')
+    files.write('targets/directory/index.ts')
+    files.write('targets/component.tsx')
+    const resolver = files.createResolver({
+      'plain-ts': ['./targets/plain'],
+      'module-mts': ['./targets/module'],
+      'common-cts': ['./targets/common'],
+      'directory': ['./targets/directory'],
+      'tsx-implicit': ['./targets/component'],
+      'tsx-explicit': ['./targets/component.tsx'],
+      'missing': ['./targets/missing'],
+    })
+
+    for (const [name, target] of [
+      ['plain-ts', 'targets/plain.ts'],
+      ['module-mts', 'targets/module.mts'],
+      ['common-cts', 'targets/common.cts'],
+      ['directory', 'targets/directory/index.ts'],
+    ] as const) {
+      await expect(resolver.resolve(name, files.parentURL()))
+        .resolves.toBe(pathToFileURL(files.path(target)).href)
+    }
+    await expect(resolver.resolve('tsx-implicit', files.parentURL())).resolves.toBeUndefined()
+    await expect(resolver.resolve('tsx-explicit', files.parentURL())).resolves.toBeUndefined()
+    await expect(resolver.resolve('missing', files.parentURL())).resolves.toBeUndefined()
+  })
+
+  it('anchors inherited paths at the config that declared them', async () => {
+    const files = fixture()
+    files.writeJson('consumer/package.json', { dependencies: { custom: '*' } })
+    files.write('targets/custom.ts')
+    files.writeJson('base.json', { compilerOptions: { paths: { custom: ['./targets/custom'] } } })
+    const customTsconfig = files.writeJson('configs/custom.json', { extends: '../base.json' })
+    const resolver = TsconfigPathsResolver.create(customTsconfig)
+
+    await expect(resolver.resolve('custom', files.parentURL()))
+      .resolves.toBe(pathToFileURL(files.path('targets/custom.ts')).href)
+  })
+
+  it('short-circuits matched aliases and delegates unsupported schemes or unmatched requests', async () => {
+    const files = fixture()
+    files.writeJson('consumer/package.json', { dependencies: { matched: '*' } })
+    const target = files.write('targets/matched.ts')
+    const tsconfigPath = files.writeJson('tsconfig.json', {
+      compilerOptions: { paths: { matched: ['./targets/matched'] } },
+    })
+    initialize({ tsconfigPath })
+    const context: ResolveHookContext = {
+      conditions: [],
+      importAttributes: {},
+      parentURL: files.parentURL(),
+    }
+    const nextResolve = vi.fn(async (
+      specifier: string,
+      _context: ResolveHookContext,
+    ): Promise<ResolveFnOutput> => ({ url: `next:${specifier}` }))
+
+    await expect(resolveHook('matched', context, nextResolve))
+      .resolves.toEqual({ url: pathToFileURL(target).href, shortCircuit: true })
+    expect(nextResolve).not.toHaveBeenCalled()
+
+    for (const specifier of ['unmatched', 'node:fs', 'data:text/javascript,export default 1', 'https://example.test/mod.ts']) {
+      await expect(resolveHook(specifier, context, nextResolve)).resolves.toEqual({ url: `next:${specifier}` })
+      expect(nextResolve).toHaveBeenLastCalledWith(specifier, context)
+    }
+  })
+})

apps/cli/tsconfig.json

@@ -62,6 +62,9 @@
     {
       "path": "../../packages/client/ui-conversation"
     },
+    {
+      "path": "../../packages/client/ui-plan"
+    },
     {
       "path": "../../packages/client/ui-trajectory"
     },