@deepseek-harness-tui/dsh-tui 0.10.2 → 0.11.1

package/lib/types/dsh-adapter/workspaces.js

@@ -10,6 +10,90 @@ import { Service } from '@deepseek-ai/cordis';
 import { activationFiber, bindCallerEffect, compositionRoot, concreteService, requirePluginCaller } from './host-access.js';
 import { assertCapabilityShadowPolicy, } from '../adapter/kernel/runtime.js';
 import { adapterRuntimeFor } from '../adapter/kernel/runtime-context.js';
+/**
+ * Enumerate the durable workspace registry, in its own display order.
+ *
+ * The sidebar needs the *registry* (every workspace the user ever registered,
+ * including ones with no sessions yet), not the session-derived grouping the
+ * `/resume` browser builds. Order, ids and titles come from the ledger;
+ * `sessionCount` is filled in by the caller (the adapter holds no session
+ * index), and `present` is derived here.
+ */
+export async function listRegistryWorkspaces(runtime) {
+    if (runtime === undefined)
+        return [];
+    const registry = workspaceRegistry(runtime);
+    if (registry === undefined)
+        return [];
+    const out = [];
+    for (const workspace of registry.list()) {
+        let present = true;
+        try {
+            present = (await workspace.status?.()) !== 'missing-dir';
+        }
+        catch {
+            // An unreadable status is not evidence of absence.
+            present = true;
+        }
+        out.push({
+            id: String(workspace.id),
+            path: workspace.path,
+            title: workspace.title,
+            present,
+            sessionCount: 0,
+        });
+    }
+    return out;
+}
+/**
+ * Remove a workspace registration by path. Sessions and the directory survive:
+ * only the ledger entry goes away, so the sessions reappear as ungrouped.
+ *
+ * @returns True when a record was removed, false when no record owned `cwd`
+ *   (or the ledger is unmounted).
+ */
+export async function removeRegistryWorkspace(runtime, cwd, owner) {
+    if (runtime === undefined)
+        return false;
+    const registry = workspaceRegistry(runtime);
+    if (registry === undefined)
+        return false;
+    const workspace = registry.list().find(candidate => sameCwd(candidate.path, cwd));
+    if (workspace === undefined)
+        return false;
+    // The durable ledger is host-owned: a plugin may only drop a registration
+    // for a cwd one of ITS OWN providers still vouches for. `owner === undefined`
+    // is the host facade's own call (the sidebar's remove action).
+    if (owner !== undefined && !ownsWorkspace(runtime, owner, cwd)) {
+        throw new Error('workspace is not owned by the calling activation');
+    }
+    return registry.delete(workspace.id);
+}
+/**
+ * Whether a calling activation's own providers still vouch for `cwd`.
+ *
+ * This is the same evidence `renameWorkspace` accepts, and the only ownership
+ * fact the local ledger records 鈥?the registry entry itself carries no creator.
+ * A provider `describe()` that returns a target means the cwd belongs to that
+ * provider's scheme, so the activation behind it is the one entitled to mutate
+ * the registration.
+ * @param runtime - The workspace service.
+ * @param owner - Live activation fiber of the caller.
+ * @param cwd - Directory to test.
+ * @returns True when one of the caller's providers owns `cwd`.
+ */
+function ownsWorkspace(runtime, owner, cwd) {
+    for (const provider of providersFor(workspaceStateFor(runtime), owner)) {
+        try {
+            if (provider.describe(cwd) !== undefined)
+                return true;
+        }
+        catch {
+            // A provider that throws on describe vouches for nothing.
+        }
+    }
+    return false;
+}
 export const name = 'dsh-tui-workspaces';
 /** Bound every provider promise so one plugin cannot park workspace flows. */
 export const WORKSPACE_PROVIDER_TIMEOUT_MS = 2000;
@@ -53,6 +137,11 @@ export class TuiWorkspaceRuntime extends Service {
                 assertCapabilityShadowPolicy('host.workspaces.rename', state.runtime.mode, state.runtime.slices);
                 return renameWorkspace(runtime, cwd, title, undefined);
             },
+            remove: (cwd) => {
+                assertCapabilityShadowPolicy('host.workspaces.remove', state.runtime.mode, state.runtime.slices);
+                return removeRegistryWorkspace(runtime, cwd);
+            },
+            listRegistry: () => listRegistryWorkspaces(runtime),
             commands: () => workspaceCommands(runtime, undefined),
             runCommand: (name, input, cwd, signal) => {
                 assertCapabilityShadowPolicy('host.workspaces.runCommand', state.runtime.mode, state.runtime.slices);
@@ -107,6 +196,27 @@ export class TuiWorkspaceRuntime extends Service {
         const owner = workspaceCaller(this, 'tuiWorkspaces.rename');
         return renameWorkspace(this, cwd, title, owner);
     }
+    /**
+     * Drop a workspace registration; the directory and session logs survive.
+     *
+     * Plugin-facing, and therefore bound by the SAME rule as {@link rename}: a
+     * live calling activation is required, and the target must be a cwd one of
+     * that activation's own providers vouches for. Without both, a plugin that
+     * never owned the workspace 鈥?including one whose fiber was already disposed
+     * and whose caller context is a retained handle 鈥?could delete a host
+     * registration. Shadow policy alone is not caller authentication.
+     */
+    async remove(cwd) {
+        assertCapabilityShadowPolicy('host.workspaces.remove', workspaceStateFor(this).runtime.mode, workspaceStateFor(this).runtime.slices);
+        const owner = workspaceCaller(this, 'tuiWorkspaces.remove');
+        return removeRegistryWorkspace(this, cwd, owner);
+    }
+    /** The durable ledger's own listing, in its own order. */
+    async listRegistry() {
+        assertCapabilityShadowPolicy('host.workspaces.list', workspaceStateFor(this).runtime.mode, workspaceStateFor(this).runtime.slices);
+        workspaceCaller(this, 'tuiWorkspaces.listRegistry');
+        return listRegistryWorkspaces(this);
+    }
     commands() {
         assertCapabilityShadowPolicy('host.workspaces.commands', workspaceStateFor(this).runtime.mode, workspaceStateFor(this).runtime.slices);
         const owner = workspaceCaller(this, 'tuiWorkspaces.commands');
@@ -376,6 +486,12 @@ export function createLocalWorkspaceRuntime() {
         async rename() {
             throw new Error('workspace registry is unavailable');
         },
+        async remove() {
+            return false;
+        },
+        async listRegistry() {
+            return [];
+        },
         commands() {
             return [];
         },

package/lib/types/effortPrefs.d.ts

@@ -3,9 +3,9 @@
  * `/effort` (slider or `/effort <id>`; `/effort status` reports the current
  * level) — note Shift+Tab cycles session modes (default/plan/full), not
  * effort levels. The choice lands here so the next boot starts on it. The
- * file is best-effort: a missing/corrupt file or a level the current adapter
- * does not offer just falls back to the provider default — the first
- * request/header event always re-asserts the truth on the status line.
+ * file is best-effort; a level the current route's tier list does not offer
+ * falls back to the nearest LOWER tier (nearestLowerEffort, never up) with a
+ * loud notice — a missing/corrupt file falls back to the provider default.
  */
 /**
  * The persisted reasoning-effort id, or undefined when unset or invalid.
@@ -26,6 +26,18 @@ export declare function readEffortPref(dir?: string): string | undefined;
  * @returns The winning level id, or undefined for the adapter default.
  */
 export declare function resolveEffortDefault(settingsDefault: string | undefined, configured: string | undefined, persisted: string | undefined): string | undefined;
+/**
+ * Resolve a preferred effort tier against a route's available tiers when the
+ * exact tier is absent: pick the NEAREST LOWER standard tier that the route
+ * offers (max→high, high→low, …). Only-down, never-up — a user who prefers
+ * `low` on a route without it must not be pushed to `high`. Unknown tier ids
+ * (custom route tiers outside the standard order) never participate: an
+ * unknown preference yields undefined, an unknown candidate is skipped.
+ * @param preferred - The preferred tier id (exact match short-circuits).
+ * @param available - Tier ids the current route offers.
+ * @returns The tier id to apply, or undefined to keep the model default.
+ */
+export declare function nearestLowerEffort(preferred: string, available: readonly string[]): string | undefined;
 /**
  * Persist the chosen reasoning-effort id (best effort).
  * @param effort - Adapter-owned effort id to persist.

package/lib/types/effortPrefs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"effortPrefs.d.ts","sourceRoot":"","sources":["../../src/effortPrefs.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAQH;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,GAAG,GAAE,MAAkB,GAAG,MAAM,GAAG,SAAS,CAS1E;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAClC,eAAe,EAAE,MAAM,GAAG,SAAS,EACnC,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,SAAS,EAAE,MAAM,GAAG,SAAS,GAC5B,MAAM,GAAG,SAAS,CAEpB;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,GAAE,MAAkB,GAAG,OAAO,CAQhF"}
+{"version":3,"file":"effortPrefs.d.ts","sourceRoot":"","sources":["../../src/effortPrefs.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAQH;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,GAAG,GAAE,MAAkB,GAAG,MAAM,GAAG,SAAS,CAS1E;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAClC,eAAe,EAAE,MAAM,GAAG,SAAS,EACnC,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,SAAS,EAAE,MAAM,GAAG,SAAS,GAC5B,MAAM,GAAG,SAAS,CAEpB;AAKD;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,GAAG,SAAS,CAgBtG;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,GAAE,MAAkB,GAAG,OAAO,CAQhF"}

package/lib/types/effortPrefs.js

@@ -3,9 +3,9 @@
  * `/effort` (slider or `/effort <id>`; `/effort status` reports the current
  * level) — note Shift+Tab cycles session modes (default/plan/full), not
  * effort levels. The choice lands here so the next boot starts on it. The
- * file is best-effort: a missing/corrupt file or a level the current adapter
- * does not offer just falls back to the provider default — the first
- * request/header event always re-asserts the truth on the status line.
+ * file is best-effort; a level the current route's tier list does not offer
+ * falls back to the nearest LOWER tier (nearestLowerEffort, never up) with a
+ * loud notice — a missing/corrupt file falls back to the provider default.
  */
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
@@ -43,6 +43,40 @@ export function readEffortPref(dir = PREFS_DIR) {
 export function resolveEffortDefault(settingsDefault, configured, persisted) {
     return settingsDefault ?? configured ?? persisted;
 }
+/** Standard effort-tier order, weakest to strongest. */
+const EFFORT_TIER_ORDER = ['off', 'low', 'medium', 'high', 'max'];
+/**
+ * Resolve a preferred effort tier against a route's available tiers when the
+ * exact tier is absent: pick the NEAREST LOWER standard tier that the route
+ * offers (max→high, high→low, …). Only-down, never-up — a user who prefers
+ * `low` on a route without it must not be pushed to `high`. Unknown tier ids
+ * (custom route tiers outside the standard order) never participate: an
+ * unknown preference yields undefined, an unknown candidate is skipped.
+ * @param preferred - The preferred tier id (exact match short-circuits).
+ * @param available - Tier ids the current route offers.
+ * @returns The tier id to apply, or undefined to keep the model default.
+ */
+export function nearestLowerEffort(preferred, available) {
+    if (preferred === '' || available.length === 0)
+        return undefined;
+    if (available.includes(preferred))
+        return preferred;
+    const preferredRank = EFFORT_TIER_ORDER.indexOf(preferred);
+    if (preferredRank <= 0)
+        return undefined; // unknown id, or 'off' has nothing lower
+    let result;
+    let resultRank = -1;
+    for (const candidate of available) {
+        const rank = EFFORT_TIER_ORDER.indexOf(candidate);
+        if (rank < 0 || rank >= preferredRank)
+            continue;
+        if (rank > resultRank) {
+            result = candidate;
+            resultRank = rank;
+        }
+    }
+    return result;
+}
 /**
  * Persist the chosen reasoning-effort id (best effort).
  * @param effort - Adapter-owned effort id to persist.

package/lib/types/history.d.ts

@@ -4,9 +4,14 @@ export type HistoryEntry = {
     /** Unix ms timestamp. */
     ts: number;
 };
+/**
+ * Entry cap for the persisted history. `↑`/`↓` and the Ctrl+R overlay read
+ * the same file, so both depths come from this one number.
+ */
+export declare const HISTORY_LIMIT = 200;
 /**
  * Append an input to the persisted history, deduping the immediately
- * previous entry and capping the file at 200 entries.
+ * previous entry and capping the file at `HISTORY_LIMIT` entries.
  * @param text - Input to persist; blank inputs are ignored.
  * @returns Resolves once this entry is persisted; callers on the input path
  * intentionally discard it because persistence is best-effort.
@@ -17,6 +22,13 @@ export declare function appendHistory(text: string): Promise<void>;
  * @returns The persisted entries in reverse-chronological order.
  */
 export declare function loadHistory(): HistoryEntry[];
+/**
+ * Read the persisted history in the order the composer walks it: oldest
+ * first, so `↑` reaches the newest entry first (the list tail) exactly as it
+ * does for the entries this process pushed itself.
+ * @returns The persisted entries in chronological order.
+ */
+export declare function loadHistoryOldestFirst(): HistoryEntry[];
 /**
  * Stable id for a history entry (keeps React keys distinct across identical texts).
  * @param entry - The history entry to hash.

package/lib/types/history.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"history.d.ts","sourceRoot":"","sources":["../../src/history.ts"],"names":[],"mappings":"AAWA,yCAAyC;AACzC,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,MAAM,CAAA;IACZ,yBAAyB;IACzB,EAAE,EAAE,MAAM,CAAA;CACX,CAAA;AAyHD;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAQzD;AAED;;;GAGG;AACH,wBAAgB,WAAW,IAAI,YAAY,EAAE,CAE5C;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,YAAY,EAAE,KAAK,SAAI,GAAG,MAAM,CAErE"}
+{"version":3,"file":"history.d.ts","sourceRoot":"","sources":["../../src/history.ts"],"names":[],"mappings":"AAWA,yCAAyC;AACzC,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,MAAM,CAAA;IACZ,yBAAyB;IACzB,EAAE,EAAE,MAAM,CAAA;CACX,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,aAAa,MAAM,CAAA;AAuHhC;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAQzD;AAED;;;GAGG;AACH,wBAAgB,WAAW,IAAI,YAAY,EAAE,CAE5C;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,IAAI,YAAY,EAAE,CAEvD;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,YAAY,EAAE,KAAK,SAAI,GAAG,MAAM,CAErE"}

package/lib/types/history.js

@@ -7,7 +7,11 @@ import { DATA_DIR } from './utils/paths.js';
 const HISTORY_DIR = DATA_DIR;
 const HISTORY_FILE = join(HISTORY_DIR, 'history.jsonl');
 const HISTORY_LOCK = `${HISTORY_FILE}.lock`;
-const HISTORY_LIMIT = 200;
+/**
+ * Entry cap for the persisted history. `↑`/`↓` and the Ctrl+R overlay read
+ * the same file, so both depths come from this one number.
+ */
+export const HISTORY_LIMIT = 200;
 const LOCK_RETRY_LIMIT = 500;
 const LOCK_RETRY_DELAY_MS = 5;
 const STALE_LOCK_MS = 30_000;
@@ -131,7 +135,7 @@ async function persistEntry(trimmed) {
 let appendChain = Promise.resolve();
 /**
  * Append an input to the persisted history, deduping the immediately
- * previous entry and capping the file at 200 entries.
+ * previous entry and capping the file at `HISTORY_LIMIT` entries.
  * @param text - Input to persist; blank inputs are ignored.
  * @returns Resolves once this entry is persisted; callers on the input path
  * intentionally discard it because persistence is best-effort.
@@ -153,6 +157,15 @@ export function appendHistory(text) {
 export function loadHistory() {
     return loadRaw().reverse();
 }
+/**
+ * Read the persisted history in the order the composer walks it: oldest
+ * first, so `↑` reaches the newest entry first (the list tail) exactly as it
+ * does for the entries this process pushed itself.
+ * @returns The persisted entries in chronological order.
+ */
+export function loadHistoryOldestFirst() {
+    return loadRaw();
+}
 /**
  * Stable id for a history entry (keeps React keys distinct across identical texts).
  * @param entry - The history entry to hash.

package/lib/types/homePrefs.d.ts

@@ -0,0 +1,15 @@
+interface HomePrefs {
+    /** True once the workspace home has been shown as the landing screen. */
+    seen?: boolean;
+}
+/** Read the persisted landing preference; an unreadable file reads as unset. */
+export declare function readHomePrefs(): HomePrefs;
+/**
+ * Record that the workspace home has been shown.
+ *
+ * @returns True when the preference was durably written; false when the data
+ *   directory is not writable (the caller stays silent — see the module note).
+ */
+export declare function markHomeSeen(): boolean;
+export {};
+//# sourceMappingURL=homePrefs.d.ts.map

package/lib/types/homePrefs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"homePrefs.d.ts","sourceRoot":"","sources":["../../src/homePrefs.ts"],"names":[],"mappings":"AA0BA,UAAU,SAAS;IACjB,yEAAyE;IACzE,IAAI,CAAC,EAAE,OAAO,CAAA;CACf;AAED,gFAAgF;AAChF,wBAAgB,aAAa,IAAI,SAAS,CASzC;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,IAAI,OAAO,CAQtC"}

package/lib/types/homePrefs.js

@@ -0,0 +1,53 @@
+/**
+ * Landing-screen preference for the TUI's workspace home screen.
+ *
+ * A one-key preference under `~/.dsh-tui/home.json`, deliberately NOT a cordis
+ * config value: "has this installation shown the user the workspace home on a
+ * fresh launch yet" is per-machine UI state, like the lang and tray
+ * preferences next to it — not a deployment choice a cordis.yml row should own.
+ *
+ * The rule it enables is one-shot: the FIRST ordinary launch (no explicit
+ * `--resume`, no workspace target) lands on the workspace home instead of a
+ * blank conversation, because that is the launch where "which project am I
+ * working on" has no answer yet. After that the chat screen is the landing
+ * surface again, and the home screen stays reachable as a screen.
+ *
+ * A preference file that cannot be read or written is never fatal: the worst
+ * outcome is one extra home screen, or a chat screen where the home was
+ * expected. Both are recoverable with a single keypress.
+ *
+ * @module @deepseek-harness-tui/dsh-tui/homePrefs
+ */
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { DATA_DIR } from './utils/paths.js';
+const PREFS_FILE = join(DATA_DIR, 'home.json');
+/** Read the persisted landing preference; an unreadable file reads as unset. */
+export function readHomePrefs() {
+    try {
+        const parsed = JSON.parse(readFileSync(PREFS_FILE, 'utf8'));
+        if (typeof parsed !== 'object' || parsed === null)
+            return {};
+        const seen = parsed.seen;
+        return typeof seen === 'boolean' ? { seen } : {};
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Record that the workspace home has been shown.
+ *
+ * @returns True when the preference was durably written; false when the data
+ *   directory is not writable (the caller stays silent — see the module note).
+ */
+export function markHomeSeen() {
+    try {
+        mkdirSync(DATA_DIR, { recursive: true });
+        writeFileSync(PREFS_FILE, `${JSON.stringify({ ...readHomePrefs(), seen: true }, null, 2)}\n`, 'utf8');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}