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

package/lib/types/host/services/worktree/git.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Host git subprocess plumbing for the worktree manager. We reuse the
+ * shared runner seam (`@deepseek-ai/dsh-subprocess`) the family already
+ * uses for git operations; this file only owns the worktree-specific git
+ * argv builders so the service layer stays declarative.
+ * @module dsh-client-ui-worktree/host/git
+ */
+import type { GitRunner } from './git-runner.ts';
+/** win32 ships git as git.exe (git for Windows); the .cmd/.bat shim in
+ *  PATH would otherwise be the resolution target and Node's spawn cannot
+ *  launch a .cmd file directly. Naming git.exe bypasses any shim and
+ *  always hits the native executable. cmd.exe routing is deliberately
+ *  NOT used: several git args carry %-format specs (--format on
+ *  for-each-ref / log) that cmd would expand and corrupt. */
+export declare function gitSpawnArgv(platform: NodeJS.Platform, argv: readonly string[]): readonly string[];
+/** `git rev-parse --path-format=absolute --git-common-dir` — used to map any
+ *  worktree back to its main repo. */
+export declare const GIT_COMMON_DIR_ARGV: readonly ["rev-parse", "--path-format=absolute", "--git-common-dir"];
+/** `git worktree list --porcelain` — the canonical list of linked worktrees
+ *  with their branch, HEAD, and on-disk path. */
+export declare const WORKTREE_LIST_ARGV: readonly ["worktree", "list", "--porcelain"];
+/** `git symbolic-ref -q --short HEAD` — current branch, empty when detached. */
+export declare const HEAD_BRANCH_ARGV: readonly ["symbolic-ref", "-q", "--short", "HEAD"];
+/** `git rev-parse --short HEAD` — used when detached. */
+export declare const HEAD_SHORT_ARGV: readonly ["rev-parse", "--short", "HEAD"];
+/** `git status --porcelain` — used for the dirty count. */
+export declare const STATUS_PORCELAIN_ARGV: readonly ["status", "--porcelain"];
+/**
+ * `git worktree add [-b <branch>] [--detach] <path> [<commit-ish>]` — the
+ * create argv. `branch` cuts a new branch at `commitIsh` and checks it out
+ * in the linked worktree; without it git checks out `commitIsh` itself, and
+ * a commit-ish that is not a branch name leaves a DETACHED HEAD. A detached
+ * worktree cannot be pushed (`git push -u origin <branch>` needs a local
+ * branch) or matched by `git worktree list --porcelain`, so every
+ * session-bound lane must pass `branch`.
+ *
+ * `-b` and `--detach` are mutually exclusive in git; passing both is a
+ * programmer error and throws rather than silently dropping one.
+ */
+export declare function worktreeAddArgv(path: string, commitIsh: string, detach: boolean, branch?: string): readonly string[];
+/**
+ * `git check-ignore -q <path>` — exit 0 when the path is ignored by the
+ * repository's ignore rules. Used to refuse creating a lane before the
+ * lane root is ignored, so an unignored `<repo>/.dsh/workspaces/` can never
+ * be swept into the main checkout by a `git add -A`.
+ */
+export declare function checkIgnoreArgv(path: string): readonly string[];
+/** `git worktree remove [--force] <path>` — the remove argv. */
+export declare function worktreeRemoveArgv(path: string, force: boolean): readonly string[];
+/** `git worktree prune` — drop stale administrative records. */
+export declare const WORKTREE_PRUNE_ARGV: readonly ["worktree", "prune"];
+/** `git worktree list --porcelain` invocation helper. */
+export declare function worktreeListPorcelain(): readonly string[];
+/** `git init -b <initialBranch>` — used for `POST /worktree/init`. */
+export declare function gitInitArgv(initialBranch: string): readonly string[];
+/** `git rev-parse --verify --quiet refs/heads/<branch>` — branch exists check. */
+export declare function verifyRefArgv(branch: string): readonly string[];
+/** `git branch <name> [<start>]` — create branch from start point. */
+export declare function createBranchArgv(name: string, start?: string): readonly string[];
+/** `git remote` — list configured remotes (we look for `origin`). */
+export declare const REMOTE_LIST_ARGV: readonly ["remote"];
+/** `git remote get-url <name>` — the remote URL for compare-URL / API derivation. */
+export declare function remoteGetUrlArgv(name: string): readonly string[];
+/** `git push -u origin <branch>` — push and set upstream. */
+export declare function pushUpstreamArgv(branch: string): readonly string[];
+/** `git ls-remote --exit-code origin refs/heads/<branch>` — remote branch existence probe. */
+export declare function lsRemoteBranchArgv(branch: string): readonly string[];
+/** `git fetch origin --prune` — sync remote-tracking refs and drop deleted ones. */
+export declare const FETCH_PRUNE_ARGV: readonly ["fetch", "origin", "--prune"];
+/** `git merge-base --is-ancestor <candidate> <base>` — merge detection (exit 0 = ancestor). */
+export declare function mergeBaseIsAncestorArgv(candidate: string, base: string): readonly string[];
+/** `git rev-parse --verify --quiet refs/remotes/origin/<branch>` — pushed probe. */
+export declare function verifyRemoteRefArgv(branch: string): readonly string[];
+/** `git symbolic-ref refs/remotes/origin/HEAD` — remote default branch probe (fails when unset). */
+export declare const REMOTE_HEAD_REF: "refs/remotes/origin/HEAD";
+export declare const REMOTE_HEAD_ARGV: readonly ["symbolic-ref", "refs/remotes/origin/HEAD"];
+/** `git branch -d|-D <branch>` — delete the local branch (refuses unmerged without -D). */
+export declare function branchDeleteArgv(branch: string, force: boolean): readonly string[];
+/** `git for-each-ref refs/heads refs/remotes/origin --format=%(refname:short)` —
+ *  candidate branches for the create/PR dialog dropdowns. Local branches
+ *  come first, then remote-tracking `origin/*` names (prefix stripped). */
+export declare const BRANCH_LIST_ARGV: readonly ["for-each-ref", "refs/heads", "refs/remotes/origin", "--format=%(refname:short)"];
+/**
+ * Parse `git for-each-ref` output into a deduplicated short-name list:
+ * local branches in listing order first, then `origin/*` remote-tracking
+ * names with the `origin/` prefix stripped (skipping duplicates already
+ * seen locally, so `dev` + `origin/dev` collapse to one entry).
+ */
+export declare function parseBranchList(stdout: string): string[];
+/** Strip a leading `origin/` from a remote-tracking short ref. */
+export declare function stripOriginPrefix(ref: string): string;
+/** Re-export the shared runner type for callers. */
+export type { GitRunner };
+//# sourceMappingURL=git.d.ts.map

package/lib/types/host/services/worktree/git.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git.d.ts","sourceRoot":"","sources":["../../../../../src/host/services/worktree/git.ts"],"names":[],"mappings":"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"}

package/lib/types/host/services/worktree/git.js

@@ -0,0 +1,153 @@
+/**
+ * Host git subprocess plumbing for the worktree manager. We reuse the
+ * shared runner seam (`@deepseek-ai/dsh-subprocess`) the family already
+ * uses for git operations; this file only owns the worktree-specific git
+ * argv builders so the service layer stays declarative.
+ * @module dsh-client-ui-worktree/host/git
+ */
+/** win32 ships git as git.exe (git for Windows); the .cmd/.bat shim in
+ *  PATH would otherwise be the resolution target and Node's spawn cannot
+ *  launch a .cmd file directly. Naming git.exe bypasses any shim and
+ *  always hits the native executable. cmd.exe routing is deliberately
+ *  NOT used: several git args carry %-format specs (--format on
+ *  for-each-ref / log) that cmd would expand and corrupt. */
+export function gitSpawnArgv(platform, argv) {
+    return platform === 'win32' ? ['git.exe', ...argv] : ['git', ...argv];
+}
+/** `git rev-parse --path-format=absolute --git-common-dir` — used to map any
+ *  worktree back to its main repo. */
+export const GIT_COMMON_DIR_ARGV = ['rev-parse', '--path-format=absolute', '--git-common-dir'];
+/** `git worktree list --porcelain` — the canonical list of linked worktrees
+ *  with their branch, HEAD, and on-disk path. */
+export const WORKTREE_LIST_ARGV = ['worktree', 'list', '--porcelain'];
+/** `git symbolic-ref -q --short HEAD` — current branch, empty when detached. */
+export const HEAD_BRANCH_ARGV = ['symbolic-ref', '-q', '--short', 'HEAD'];
+/** `git rev-parse --short HEAD` — used when detached. */
+export const HEAD_SHORT_ARGV = ['rev-parse', '--short', 'HEAD'];
+/** `git status --porcelain` — used for the dirty count. */
+export const STATUS_PORCELAIN_ARGV = ['status', '--porcelain'];
+/**
+ * `git worktree add [-b <branch>] [--detach] <path> [<commit-ish>]` — the
+ * create argv. `branch` cuts a new branch at `commitIsh` and checks it out
+ * in the linked worktree; without it git checks out `commitIsh` itself, and
+ * a commit-ish that is not a branch name leaves a DETACHED HEAD. A detached
+ * worktree cannot be pushed (`git push -u origin <branch>` needs a local
+ * branch) or matched by `git worktree list --porcelain`, so every
+ * session-bound lane must pass `branch`.
+ *
+ * `-b` and `--detach` are mutually exclusive in git; passing both is a
+ * programmer error and throws rather than silently dropping one.
+ */
+export function worktreeAddArgv(path, commitIsh, detach, branch) {
+    if (detach && branch !== undefined) {
+        throw new Error('worktreeAddArgv: --detach and -b are mutually exclusive');
+    }
+    const argv = ['worktree', 'add'];
+    if (detach)
+        argv.push('--detach');
+    if (branch !== undefined)
+        argv.push('-b', branch);
+    argv.push(path, commitIsh);
+    return argv;
+}
+/**
+ * `git check-ignore -q <path>` — exit 0 when the path is ignored by the
+ * repository's ignore rules. Used to refuse creating a lane before the
+ * lane root is ignored, so an unignored `<repo>/.dsh/workspaces/` can never
+ * be swept into the main checkout by a `git add -A`.
+ */
+export function checkIgnoreArgv(path) {
+    return ['check-ignore', '-q', path];
+}
+/** `git worktree remove [--force] <path>` — the remove argv. */
+export function worktreeRemoveArgv(path, force) {
+    const argv = ['worktree', 'remove'];
+    if (force)
+        argv.push('--force');
+    argv.push(path);
+    return argv;
+}
+/** `git worktree prune` — drop stale administrative records. */
+export const WORKTREE_PRUNE_ARGV = ['worktree', 'prune'];
+/** `git worktree list --porcelain` invocation helper. */
+export function worktreeListPorcelain() {
+    return WORKTREE_LIST_ARGV;
+}
+/** `git init -b <initialBranch>` — used for `POST /worktree/init`. */
+export function gitInitArgv(initialBranch) {
+    return ['init', '-b', initialBranch];
+}
+/** `git rev-parse --verify --quiet refs/heads/<branch>` — branch exists check. */
+export function verifyRefArgv(branch) {
+    return ['rev-parse', '--verify', '--quiet', `refs/heads/${branch}`];
+}
+/** `git branch <name> [<start>]` — create branch from start point. */
+export function createBranchArgv(name, start) {
+    const argv = ['branch', name];
+    if (start !== undefined)
+        argv.push(start);
+    return argv;
+}
+/** `git remote` — list configured remotes (we look for `origin`). */
+export const REMOTE_LIST_ARGV = ['remote'];
+/** `git remote get-url <name>` — the remote URL for compare-URL / API derivation. */
+export function remoteGetUrlArgv(name) {
+    return ['remote', 'get-url', name];
+}
+/** `git push -u origin <branch>` — push and set upstream. */
+export function pushUpstreamArgv(branch) {
+    return ['push', '-u', 'origin', branch];
+}
+/** `git ls-remote --exit-code origin refs/heads/<branch>` — remote branch existence probe. */
+export function lsRemoteBranchArgv(branch) {
+    return ['ls-remote', '--exit-code', 'origin', `refs/heads/${branch}`];
+}
+/** `git fetch origin --prune` — sync remote-tracking refs and drop deleted ones. */
+export const FETCH_PRUNE_ARGV = ['fetch', 'origin', '--prune'];
+/** `git merge-base --is-ancestor <candidate> <base>` — merge detection (exit 0 = ancestor). */
+export function mergeBaseIsAncestorArgv(candidate, base) {
+    return ['merge-base', '--is-ancestor', candidate, base];
+}
+/** `git rev-parse --verify --quiet refs/remotes/origin/<branch>` — pushed probe. */
+export function verifyRemoteRefArgv(branch) {
+    return ['rev-parse', '--verify', '--quiet', `refs/remotes/origin/${branch}`];
+}
+/** `git symbolic-ref refs/remotes/origin/HEAD` — remote default branch probe (fails when unset). */
+export const REMOTE_HEAD_REF = 'refs/remotes/origin/HEAD';
+export const REMOTE_HEAD_ARGV = ['symbolic-ref', REMOTE_HEAD_REF];
+/** `git branch -d|-D <branch>` — delete the local branch (refuses unmerged without -D). */
+export function branchDeleteArgv(branch, force) {
+    return ['branch', force ? '-D' : '-d', branch];
+}
+/** `git for-each-ref refs/heads refs/remotes/origin --format=%(refname:short)` —
+ *  candidate branches for the create/PR dialog dropdowns. Local branches
+ *  come first, then remote-tracking `origin/*` names (prefix stripped). */
+export const BRANCH_LIST_ARGV = [
+    'for-each-ref', 'refs/heads', 'refs/remotes/origin',
+    '--format=%(refname:short)',
+];
+/**
+ * Parse `git for-each-ref` output into a deduplicated short-name list:
+ * local branches in listing order first, then `origin/*` remote-tracking
+ * names with the `origin/` prefix stripped (skipping duplicates already
+ * seen locally, so `dev` + `origin/dev` collapse to one entry).
+ */
+export function parseBranchList(stdout) {
+    const seen = new Set();
+    const out = [];
+    for (const raw of stdout.split('\n')) {
+        const line = raw.replace(/\r$/, '').trim();
+        if (line === '' || line === 'origin/HEAD')
+            continue;
+        const name = stripOriginPrefix(line);
+        if (name === '' || seen.has(name))
+            continue;
+        seen.add(name);
+        out.push(name);
+    }
+    return out;
+}
+/** Strip a leading `origin/` from a remote-tracking short ref. */
+export function stripOriginPrefix(ref) {
+    return ref.startsWith('origin/') ? ref.slice('origin/'.length) : ref;
+}

package/lib/types/host/services/worktree/http.d.ts

@@ -0,0 +1,12 @@
+/**
+ * JSON request/response helpers. Kept tiny on purpose; the manager layer
+ * owns the response shape (`MutationResult` / `WorktreeErrorView`) and the
+ * route layer only does envelope + status code translation.
+ * @module dsh-client-ui-worktree/host/http
+ */
+import type { IncomingMessage, ServerResponse } from 'node:http';
+/** Read a JSON object body. Returns `null` for empty bodies, throws otherwise. */
+export declare function readJsonObject(req: IncomingMessage, limit?: number): Promise<Record<string, unknown> | null>;
+/** Write a JSON response with the given status. */
+export declare function writeJson(res: ServerResponse, status: number, payload: unknown): void;
+//# sourceMappingURL=http.d.ts.map

package/lib/types/host/services/worktree/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../../../../src/host/services/worktree/http.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,WAAW,CAAA;AAEhE,kFAAkF;AAClF,wBAAsB,cAAc,CAAC,GAAG,EAAE,eAAe,EAAE,KAAK,SAAc,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC,CAmBvH;AAED,mDAAmD;AACnD,wBAAgB,SAAS,CAAC,GAAG,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,CAGrF"}

package/lib/types/host/services/worktree/http.js

@@ -0,0 +1,34 @@
+/**
+ * JSON request/response helpers. Kept tiny on purpose; the manager layer
+ * owns the response shape (`MutationResult` / `WorktreeErrorView`) and the
+ * route layer only does envelope + status code translation.
+ * @module dsh-client-ui-worktree/host/http
+ */
+/** Read a JSON object body. Returns `null` for empty bodies, throws otherwise. */
+export async function readJsonObject(req, limit = 1024 * 1024) {
+    const chunks = [];
+    let received = 0;
+    for await (const chunk of req) {
+        received += chunk.length;
+        if (received > limit) {
+            req.destroy();
+            throw new Error('request body too large');
+        }
+        chunks.push(chunk);
+    }
+    if (received === 0)
+        return null;
+    const text = Buffer.concat(chunks).toString('utf8');
+    if (text.trim() === '')
+        return null;
+    const parsed = JSON.parse(text);
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error('expected JSON object body');
+    }
+    return parsed;
+}
+/** Write a JSON response with the given status. */
+export function writeJson(res, status, payload) {
+    res.writeHead(status, { 'content-type': 'application/json; charset=utf-8' });
+    res.end(JSON.stringify(payload));
+}

package/lib/types/host/services/worktree/index.d.ts

@@ -0,0 +1,38 @@
+/** Mature worktree service domain mounted inside the single web-all Cordis row. */
+import type { Context } from '@deepseek-ai/cordis';
+import { WorktreeManager } from './manager.ts';
+export { API_PREFIX as WORKTREE_API_PREFIX } from './routes.ts';
+export { WORKSPACE_MODEL_PREFIX } from './workspace-model-routes.ts';
+export interface WorktreeServiceConfig {
+    pr?: {
+        tokenEnv?: string;
+    };
+}
+/** The retirement faces this domain needs from the manager (structural, for tests). */
+export type LaneRetirementManager = Pick<WorktreeManager, 'retireArchivedLane' | 'reconcileLaneWorkspaces'>;
+/**
+ * Keep a lane's workspace registration as short-lived as the platform allows.
+ *
+ * The registration itself is unavoidable while the lane's conversation runs (the
+ * platform accounts a session to a workspace only when the session cwd equals
+ * that workspace's path, and a blank conversation no workspace accounts for has
+ * an inert composer), so the worktree's sidebar row is a platform requirement.
+ * What this owns is its LIFETIME: archiving the lane's conversation retires the
+ * registration, and a boot pass retires the rows an earlier build left behind.
+ * The directory, the branch and the binding stay, so the lane can be picked up
+ * again in one step.
+ *
+ * Both archive paths are covered: `workspace/session-activity` (the waterfall
+ * that runs before a non-forced archive write) and `workspace/session-stop`
+ * (dispatched once a forced archive is durable).
+ * @param ctx - registrant context.
+ * @param manager - the worktree manager owning the lanes.
+ * @returns the dispose function.
+ */
+export declare function installLaneWorkspaceRetirement(ctx: Context, manager: LaneRetirementManager): () => void;
+/** Register the shipped worktree, session-lane and workspace-model lifecycles. */
+export declare function register(ctx: Context, config?: WorktreeServiceConfig): () => void;
+export { WorktreeManager } from './manager.ts';
+export { SessionLaneManager, LANE_PERMISSION_PRESET } from './session-lane/manager.ts';
+export { WorkspaceModelManager } from './workspace-model.ts';
+//# sourceMappingURL=index.d.ts.map

package/lib/types/host/services/worktree/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/host/services/worktree/index.ts"],"names":[],"mappings":"AAAA,mFAAmF;AACnF,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAGlD,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAS9C,OAAO,EAAE,UAAU,IAAI,mBAAmB,EAAE,MAAM,aAAa,CAAA;AAC/D,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAA;AAEpE,MAAM,WAAW,qBAAqB;IACpC,EAAE,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;CAC3B;AAED,uFAAuF;AACvF,MAAM,MAAM,qBAAqB,GAAG,IAAI,CAAC,eAAe,EAAE,oBAAoB,GAAG,yBAAyB,CAAC,CAAA;AAS3G;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,8BAA8B,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,qBAAqB,GAAG,MAAM,IAAI,CAuBvG;AAED,kFAAkF;AAClF,wBAAgB,QAAQ,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,GAAE,qBAA0B,GAAG,MAAM,IAAI,CAYrF;AAED,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAC9C,OAAO,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAA;AACtF,OAAO,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAA"}

package/lib/types/host/services/worktree/index.js

@@ -0,0 +1,78 @@
+import { WorktreeManager } from "./manager.js";
+import { registerResources } from "../resources.js";
+import { registerWorktreeRoutes } from "./routes.js";
+import { SessionLaneManager } from "./session-lane/manager.js";
+import { registerLaneTool } from "./lane-tool.js";
+import { WorkspaceModelManager } from "./workspace-model.js";
+import { registerWorkspaceModelRoutes } from "./workspace-model-routes.js";
+import { installWorkspaceModelAgentOverride } from "./model-override.js";
+export { API_PREFIX as WORKTREE_API_PREFIX } from "./routes.js";
+export { WORKSPACE_MODEL_PREFIX } from "./workspace-model-routes.js";
+/** Fire-and-forget retirement; a failure is logged, never thrown into the archive path. */
+function retireLane(manager, sessionId) {
+    void manager.retireArchivedLane(sessionId).catch((error) => {
+        console.warn('[dsh-worktree] lane workspace retirement failed:', error);
+    });
+}
+/**
+ * Keep a lane's workspace registration as short-lived as the platform allows.
+ *
+ * The registration itself is unavoidable while the lane's conversation runs (the
+ * platform accounts a session to a workspace only when the session cwd equals
+ * that workspace's path, and a blank conversation no workspace accounts for has
+ * an inert composer), so the worktree's sidebar row is a platform requirement.
+ * What this owns is its LIFETIME: archiving the lane's conversation retires the
+ * registration, and a boot pass retires the rows an earlier build left behind.
+ * The directory, the branch and the binding stay, so the lane can be picked up
+ * again in one step.
+ *
+ * Both archive paths are covered: `workspace/session-activity` (the waterfall
+ * that runs before a non-forced archive write) and `workspace/session-stop`
+ * (dispatched once a forced archive is durable).
+ * @param ctx - registrant context.
+ * @param manager - the worktree manager owning the lanes.
+ * @returns the dispose function.
+ */
+export function installLaneWorkspaceRetirement(ctx, manager) {
+    return registerResources(own => {
+        own(ctx.on('workspace/session-activity', async (request, next) => {
+            const activity = await next();
+            // The waterfall runs BEFORE the durable write: a request refused for running
+            // work never lands, and the retirement polls the archive set to tell.
+            if (activity.length === 0)
+                retireLane(manager, request.sessionId);
+            return activity;
+        }));
+        own(ctx.on('workspace/session-stop', (request) => {
+            // The archive set is durable by the time this dispatches.
+            retireLane(manager, request.sessionId);
+        }));
+        // The workspace registry initializes asynchronously; the boot pass runs once it
+        // is there. The injected fiber follows the ctx lifetime, like every other
+        // service wait in this domain.
+        const fiber = ctx.inject(['workspaceRegistry'], () => {
+            void manager.reconcileLaneWorkspaces().catch((error) => {
+                console.warn('[dsh-worktree] lane workspace reconciliation failed:', error);
+            });
+        });
+        if (fiber)
+            own(() => { void fiber.dispose(); });
+    });
+}
+/** Register the shipped worktree, session-lane and workspace-model lifecycles. */
+export function register(ctx, config = {}) {
+    return registerResources(own => {
+        const manager = new WorktreeManager(ctx, { tokenEnv: config.pr?.tokenEnv });
+        const modelManager = new WorkspaceModelManager(ctx);
+        own(() => modelManager.dispose());
+        const laneManager = new SessionLaneManager(ctx, manager);
+        own(registerWorktreeRoutes(ctx, manager, laneManager));
+        own(registerWorkspaceModelRoutes(ctx, modelManager));
+        own(installWorkspaceModelAgentOverride(ctx, modelManager));
+        own(registerLaneTool(ctx, manager));
+        own(installLaneWorkspaceRetirement(ctx, manager));
+    });
+}
+export { WorktreeManager } from "./manager.js";
+export { SessionLaneManager, LANE_PERMISSION_PRESET } from "./session-lane/manager.js";
+export { WorkspaceModelManager } from "./workspace-model.js";

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

@@ -0,0 +1,22 @@
+/**
+ * `worktree_lane` — the one agent-facing surface of the lane model.
+ *
+ * A conversation can carry a lane even when its cwd is not the lane directory:
+ * a blank conversation is moved onto the lane at creation (cwd IS the lane),
+ * while a conversation that already has turns keeps its cwd and merely carries
+ * the lane. Tools do not see the header chip, so the agent must be able to ask
+ * where its lane is before running git commands — otherwise it would operate on
+ * the main checkout while the branch lives in a linked worktree.
+ *
+ * Resolution is exactly the host's `laneForPath({ sessionId })`, which first
+ * checks the session cwd and then falls back to the manifest binding.
+ * @module dsh-client-ui-worktree/host/lane-tool
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { WorktreeManager } from './manager.ts';
+export declare const LANE_TOOL_NAME = "worktree_lane";
+/** The agent-facing tool definition (registered via `ctx.tools.register`). */
+export declare function makeLaneTool(worktrees: WorktreeManager): import("@deepseek-ai/dsh-tools").ToolDefinition;
+/** Register the lane tool, degrading silently when the tools service is absent. */
+export declare function registerLaneTool(ctx: Context, worktrees: WorktreeManager): () => void;
+//# sourceMappingURL=lane-tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lane-tool.d.ts","sourceRoot":"","sources":["../../../../../src/host/services/worktree/lane-tool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAElD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAOnD,eAAO,MAAM,cAAc,kBAAkB,CAAA;AAE7C,8EAA8E;AAC9E,wBAAgB,YAAY,CAAC,SAAS,EAAE,eAAe,mDA8DtD;AAED,mFAAmF;AACnF,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,EAAE,SAAS,EAAE,eAAe,GAAG,MAAM,IAAI,CAOrF"}

package/lib/types/host/services/worktree/lane-tool.js

@@ -0,0 +1,92 @@
+/**
+ * `worktree_lane` — the one agent-facing surface of the lane model.
+ *
+ * A conversation can carry a lane even when its cwd is not the lane directory:
+ * a blank conversation is moved onto the lane at creation (cwd IS the lane),
+ * while a conversation that already has turns keeps its cwd and merely carries
+ * the lane. Tools do not see the header chip, so the agent must be able to ask
+ * where its lane is before running git commands — otherwise it would operate on
+ * the main checkout while the branch lives in a linked worktree.
+ *
+ * Resolution is exactly the host's `laneForPath({ sessionId })`, which first
+ * checks the session cwd and then falls back to the manifest binding.
+ * @module dsh-client-ui-worktree/host/lane-tool
+ */
+import { defineTool } from '@deepseek-ai/dsh-tools';
+export const LANE_TOOL_NAME = 'worktree_lane';
+/** The agent-facing tool definition (registered via `ctx.tools.register`). */
+export function makeLaneTool(worktrees) {
+    return defineTool({
+        name: LANE_TOOL_NAME,
+        description: 'Report the worktree lane bound to this conversation: the branch and the '
+            + 'directory it checks out. When a repository isolates branches into '
+            + 'linked worktrees (under `<repo>/.dsh/workspaces/<branch>`), the reported '
+            + 'directory is where this conversation\u2019s git work must happen. Returns '
+            + 'lane:null when the conversation works on the main checkout.',
+        parameters: {},
+        output: {
+            schema: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    lane: {
+                        oneOf: [
+                            {
+                                type: 'object',
+                                additionalProperties: false,
+                                properties: {
+                                    branch: { type: 'string', required: true },
+                                    path: { type: 'string', required: true },
+                                    repoPath: { type: 'string', required: true },
+                                },
+                            },
+                            { type: 'null' },
+                        ],
+                    },
+                    note: { type: 'string' },
+                },
+            },
+            render: (_args, value) => [{ type: 'text', text: JSON.stringify(value) }],
+        },
+        async execute(_args, exec) {
+            const session = exec.agent?.session?.header;
+            const sessionId = session?.id;
+            if (typeof sessionId !== 'string' || sessionId === '') {
+                return {
+                    lane: null,
+                    note: 'no session context; call this tool from a conversation',
+                };
+            }
+            const lane = await worktrees.laneForPath({ sessionId });
+            if (lane === null) {
+                return {
+                    lane: null,
+                    note: 'this conversation works on the main checkout of its repository',
+                };
+            }
+            return {
+                lane: {
+                    branch: lane.branch ?? lane.name,
+                    path: lane.path,
+                    repoPath: lane.repoPath,
+                },
+            };
+        },
+        presentCall(args) {
+            return { card: 'generic', title: 'Worktree lane lookup', kind: 'read', rawInput: args };
+        },
+    });
+}
+/** Register the lane tool, degrading silently when the tools service is absent. */
+export function registerLaneTool(ctx, worktrees) {
+    try {
+        const dispose = ctx.tools.register(makeLaneTool(worktrees));
+        return () => { try {
+            dispose();
+        }
+        catch { /* tolerant */ } };
+    }
+    catch {
+        return () => { };
+    }
+}