@dsh-cove/dsh-web-all 0.0.0-stage → 0.4.4

package/lib/types/host/services/worktree/run-command.d.ts

@@ -0,0 +1,26 @@
+export interface RunCommandOptions {
+    cwd: string;
+    timeoutMs: number;
+    maxBuffer?: number;
+}
+export interface RunCommandResult {
+    stdout: string;
+    stderr: string;
+}
+export type RunCommand = (executable: string, argv: readonly string[], options: RunCommandOptions) => Promise<RunCommandResult>;
+/** Production command runner. Node's execFile passes argv directly to the executable. */
+export declare const runCommand: RunCommand;
+export interface CommandFailure extends Error {
+    code?: string | number;
+    errno?: number;
+    killed?: boolean;
+    signal?: NodeJS.Signals | null;
+    stdout?: string | Buffer;
+    stderr?: string | Buffer;
+}
+/** Narrow unknown exec failures without coupling callers to Node's private error type. */
+export declare function commandFailure(error: unknown): CommandFailure | undefined;
+/** execFile reports timeout as killed/SIGTERM and commonly as code ETIMEDOUT. */
+export declare function isCommandTimeout(error: unknown): boolean;
+export declare function commandFailureText(error: unknown): string;
+//# sourceMappingURL=run-command.d.ts.map

package/lib/types/host/services/worktree/run-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-command.d.ts","sourceRoot":"","sources":["../../../../../src/host/services/worktree/run-command.ts"],"names":[],"mappings":"AAWA,MAAM,WAAW,iBAAiB;IAChC,GAAG,EAAE,MAAM,CAAA;IACX,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;CACf;AAED,MAAM,MAAM,UAAU,GAAG,CACvB,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,OAAO,EAAE,iBAAiB,KACvB,OAAO,CAAC,gBAAgB,CAAC,CAAA;AAE9B,yFAAyF;AACzF,eAAO,MAAM,UAAU,EAAE,UAQxB,CAAA;AAED,MAAM,WAAW,cAAe,SAAQ,KAAK;IAC3C,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IACtB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC,OAAO,GAAG,IAAI,CAAA;IAC9B,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IACxB,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;CACzB;AAED,0FAA0F;AAC1F,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,cAAc,GAAG,SAAS,CAEzE;AAED,iFAAiF;AACjF,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAGxD;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAMzD"}

package/lib/types/host/services/worktree/run-command.js

@@ -0,0 +1,36 @@
+/**
+ * Injectable argv-only command runner for the worktree service.
+ *
+ * Commands are executed with execFile, never a shell. Keeping this seam small
+ * lets route tests assert the exact executable, argv, cwd, and timeout.
+ */
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+/** Production command runner. Node's execFile passes argv directly to the executable. */
+export const runCommand = async (executable, argv, options) => {
+    const { stdout, stderr } = await execFileAsync(executable, [...argv], {
+        cwd: options.cwd,
+        timeout: options.timeoutMs,
+        maxBuffer: options.maxBuffer ?? 4 * 1024 * 1024,
+        windowsHide: true,
+    });
+    return { stdout, stderr };
+};
+/** Narrow unknown exec failures without coupling callers to Node's private error type. */
+export function commandFailure(error) {
+    return error instanceof Error ? error : undefined;
+}
+/** execFile reports timeout as killed/SIGTERM and commonly as code ETIMEDOUT. */
+export function isCommandTimeout(error) {
+    const failure = commandFailure(error);
+    return failure?.code === 'ETIMEDOUT' || failure?.killed === true || failure?.signal === 'SIGTERM';
+}
+export function commandFailureText(error) {
+    const failure = commandFailure(error);
+    if (failure === undefined)
+        return String(error);
+    const stderr = typeof failure.stderr === 'string' ? failure.stderr : failure.stderr?.toString('utf8');
+    const stdout = typeof failure.stdout === 'string' ? failure.stdout : failure.stdout?.toString('utf8');
+    return [stderr, stdout, failure.message].filter((part) => typeof part === 'string' && part.trim() !== '').join('\n');
+}

package/lib/types/host/services/worktree/session-lane/manager.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Session-bound lane orchestration: the two host-side halves of "start a
+ * conversation on its own worktree".
+ *
+ * Why the host does NOT create the session
+ *   The obvious host path is a direct store insert, but it is wrong on two
+ *   counts:
+ *     1. `ctx.sessions.create()` makes the session owned by the CALLING
+ *        FIBER — disposing that fiber removes the session from the store. A
+ *        session created by this plugin would then disappear on the next
+ *        plugin reload, which is exactly when a developer expects their
+ *        conversation to still be there.
+ *     2. The retired session-isolation wrapper reached for a host gateway
+ *        face (`apiProxy.sessions.create`); on a real deployment that face is
+ *        absent — reproduced live: `POST /worktree/lane/create` answered
+ *        `session-create-failed: the apiProxy sessions face is unavailable`.
+ *   So creation stays with the platform: the browser asks the platform's own
+ *   workspace navigation for the lane (`uiWorkspace.openWorkspace`, whose
+ *   `beforeOpen` callback names the `ctx.sessions.create({ workspaceId })`
+ *   session it connected) and binds that id to the lane. The lane's directory is
+ *   a registered workspace because the platform accounts a session to a workspace
+ *   only while its cwd equals that path; a lane session created with a bare cwd
+ *   would render an inert composer.
+ *
+ * What the host owns
+ *   `createLane`       — make the branch's worktree (attaching an existing
+ *                        branch, cutting a missing one) and register its
+ *                        directory as a workspace. The registration is what makes
+ *                        the conversation in it usable; ownership still sits with
+ *                        the session, and teardown removes the registration with
+ *                        the directory.
+ *   `bindLaneSession`  — after the platform created the session, record the
+ *                        binding and apply the preset the lane requires.
+ *
+ * Why the lane needs `danger-full-access`
+ *   A linked worktree keeps its git directory under
+ *   `<repo>/.git/worktrees/<name>/`, i.e. OUTSIDE the session cwd (which is
+ *   the lane directory). The sandbox grants writes only to the session cwd and
+ *   its descendants, so under `workspace-write` git could not write its index,
+ *   objects or refs and no commit would be possible. Reported as a boolean,
+ *   never thrown: a lane whose preset could not be applied is still usable
+ *   once the user switches the access mode manually, and the header chip says
+ *   so.
+ * @module dsh-client-ui-worktree/host/session-lane
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { BindLaneInput, BindLaneResult, CreateLaneInput, CreateLaneResult, LaneLookupInput, LaneView } from '../../../../core/worktree/types.ts';
+import type { WorktreeManager } from '../manager.ts';
+/**
+ * The preset every lane session must run under. `danger-full-access` maps to
+ * `{sandbox: 'danger-full-access', approval: 'never'}` in
+ * `@deepseek-ai/dsh-permission-presets`.
+ */
+export declare const LANE_PERMISSION_PRESET = "danger-full-access";
+/** Test seams; production uses the ctx services. */
+export interface SessionLaneManagerOptions {
+    /** Preset applier override (tests). */
+    setPermissionPreset?: (sessionId: string, preset: string) => void | Promise<void>;
+    /** Live-session lookup override (tests). */
+    hasSession?: (sessionId: string) => boolean;
+}
+export declare class SessionLaneManager {
+    private readonly ctx;
+    private readonly worktrees;
+    private readonly options;
+    /**
+     * Captured through an optional inject, so the preset service is picked up
+     * whenever the deployment provides it and never blocks this plugin's mount
+     * when it does not.
+     */
+    private presets;
+    constructor(ctx: Context, worktrees: WorktreeManager, options?: SessionLaneManagerOptions);
+    /** Phase 1: ensure the worktree behind the branch exists (no workspace). */
+    createLane(input: CreateLaneInput): Promise<CreateLaneResult>;
+    /**
+     * Phase 2: bind the platform-created session to its lane and apply the preset.
+     *
+     * Fail closed, in this order: every check that can reject the request runs
+     * BEFORE the session is elevated, and the request has to name the directory
+     * the conversation actually runs in. Without that, this route could record —
+     * and hand `danger-full-access` to — a conversation living somewhere else,
+     * and a later teardown would archive a session that never used the lane.
+     * Both halves were reproduced before this check existed: a bind resolved for a
+     * session whose cwd was a different directory, and the elevation happened on
+     * the way to a manifest write that then failed.
+     *
+     * The preset outcome is recorded with the binding, so a lane whose preset
+     * failed still resolves for the header chip.
+     */
+    bindLaneSession(input: BindLaneInput): Promise<BindLaneResult>;
+    /** Resolve the lane a path or session belongs to (delegates to the git layer). */
+    laneForPath(input: LaneLookupInput): Promise<LaneView | null>;
+    /**
+     * Undo a lane whose session never came up (the platform's create failed, or
+     * the user cancelled before it landed). Removes the worktree directory, the
+     * local branch, the git admin records, the manifest entry and the registered
+     * workspace, so a failed start leaves no stray lane behind.
+     */
+    rollbackLane(input: {
+        repoPath: string;
+        branch: string;
+    }): Promise<void>;
+    /** Whether the host can see that session. */
+    private hasSession;
+    /** Apply the lane preset; a failure is reported, not thrown. */
+    private applyPreset;
+    private warnPreset;
+}
+//# sourceMappingURL=manager.d.ts.map

package/lib/types/host/services/worktree/session-lane/manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../../../../../src/host/services/worktree/session-lane/manager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAIlD,OAAO,KAAK,EACV,aAAa,EAAE,cAAc,EAAE,eAAe,EAAE,gBAAgB,EAAE,eAAe,EAAE,QAAQ,EAC5F,MAAM,oCAAoC,CAAA;AAC3C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAEpD;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,uBAAuB,CAAA;AAY1D,oDAAoD;AACpD,MAAM,WAAW,yBAAyB;IACxC,uCAAuC;IACvC,mBAAmB,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACjF,4CAA4C;IAC5C,UAAU,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAA;CAC5C;AAED,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAC7B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAiB;IAC3C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2B;IACnD;;;;OAIG;IACH,OAAO,CAAC,OAAO,CAAmC;gBAEtC,GAAG,EAAE,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,OAAO,GAAE,yBAA8B;IAW7F,4EAA4E;IACtE,UAAU,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAInE;;;;;;;;;;;;;;OAcG;IACG,eAAe,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC;IA6CpE,kFAAkF;IAC5E,WAAW,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC;IAInE;;;;;OAKG;IACG,YAAY,CAAC,KAAK,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAI9E,6CAA6C;IAC7C,OAAO,CAAC,UAAU;IAMlB,gEAAgE;YAClD,WAAW;IA8BzB,OAAO,CAAC,UAAU;CAOnB"}

package/lib/types/host/services/worktree/session-lane/manager.js

@@ -0,0 +1,172 @@
+/**
+ * Session-bound lane orchestration: the two host-side halves of "start a
+ * conversation on its own worktree".
+ *
+ * Why the host does NOT create the session
+ *   The obvious host path is a direct store insert, but it is wrong on two
+ *   counts:
+ *     1. `ctx.sessions.create()` makes the session owned by the CALLING
+ *        FIBER — disposing that fiber removes the session from the store. A
+ *        session created by this plugin would then disappear on the next
+ *        plugin reload, which is exactly when a developer expects their
+ *        conversation to still be there.
+ *     2. The retired session-isolation wrapper reached for a host gateway
+ *        face (`apiProxy.sessions.create`); on a real deployment that face is
+ *        absent — reproduced live: `POST /worktree/lane/create` answered
+ *        `session-create-failed: the apiProxy sessions face is unavailable`.
+ *   So creation stays with the platform: the browser asks the platform's own
+ *   workspace navigation for the lane (`uiWorkspace.openWorkspace`, whose
+ *   `beforeOpen` callback names the `ctx.sessions.create({ workspaceId })`
+ *   session it connected) and binds that id to the lane. The lane's directory is
+ *   a registered workspace because the platform accounts a session to a workspace
+ *   only while its cwd equals that path; a lane session created with a bare cwd
+ *   would render an inert composer.
+ *
+ * What the host owns
+ *   `createLane`       — make the branch's worktree (attaching an existing
+ *                        branch, cutting a missing one) and register its
+ *                        directory as a workspace. The registration is what makes
+ *                        the conversation in it usable; ownership still sits with
+ *                        the session, and teardown removes the registration with
+ *                        the directory.
+ *   `bindLaneSession`  — after the platform created the session, record the
+ *                        binding and apply the preset the lane requires.
+ *
+ * Why the lane needs `danger-full-access`
+ *   A linked worktree keeps its git directory under
+ *   `<repo>/.git/worktrees/<name>/`, i.e. OUTSIDE the session cwd (which is
+ *   the lane directory). The sandbox grants writes only to the session cwd and
+ *   its descendants, so under `workspace-write` git could not write its index,
+ *   objects or refs and no commit would be possible. Reported as a boolean,
+ *   never thrown: a lane whose preset could not be applied is still usable
+ *   once the user switches the access mode manually, and the header chip says
+ *   so.
+ * @module dsh-client-ui-worktree/host/session-lane
+ */
+import { isValidBranchName, WorktreeError } from "../../../../core/worktree/invariant.js";
+import { samePath } from "../../../../core/worktree/paths.js";
+/**
+ * The preset every lane session must run under. `danger-full-access` maps to
+ * `{sandbox: 'danger-full-access', approval: 'never'}` in
+ * `@deepseek-ai/dsh-permission-presets`.
+ */
+export const LANE_PERMISSION_PRESET = 'danger-full-access';
+export class SessionLaneManager {
+    ctx;
+    worktrees;
+    options;
+    /**
+     * Captured through an optional inject, so the preset service is picked up
+     * whenever the deployment provides it and never blocks this plugin's mount
+     * when it does not.
+     */
+    presets;
+    constructor(ctx, worktrees, options = {}) {
+        this.ctx = ctx;
+        this.worktrees = worktrees;
+        this.options = options;
+        this.presets = ctx.get('permissionPresets');
+        ctx.inject(['permissionPresets'], (child) => {
+            this.presets = child.get('permissionPresets');
+            child.effect(() => () => { this.presets = undefined; });
+        });
+    }
+    /** Phase 1: ensure the worktree behind the branch exists (no workspace). */
+    async createLane(input) {
+        return await this.worktrees.ensureLane(input);
+    }
+    /**
+     * Phase 2: bind the platform-created session to its lane and apply the preset.
+     *
+     * Fail closed, in this order: every check that can reject the request runs
+     * BEFORE the session is elevated, and the request has to name the directory
+     * the conversation actually runs in. Without that, this route could record —
+     * and hand `danger-full-access` to — a conversation living somewhere else,
+     * and a later teardown would archive a session that never used the lane.
+     * Both halves were reproduced before this check existed: a bind resolved for a
+     * session whose cwd was a different directory, and the elevation happened on
+     * the way to a manifest write that then failed.
+     *
+     * The preset outcome is recorded with the binding, so a lane whose preset
+     * failed still resolves for the header chip.
+     */
+    async bindLaneSession(input) {
+        if (!this.hasSession(input.sessionId)) {
+            throw new WorktreeError('session-unknown', `session ${input.sessionId} is not live on the host, so it cannot be bound to a lane`, { sessionId: input.sessionId });
+        }
+        if (!isValidBranchName(input.branch)) {
+            throw new WorktreeError('invalid-branch', `branch ${JSON.stringify(input.branch)} is not a valid git ref`, { branch: input.branch });
+        }
+        // Only a lane the host actually records may be bound; `laneForPath`
+        // synthesizes a view for a directory the manifest does not know about.
+        const recorded = await this.worktrees.laneEntry(input.repoPath, input.branch);
+        if (recorded === null) {
+            throw new WorktreeError('worktree-not-found', `no manifest entry records the lane ${JSON.stringify(input.branch)}`, { branch: input.branch });
+        }
+        // The conversation has to be in that directory already: the bind is a
+        // record of where it runs, never a way to move it.
+        const lane = await this.worktrees.laneForPath({ sessionId: input.sessionId });
+        if (lane === null || !samePath(lane.path, recorded.path)) {
+            throw new WorktreeError('lane-mismatch', `session ${input.sessionId} runs in ${lane === null ? 'no lane' : lane.path}, not ${recorded.path}`, { sessionId: input.sessionId, branch: input.branch, expected: recorded.path, actual: lane?.path ?? null });
+        }
+        const permissionPresetApplied = await this.applyPreset(input.sessionId);
+        await this.worktrees.bindSession(input.repoPath, input.branch, input.sessionId, permissionPresetApplied);
+        return { lane, permissionPresetApplied };
+    }
+    /** Resolve the lane a path or session belongs to (delegates to the git layer). */
+    async laneForPath(input) {
+        return this.worktrees.laneForPath(input);
+    }
+    /**
+     * Undo a lane whose session never came up (the platform's create failed, or
+     * the user cancelled before it landed). Removes the worktree directory, the
+     * local branch, the git admin records, the manifest entry and the registered
+     * workspace, so a failed start leaves no stray lane behind.
+     */
+    async rollbackLane(input) {
+        await this.worktrees.rollbackCreate({ repoPath: input.repoPath, name: input.branch });
+    }
+    /** Whether the host can see that session. */
+    hasSession(sessionId) {
+        if (this.options.hasSession !== undefined)
+            return this.options.hasSession(sessionId);
+        const store = this.ctx.get('sessions');
+        return store?.get?.(sessionId) !== undefined;
+    }
+    /** Apply the lane preset; a failure is reported, not thrown. */
+    async applyPreset(sessionId) {
+        if (this.options.setPermissionPreset !== undefined) {
+            try {
+                await this.options.setPermissionPreset(sessionId, LANE_PERMISSION_PRESET);
+                return true;
+            }
+            catch (error) {
+                this.warnPreset(error);
+                return false;
+            }
+        }
+        const presets = this.presets;
+        if (presets === undefined) {
+            this.warnPreset(new Error('the permissionPresets service is unavailable in this deployment'));
+            return false;
+        }
+        const store = this.ctx.get('sessions');
+        const session = store?.get?.(sessionId);
+        if (session === undefined) {
+            this.warnPreset(new Error(`session ${sessionId} is not in the session store`));
+            return false;
+        }
+        try {
+            presets.set(session, LANE_PERMISSION_PRESET);
+            return true;
+        }
+        catch (error) {
+            this.warnPreset(error);
+            return false;
+        }
+    }
+    warnPreset(error) {
+        console.warn(`[dsh-worktree] could not apply the "${LANE_PERMISSION_PRESET}" preset; `
+            + 'the lane session will need its access mode switched manually before it can commit:', error);
+    }
+}

package/lib/types/host/services/worktree/workspace-model-routes.d.ts

@@ -0,0 +1,21 @@
+/**
+ * HTTP route layer for the workspace-model manager. Mirrors the worktree
+ * route discipline:
+ *   1. JSON envelope + status code translation
+ *   2. Shared host access fence (`accessTrustOf`) for every endpoint
+ *   3. Surfacing errors under the stable `WorkspaceModelResponse` contract
+ *
+ * Route list:
+ *   - GET  /workspace-model/list   — read; always allowed from the browser
+ *   - POST /workspace-model/get     — read one path (body `{ path }`)
+ *   - POST /workspace-model/set     — mutation; shared fence
+ *   - POST /workspace-model/clear   — mutation; shared fence
+ * @module dsh-client-ui-worktree/host/workspace-model-routes
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { WorkspaceModelManager } from './workspace-model.ts';
+/** Per-route URL prefix. */
+export declare const WORKSPACE_MODEL_PREFIX = "/workspace-model";
+/** Register all /workspace-model/* routes. Returns the dispose function. */
+export declare function registerWorkspaceModelRoutes(ctx: Context, manager: WorkspaceModelManager): () => void;
+//# sourceMappingURL=workspace-model-routes.d.ts.map

package/lib/types/host/services/worktree/workspace-model-routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-model-routes.d.ts","sourceRoot":"","sources":["../../../../../src/host/services/worktree/workspace-model-routes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAKlD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAA;AAKjE,4BAA4B;AAC5B,eAAO,MAAM,sBAAsB,qBAAqB,CAAA;AAkCxD,4EAA4E;AAC5E,wBAAgB,4BAA4B,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,qBAAqB,GAAG,MAAM,IAAI,CAErG"}

package/lib/types/host/services/worktree/workspace-model-routes.js

@@ -0,0 +1,198 @@
+/**
+ * HTTP route layer for the workspace-model manager. Mirrors the worktree
+ * route discipline:
+ *   1. JSON envelope + status code translation
+ *   2. Shared host access fence (`accessTrustOf`) for every endpoint
+ *   3. Surfacing errors under the stable `WorkspaceModelResponse` contract
+ *
+ * Route list:
+ *   - GET  /workspace-model/list   — read; always allowed from the browser
+ *   - POST /workspace-model/get     — read one path (body `{ path }`)
+ *   - POST /workspace-model/set     — mutation; shared fence
+ *   - POST /workspace-model/clear   — mutation; shared fence
+ * @module dsh-client-ui-worktree/host/workspace-model-routes
+ */
+import { readJsonObject, writeJson } from "./http.js";
+import { accessTrustOf } from "../access-trust/index.js";
+import { registerResources } from "../resources.js";
+/** Per-route URL prefix. */
+export const WORKSPACE_MODEL_PREFIX = '/workspace-model';
+const BAD_REQUEST = { ok: false, code: 'bad-request', message: 'malformed request' };
+const FORBIDDEN = { ok: false, code: 'forbidden', message: 'mutation endpoints require the host access fence' };
+const READ_FORBIDDEN = { ok: false, code: 'forbidden', message: 'reads require the host access fence' };
+/** Pull a required string field, or null when absent/empty. */
+function stringField(body, name) {
+    if (body === null)
+        return null;
+    const value = body[name];
+    return typeof value === 'string' && value !== '' ? value : null;
+}
+/** CORS preflight short-circuit for the mutation routes. */
+function handleOptions(res) {
+    res.writeHead(204, {
+        'access-control-allow-methods': 'POST, OPTIONS',
+        'access-control-allow-headers': 'content-type',
+        'access-control-max-age': '600',
+    });
+    res.end();
+}
+/**
+ * True when the request may mutate: the shared host access fence (loopback, or
+ * a deployment trusted authority with an authenticated browser session).
+ * `isTrusted` already carries the whole rule, so there is no second allow path.
+ */
+/** Wrap a handler that already bounds its own errors. */
+function respond(res, value) {
+    writeJson(res, value.ok ? 200 : value.code === 'forbidden' ? 403 : 400, value);
+}
+/** Register all /workspace-model/* routes. Returns the dispose function. */
+export function registerWorkspaceModelRoutes(ctx, manager) {
+    return registerResources(own => registerOwnedWorkspaceModelRoutes(ctx, manager, own));
+}
+function registerOwnedWorkspaceModelRoutes(ctx, manager, own) {
+    const isTrusted = accessTrustOf(ctx).isTrusted;
+    const canMutate = isTrusted;
+    // GET /workspace-model/list
+    own(ctx.webServer.register({
+        kind: 'exact',
+        path: `${WORKSPACE_MODEL_PREFIX}/list`,
+        handler: async (req, res) => {
+            if (req.method !== 'GET') {
+                writeJson(res, 405, BAD_REQUEST);
+                return;
+            }
+            if (!isTrusted(req)) {
+                respond(res, READ_FORBIDDEN);
+                return;
+            }
+            const list = manager.list();
+            const views = Object.entries(list).map(([path, preset]) => ({ path, preset }));
+            writeJson(res, 200, { ok: true, value: views });
+        },
+    }));
+    // POST /workspace-model/get
+    own(ctx.webServer.register({
+        kind: 'exact',
+        path: `${WORKSPACE_MODEL_PREFIX}/get`,
+        handler: async (req, res) => {
+            if (req.method === 'OPTIONS') {
+                handleOptions(res);
+                return;
+            }
+            if (req.method !== 'POST') {
+                writeJson(res, 405, BAD_REQUEST);
+                return;
+            }
+            if (!isTrusted(req)) {
+                respond(res, READ_FORBIDDEN);
+                return;
+            }
+            let body;
+            try {
+                body = await readJsonObject(req);
+            }
+            catch {
+                writeJson(res, 400, BAD_REQUEST);
+                return;
+            }
+            const path = stringField(body, 'path');
+            if (path === null) {
+                writeJson(res, 400, BAD_REQUEST);
+                return;
+            }
+            respond(res, { ok: true, value: { path, preset: manager.get(path) } });
+        },
+    }));
+    // POST /workspace-model/set
+    own(ctx.webServer.register({
+        kind: 'exact',
+        path: `${WORKSPACE_MODEL_PREFIX}/set`,
+        handler: async (req, res) => {
+            if (req.method === 'OPTIONS') {
+                handleOptions(res);
+                return;
+            }
+            if (req.method !== 'POST') {
+                writeJson(res, 405, BAD_REQUEST);
+                return;
+            }
+            if (!canMutate(req)) {
+                writeJson(res, 403, FORBIDDEN);
+                return;
+            }
+            let body;
+            try {
+                body = await readJsonObject(req);
+            }
+            catch {
+                writeJson(res, 400, BAD_REQUEST);
+                return;
+            }
+            const path = stringField(body, 'path');
+            const preset = body?.preset;
+            if (path === null || typeof preset !== 'object' || preset === null || Array.isArray(preset)) {
+                writeJson(res, 400, BAD_REQUEST);
+                return;
+            }
+            const p = preset;
+            if (typeof p.provider !== 'string' || p.provider === '' || typeof p.model !== 'string' || p.model === '') {
+                writeJson(res, 400, BAD_REQUEST);
+                return;
+            }
+            if (p.reasoningEffort !== undefined && typeof p.reasoningEffort !== 'string') {
+                writeJson(res, 400, BAD_REQUEST);
+                return;
+            }
+            const input = {
+                path,
+                preset: { provider: p.provider, model: p.model, ...(p.reasoningEffort !== undefined ? { reasoningEffort: p.reasoningEffort } : {}) },
+            };
+            try {
+                const stored = await manager.set(input.path, input.preset);
+                respond(res, { ok: true, value: stored });
+            }
+            catch (error) {
+                writeJson(res, 500, { ok: false, code: 'bad-request', message: error instanceof Error ? error.message : String(error) });
+            }
+        },
+    }));
+    // POST /workspace-model/clear
+    own(ctx.webServer.register({
+        kind: 'exact',
+        path: `${WORKSPACE_MODEL_PREFIX}/clear`,
+        handler: async (req, res) => {
+            if (req.method === 'OPTIONS') {
+                handleOptions(res);
+                return;
+            }
+            if (req.method !== 'POST') {
+                writeJson(res, 405, BAD_REQUEST);
+                return;
+            }
+            if (!canMutate(req)) {
+                writeJson(res, 403, FORBIDDEN);
+                return;
+            }
+            let body;
+            try {
+                body = await readJsonObject(req);
+            }
+            catch {
+                writeJson(res, 400, BAD_REQUEST);
+                return;
+            }
+            const path = stringField(body, 'path');
+            if (path === null) {
+                writeJson(res, 400, BAD_REQUEST);
+                return;
+            }
+            try {
+                const removed = await manager.clear(path);
+                respond(res, { ok: true, value: removed });
+            }
+            catch (error) {
+                writeJson(res, 500, { ok: false, code: 'bad-request', message: error instanceof Error ? error.message : String(error) });
+            }
+        },
+    }));
+}

package/lib/types/host/services/worktree/workspace-model.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Host workspace-model manager: owns the workspace-granularity model preset
+ * document. Presets are stored in a plugin-own settings namespace
+ * (`workspace-model`) as a `{ [canonicalPath]: { provider, model, effort? } }`
+ * map, so a single user-editable document is the source of truth across
+ * machines and reloads.
+ *
+ * The settings service is optional: when no settings provider is mounted the
+ * manager degrades to an in-memory-only store (model presets still apply for
+ * the process lifetime, just not durable) rather than failing to mount.
+ * @module dsh-client-ui-worktree/host/workspace-model
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import z from 'schemastery';
+import type { WorkspaceModelPreset, WorkspacePresetMap } from '../../../core/worktree/workspace-model.ts';
+/** Settings namespace unique to this plugin. */
+export declare const WORKSPACE_MODEL_NS = "workspace-model";
+/** Schemastery schema for the preset document (a path -> preset map). */
+export declare const WorkspacePresetSchema: z<WorkspacePresetMap>;
+/** Canonicalize a workspace path for use as a document key. Follows symlinks
+ *  via realpath and strips a trailing separator, matching how the workspace
+ *  registry records paths and how sessions record `cwd`. The root path `/`
+ *  is preserved (and is the only case where stripping the trailing separator
+ *  is a no-op, because paths must be non-empty when used as a key). */
+export declare function canonicalWorkspacePath(path: string): string;
+/** Public surface used by `routes.ts` and the agent wiring. */
+export declare class WorkspaceModelManager {
+    private readonly ctx;
+    private settings;
+    private memory;
+    private settingsFiber;
+    dispose(): void;
+    /** Optional settings service; safe to call with an unmounted provider. */
+    constructor(ctx: Context);
+    /** Wire the workspace-model namespace to the 0.2 settings document. */
+    private installSettings;
+    /** Replace the in-memory mirror from a resolved document. */
+    private seedMemory;
+    /** All stored presets keyed by canonical path (read snapshot). */
+    list(): Record<string, WorkspaceModelPreset>;
+    /** The preset for one workspace path, or undefined when none. */
+    get(path: string): WorkspaceModelPreset | undefined;
+    /** Store a preset for one workspace path. Returns the stored preset. */
+    set(path: string, preset: WorkspaceModelPreset): Promise<WorkspaceModelPreset>;
+    /** Remove a workspace's preset if present. Returns true when removed. */
+    clear(path: string): Promise<boolean>;
+}
+//# sourceMappingURL=workspace-model.d.ts.map

package/lib/types/host/services/worktree/workspace-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-model.d.ts","sourceRoot":"","sources":["../../../../../src/host/services/worktree/workspace-model.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAGlD,OAAO,CAAC,MAAM,aAAa,CAAA;AAC3B,OAAO,KAAK,EACV,oBAAoB,EAAE,kBAAkB,EACzC,MAAM,2CAA2C,CAAA;AAElD,gDAAgD;AAChD,eAAO,MAAM,kBAAkB,oBAAoB,CAAA;AAEnD,yEAAyE;AACzE,eAAO,MAAM,qBAAqB,EAIJ,CAAC,CAAC,kBAAkB,CAAC,CAAA;AAQnD;;;;uEAIuE;AACvE,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAW3D;AAID,+DAA+D;AAC/D,qBAAa,qBAAqB;IAYpB,OAAO,CAAC,QAAQ,CAAC,GAAG;IAXhC,OAAO,CAAC,QAAQ,CAA4B;IAC5C,OAAO,CAAC,MAAM,CAA0C;IACxD,OAAO,CAAC,aAAa,CAAiD;IAEtE,OAAO,IAAI,IAAI;IAMf,0EAA0E;gBAC7C,GAAG,EAAE,OAAO;IAIzC,uEAAuE;IACvE,OAAO,CAAC,eAAe;IAavB,6DAA6D;IAC7D,OAAO,CAAC,UAAU;IAIlB,kEAAkE;IAClE,IAAI,IAAI,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC;IAI5C,iEAAiE;IACjE,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,oBAAoB,GAAG,SAAS;IAInD,wEAAwE;IAClE,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,oBAAoB,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAYpF,yEAAyE;IACnE,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;CAa5C"}