@ohzw/worktree-command-tui 0.1.0 → 0.1.2

package/dist/core/git-metadata.d.ts

@@ -0,0 +1,25 @@
+export interface UpstreamInfo {
+    branch: string;
+    ahead: number;
+    behind: number;
+}
+export interface WorkingTreeInfo {
+    staged: number;
+    unstaged: number;
+    untracked: number;
+    conflicts: number;
+}
+export interface GitStatusSummary {
+    upstream?: UpstreamInfo;
+    upstreamUnavailable: boolean;
+    workingTree?: WorkingTreeInfo;
+}
+export interface RepoContext {
+    workspaceRoot: string;
+    mainWorktreePath: string;
+    gitCommonDir: string;
+}
+export declare function parseGitStatusSummary(output: string): GitStatusSummary;
+export declare function readGitStatusSummary(cwd: string): Promise<GitStatusSummary>;
+export declare function readBranchCreatedAtMs(cwd: string, branch: string): Promise<number | null>;
+export declare function resolveRepoContext(cwd: string): Promise<RepoContext>;

package/dist/core/git-metadata.js

@@ -0,0 +1,84 @@
+import path from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+function createEmptyWorkingTree() {
+    return { staged: 0, unstaged: 0, untracked: 0, conflicts: 0 };
+}
+export function parseGitStatusSummary(output) {
+    const workingTree = createEmptyWorkingTree();
+    let upstreamBranch;
+    let ahead = 0;
+    let behind = 0;
+    for (const line of output.split('\n')) {
+        if (line.startsWith('# branch.upstream ')) {
+            upstreamBranch = line.slice('# branch.upstream '.length).trim();
+            continue;
+        }
+        if (line.startsWith('# branch.ab ')) {
+            const match = /# branch\.ab \+(\d+) -(\d+)/.exec(line);
+            ahead = Number(match?.[1] ?? 0);
+            behind = Number(match?.[2] ?? 0);
+            continue;
+        }
+        if (line.startsWith('1 ') || line.startsWith('2 ')) {
+            const [, xy = '..'] = line.split(' ', 3);
+            if (xy[0] !== '.') {
+                workingTree.staged += 1;
+            }
+            if (xy[1] !== '.') {
+                workingTree.unstaged += 1;
+            }
+            continue;
+        }
+        if (line.startsWith('u ')) {
+            workingTree.conflicts += 1;
+            continue;
+        }
+        if (line.startsWith('? ')) {
+            workingTree.untracked += 1;
+        }
+    }
+    return {
+        upstream: upstreamBranch ? { branch: upstreamBranch, ahead, behind } : undefined,
+        upstreamUnavailable: false,
+        workingTree,
+    };
+}
+export async function readGitStatusSummary(cwd) {
+    try {
+        const { stdout } = await execFileAsync('git', ['status', '--branch', '--porcelain=v2'], { cwd });
+        return parseGitStatusSummary(stdout);
+    }
+    catch {
+        return { upstreamUnavailable: true };
+    }
+}
+export async function readBranchCreatedAtMs(cwd, branch) {
+    if (branch.startsWith('(')) {
+        return null;
+    }
+    try {
+        const { stdout } = await execFileAsync('git', ['reflog', 'show', '--format=%ct', `refs/heads/${branch}`], { cwd });
+        const trimmed = stdout.trim();
+        if (trimmed.length === 0) {
+            return null;
+        }
+        const timestamps = trimmed.split('\n');
+        const firstTimestampSeconds = Number(timestamps.at(-1));
+        return Number.isFinite(firstTimestampSeconds) ? firstTimestampSeconds * 1000 : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function resolveRepoContext(cwd) {
+    const [{ stdout: workspaceRootRaw }, { stdout: gitCommonDirRaw }] = await Promise.all([
+        execFileAsync('git', ['rev-parse', '--show-toplevel'], { cwd }),
+        execFileAsync('git', ['rev-parse', '--git-common-dir'], { cwd }),
+    ]);
+    const workspaceRoot = workspaceRootRaw.trim();
+    const gitCommonDir = path.resolve(workspaceRoot, gitCommonDirRaw.trim());
+    const mainWorktreePath = path.dirname(gitCommonDir);
+    return { workspaceRoot, mainWorktreePath, gitCommonDir };
+}

package/dist/core/git-worktrees.d.ts

@@ -4,8 +4,9 @@ export interface WorktreeRow {
     headSha: string;
     isMain: boolean;
     isExternal: boolean;
+    createdAtMs: number | null;
 }
 export declare function parseWorktreeListPorcelain(input: string, mainWorktreePath: string): WorktreeRow[];
-export declare function sortWorktrees(rows: WorktreeRow[], activePath: string | null): WorktreeRow[];
+export declare function sortWorktrees(rows: WorktreeRow[], _activePath: string | null): WorktreeRow[];
 export declare function readWorktrees(cwd: string, mainWorktreePath: string): Promise<WorktreeRow[]>;
 export declare function toShortPath(mainWorktreePath: string, worktreePath: string): string;

package/dist/core/git-worktrees.js

@@ -1,4 +1,5 @@
 import { execFile } from 'node:child_process';
+import { stat } from 'node:fs/promises';
 import path from 'node:path';
 import { promisify } from 'node:util';
 const execFileAsync = promisify(execFile);
@@ -28,26 +29,44 @@ export function parseWorktreeListPorcelain(input, mainWorktreePath) {
             headSha: headLine?.slice('HEAD '.length) ?? '',
             isMain: worktreePath === mainWorktreePath,
             isExternal: isExternalWorktree(mainWorktreePath, worktreePath),
+            createdAtMs: null,
         };
     });
 }
-export function sortWorktrees(rows, activePath) {
+function compareDeterministic(left, right) {
+    if (left.isMain !== right.isMain) {
+        return left.isMain ? -1 : 1;
+    }
+    const branchCompare = left.branch.localeCompare(right.branch);
+    return branchCompare !== 0 ? branchCompare : left.path.localeCompare(right.path);
+}
+export function sortWorktrees(rows, _activePath) {
+    const hasMissingCreatedAt = rows.some(row => row.createdAtMs === null);
     return [...rows].sort((left, right) => {
-        if (left.isMain !== right.isMain) {
-            return left.isMain ? -1 : 1;
-        }
-        const leftActive = activePath !== null && left.path === activePath;
-        const rightActive = activePath !== null && right.path === activePath;
-        if (leftActive !== rightActive) {
-            return leftActive ? -1 : 1;
+        const leftCreated = left.createdAtMs;
+        const rightCreated = right.createdAtMs;
+        if (!hasMissingCreatedAt && leftCreated !== null && rightCreated !== null && leftCreated !== rightCreated) {
+            return leftCreated - rightCreated;
         }
-        const branchCompare = left.branch.localeCompare(right.branch);
-        return branchCompare !== 0 ? branchCompare : left.path.localeCompare(right.path);
+        return compareDeterministic(left, right);
     });
 }
+async function readWorktreeCreatedAtMs(worktreePath) {
+    try {
+        const stats = await stat(worktreePath);
+        return stats.birthtimeMs;
+    }
+    catch {
+        return null;
+    }
+}
 export async function readWorktrees(cwd, mainWorktreePath) {
     const { stdout } = await execFileAsync('git', ['worktree', 'list', '--porcelain'], { cwd });
-    return parseWorktreeListPorcelain(stdout, mainWorktreePath);
+    const rows = parseWorktreeListPorcelain(stdout, mainWorktreePath);
+    return Promise.all(rows.map(async (row) => ({
+        ...row,
+        createdAtMs: await readWorktreeCreatedAtMs(row.path),
+    })));
 }
 export function toShortPath(mainWorktreePath, worktreePath) {
     if (worktreePath === mainWorktreePath) {

package/dist/core/github-metadata.d.ts

@@ -0,0 +1,14 @@
+export type PullRequestInfo = {
+    kind: 'found';
+    number: number;
+    title: string;
+    url: string;
+    state: 'OPEN' | 'CLOSED' | 'MERGED';
+    isDraft: boolean;
+    baseBranch: string;
+} | {
+    kind: 'none';
+} | {
+    kind: 'unavailable';
+};
+export declare function readPullRequestInfo(cwd: string, branch: string): Promise<PullRequestInfo>;

package/dist/core/github-metadata.js

@@ -0,0 +1,137 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+const GH_TIMEOUT_MS = 2500;
+const SCP_REMOTE_URL_RE = /^(?:[^@]+@)?([^:]+):(.+)$/;
+function splitRepositoryPath(pathInput) {
+    return pathInput
+        .replace(/\.git$/, '')
+        .replace(/^\/+/, '')
+        .replace(/\/+$/, '')
+        .split('/')
+        .filter(Boolean);
+}
+function parseGitHubRepositoryFromRemoteUrl(remoteUrl) {
+    const trimmedUrl = remoteUrl.trim();
+    if (!trimmedUrl) {
+        return null;
+    }
+    if (trimmedUrl.includes('://')) {
+        if (!URL.canParse(trimmedUrl)) {
+            return null;
+        }
+        const parsedUrl = new URL(trimmedUrl);
+        const segments = splitRepositoryPath(parsedUrl.pathname);
+        if (segments.length < 2) {
+            return null;
+        }
+        return { host: parsedUrl.hostname.toLowerCase(), owner: segments[0], name: segments[1] };
+    }
+    const scpMatch = SCP_REMOTE_URL_RE.exec(trimmedUrl);
+    if (!scpMatch) {
+        return null;
+    }
+    const segments = splitRepositoryPath(scpMatch[2]);
+    if (segments.length < 2) {
+        return null;
+    }
+    return { host: scpMatch[1].toLowerCase(), owner: segments[0], name: segments[1] };
+}
+async function readGitHubRepository(cwd) {
+    const { stdout } = await execFileAsync('git', ['config', '--get', 'remote.origin.url'], { cwd });
+    const repository = parseGitHubRepositoryFromRemoteUrl(stdout);
+    if (!repository) {
+        throw new Error('GitHub repository remote unavailable');
+    }
+    return repository;
+}
+function buildPullRequestListArgs(repository, branch, state) {
+    const args = [
+        'api',
+        '-X',
+        'GET',
+        `repos/${repository.owner}/${repository.name}/pulls`,
+        '-f',
+        `state=${state}`,
+        '-f',
+        `head=${repository.owner}:${branch}`,
+        '-F',
+        'per_page=1',
+    ];
+    if (repository.host !== 'github.com' && repository.host !== 'www.github.com') {
+        args.push('--hostname', repository.host);
+    }
+    return args;
+}
+function normalizePullRequestState(state, mergedAt) {
+    if (typeof state === 'string' && state.toUpperCase() === 'OPEN') {
+        return 'OPEN';
+    }
+    return typeof mergedAt === 'string' && mergedAt.length > 0 ? 'MERGED' : 'CLOSED';
+}
+function parsePullRequest(item) {
+    if (typeof item !== 'object' || item === null) {
+        return null;
+    }
+    const pullRequest = item;
+    const number = typeof pullRequest.number === 'number' ? pullRequest.number : NaN;
+    const title = typeof pullRequest.title === 'string' ? pullRequest.title : '';
+    const url = typeof pullRequest.html_url === 'string' ? pullRequest.html_url : '';
+    const isDraft = typeof pullRequest.draft === 'boolean' ? pullRequest.draft : false;
+    const baseRefName = typeof pullRequest.base?.ref === 'string' ? pullRequest.base.ref : '';
+    if (!Number.isFinite(number) || !title || !url || !baseRefName) {
+        return null;
+    }
+    return {
+        number,
+        title,
+        url,
+        state: normalizePullRequestState(pullRequest.state, pullRequest.merged_at),
+        isDraft,
+        baseRefName,
+    };
+}
+async function readPullRequestList(cwd, branch, state) {
+    const repository = await readGitHubRepository(cwd);
+    const args = buildPullRequestListArgs(repository, branch, state);
+    const { stdout } = await execFileAsync('gh', args, { cwd, timeout: GH_TIMEOUT_MS });
+    const payload = JSON.parse(stdout);
+    if (!Array.isArray(payload)) {
+        throw new Error('GitHub REST API returned unexpected payload');
+    }
+    const pullRequests = [];
+    for (const item of payload) {
+        const parsed = parsePullRequest(item);
+        if (parsed !== null) {
+            pullRequests.push(parsed);
+        }
+    }
+    return pullRequests;
+}
+export async function readPullRequestInfo(cwd, branch) {
+    if (branch.startsWith('(')) {
+        return { kind: 'none' };
+    }
+    try {
+        const openPullRequests = await readPullRequestList(cwd, branch, 'open');
+        const pullRequests = openPullRequests.length > 0
+            ? openPullRequests
+            : await readPullRequestList(cwd, branch, 'all');
+        const pullRequest = pullRequests[0];
+        if (!pullRequest) {
+            return { kind: 'none' };
+        }
+        return {
+            kind: 'found',
+            number: pullRequest.number,
+            title: pullRequest.title,
+            url: pullRequest.url,
+            state: pullRequest.state,
+            isDraft: pullRequest.isDraft,
+            baseBranch: pullRequest.baseRefName,
+        };
+    }
+    catch {
+        return { kind: 'unavailable' };
+    }
+}

package/dist/core/init.d.ts

@@ -1,6 +1,7 @@
-import { type ToolConfig } from './config.js';
+import type { ToolConfig } from './config.js';
+import { renderConfigJsonc } from './config-lifecycle.js';
+export { renderConfigJsonc };
 export declare function buildDefaultConfig(repoRoot: string): Promise<ToolConfig>;
-export declare function renderConfigJsonc(config: ToolConfig): string;
 export interface InitResult {
     path: string;
     config: ToolConfig;

package/dist/core/init.js

@@ -1,18 +1,11 @@
-import { access, readFile, writeFile } from 'node:fs/promises';
+import { access, readFile } from 'node:fs/promises';
 import { constants } from 'node:fs';
 import path from 'node:path';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
-import { CONFIG_FILE_NAME, CONFIG_FILE_NAMES } from './config.js';
+import { createDefaultToolConfig, renderConfigJsonc, writeToolConfigForRepo } from './config-lifecycle.js';
 const execFileAsync = promisify(execFile);
-function isSafeNamespace(value) {
-    return /^[A-Za-z0-9._-]+$/u.test(value);
-}
-function toSafeNamespace(value) {
-    const replaced = value.replace(/[^A-Za-z0-9._-]+/gu, '-');
-    const trimmed = replaced.replace(/^-+/, '').replace(/-+$/, '');
-    return trimmed.length > 0 && isSafeNamespace(trimmed) ? trimmed : 'worktree-command-tui';
-}
+export { renderConfigJsonc };
 async function resolveRepositoryRoot(cwd) {
     const { stdout } = await execFileAsync('git', ['rev-parse', '--show-toplevel'], { cwd });
     return stdout.trim();
@@ -85,56 +78,15 @@ function selectDefaultScript(scripts) {
 export async function buildDefaultConfig(repoRoot) {
     const packageJson = await readPackageJson(repoRoot);
     const packageManager = await detectPackageManager(repoRoot, packageJson);
-    const command = [packageManager, 'run', selectDefaultScript(packageJson?.scripts)];
-    const namespaceSeed = packageJson?.name ?? path.basename(repoRoot);
-    return {
-        namespace: toSafeNamespace(namespaceSeed),
-        command,
-        port: 3000,
-        requiredFiles: ['package.json'],
-        orphanMatchers: [],
-    };
-}
-export function renderConfigJsonc(config) {
-    return `{
-  // Session namespace used for git-common-dir state files and logs.
-  // Keep this filesystem-safe: letters, numbers, dots, underscores, and hyphens only.
-  "namespace": ${JSON.stringify(config.namespace)},
-
-  // Command launched in the selected worktree.
-  // Use argv form so spaces and shell metacharacters are passed safely.
-  "command": ${JSON.stringify(config.command)},
-
-  // TCP port owned by the command, used when stopping stale/orphaned processes.
-  "port": ${JSON.stringify(config.port)},
-
-  // Files that must exist in a worktree before the command can be started there.
-  "requiredFiles": ${JSON.stringify(config.requiredFiles)},
-
-  // Extra process command-line substrings treated as orphans for cleanup.
-  // Example: ["node --watch", "vite --host 0.0.0.0"]
-  "orphanMatchers": ${JSON.stringify(config.orphanMatchers)},
-}
-`;
-}
-async function findExistingConfigPath(workspaceRoot) {
-    for (const fileName of CONFIG_FILE_NAMES) {
-        const configPath = path.join(workspaceRoot, fileName);
-        if (await fileExists(configPath)) {
-            return configPath;
-        }
-    }
-    return null;
+    return createDefaultToolConfig({
+        namespaceSeed: packageJson?.name ?? path.basename(repoRoot),
+        packageManager,
+        script: selectDefaultScript(packageJson?.scripts),
+    });
 }
 export async function runInit(options) {
-    const configPath = path.join(options.workspaceRoot, CONFIG_FILE_NAME);
-    const existingConfigPath = await findExistingConfigPath(options.workspaceRoot);
-    if (!options.force && existingConfigPath) {
-        throw new Error(`Config file already exists: ${existingConfigPath}`);
-    }
     const config = await buildDefaultConfig(options.workspaceRoot);
-    await writeFile(configPath, renderConfigJsonc(config), 'utf8');
-    return { path: configPath, config };
+    return writeToolConfigForRepo({ ...options, config }, fileExists);
 }
 export async function createConfigForRepo(options) {
     const workspaceRoot = await resolveRepositoryRoot(options.cwd);

package/dist/core/log-reader.d.ts

@@ -0,0 +1,7 @@
+export interface LogEntry {
+    name: string;
+    path: string;
+    content: string;
+}
+export declare function tailLogContent(content: string): string;
+export declare function readLogs(logsDir: string, activeLogPath: string | null): Promise<LogEntry[]>;

package/dist/core/log-reader.js

@@ -0,0 +1,43 @@
+import path from 'node:path';
+import { readdir, readFile, stat } from 'node:fs/promises';
+const MAX_LOG_BYTES = 16 * 1024;
+const MAX_LOG_LINES = 120;
+export function tailLogContent(content) {
+    const byteTrimmed = content.length > MAX_LOG_BYTES ? content.slice(-MAX_LOG_BYTES) : content;
+    const lines = byteTrimmed.replace(/\r\n/g, '\n').split('\n');
+    const tailLines = lines.length > MAX_LOG_LINES ? lines.slice(-MAX_LOG_LINES) : lines;
+    return tailLines.join('\n').trimEnd();
+}
+export async function readLogs(logsDir, activeLogPath) {
+    try {
+        const entries = (await readdir(logsDir, { withFileTypes: true }))
+            .filter(entry => entry.isFile() && entry.name.endsWith('.log'))
+            .map(entry => ({ name: entry.name, path: path.join(logsDir, entry.name) }));
+        if (entries.length === 0) {
+            return [];
+        }
+        let selectedEntries = entries;
+        if (activeLogPath !== null) {
+            const activeEntry = entries.find(entry => entry.path === activeLogPath);
+            if (activeEntry) {
+                selectedEntries = [activeEntry];
+            }
+        }
+        else {
+            const withStats = await Promise.all(entries.map(async (entry) => ({
+                ...entry,
+                mtimeMs: (await stat(entry.path)).mtimeMs,
+            })));
+            withStats.sort((a, b) => b.mtimeMs - a.mtimeMs || a.name.localeCompare(b.name));
+            selectedEntries = [withStats[0]];
+        }
+        return await Promise.all(selectedEntries.map(async (entry) => ({
+            name: entry.name,
+            path: entry.path,
+            content: tailLogContent(await readFile(entry.path, 'utf8')),
+        })));
+    }
+    catch {
+        return [];
+    }
+}

package/dist/core/runtime-state.d.ts

@@ -0,0 +1,42 @@
+import type { ToolConfig } from './config.js';
+import type { AppActions, AppLogEntry, AppModel, AppStatus } from './runtime.js';
+import type { SessionPaths, SessionRecord } from './session-store.js';
+export interface StartedCommand {
+    pid: number;
+    pgid: number;
+    logPath: string;
+}
+export interface RuntimeStateAdapter {
+    refresh: () => Promise<AppModel>;
+    readActive: () => Promise<SessionRecord | null>;
+    readLogs: (logPath: string | null) => Promise<AppLogEntry[]>;
+    readWorktreeBranch: (worktreePath: string) => Promise<string>;
+    getInvalidReason: (worktreePath: string) => Promise<string | null>;
+    runSetup: (input: {
+        command: string[];
+        cwd: string;
+        logsDir: string;
+        logFileBase: string;
+    }) => Promise<{
+        logPath: string;
+    }>;
+    startCommand: (input: {
+        command: string[];
+        cwd: string;
+        logsDir: string;
+        logFileBase: string;
+    }) => Promise<StartedCommand>;
+    stopSession: (active: SessionRecord) => Promise<void>;
+    clearSession: () => Promise<void>;
+    writeSession: (record: SessionRecord) => Promise<void>;
+    openEditor: (worktreePath: string) => Promise<AppStatus>;
+    openPullRequest: (worktreePath: string) => Promise<AppStatus>;
+    deleteWorktree: (worktreePath: string) => Promise<AppStatus>;
+    nowIso: () => string;
+}
+export interface RuntimeStateOptions {
+    config: ToolConfig;
+    paths: SessionPaths;
+    adapter: RuntimeStateAdapter;
+}
+export declare function createRuntimeStateActions({ config, paths, adapter }: RuntimeStateOptions): AppActions;

package/dist/core/runtime-state.js

@@ -0,0 +1,125 @@
+import path from 'node:path';
+function toLogFileBase(branch) {
+    return branch.replace(/[\\/]/g, '-');
+}
+export function createRuntimeStateActions({ config, paths, adapter }) {
+    const refreshLogs = async () => {
+        const active = await adapter.readActive();
+        return {
+            logs: await adapter.readLogs(active?.logPath ?? null),
+            activePath: active?.worktreePath ?? null,
+            activeBranch: active?.branch ?? null,
+        };
+    };
+    const refreshWithStatus = async (run, preserveRunningStatus) => {
+        const status = await run();
+        const model = await adapter.refresh();
+        if (preserveRunningStatus && model.activePath !== null && status.kind === 'idle') {
+            return {
+                ...model,
+                status: { kind: 'running', message: status.message },
+            };
+        }
+        return {
+            ...model,
+            status,
+        };
+    };
+    const stop = async () => {
+        const active = await adapter.readActive();
+        if (active) {
+            await adapter.stopSession(active);
+            await adapter.clearSession();
+        }
+        const model = await adapter.refresh();
+        return {
+            ...model,
+            activePath: null,
+            activeBranch: null,
+            status: { kind: 'idle', message: active ? 'stopped' : 'already stopped' },
+        };
+    };
+    const setup = async (worktreePath) => {
+        const setupCommand = config.setupCommand;
+        if (setupCommand === undefined) {
+            const model = await adapter.refresh();
+            return {
+                ...model,
+                status: { kind: 'idle', message: 'setup command is not configured' },
+            };
+        }
+        const branch = await adapter.readWorktreeBranch(worktreePath);
+        const logFileBase = `${toLogFileBase(branch)}.setup`;
+        const setupLogPath = path.join(paths.logsDir, `${logFileBase}.log`);
+        try {
+            await adapter.runSetup({
+                command: setupCommand,
+                cwd: worktreePath,
+                logsDir: paths.logsDir,
+                logFileBase,
+            });
+        }
+        catch (error) {
+            const model = await adapter.refresh();
+            return {
+                ...model,
+                status: { kind: 'error', message: error instanceof Error ? error.message : String(error) },
+                logs: await adapter.readLogs(setupLogPath),
+            };
+        }
+        const model = await adapter.refresh();
+        return {
+            ...model,
+            status: { kind: model.activePath === null ? 'idle' : 'running', message: `setup complete for ${branch}` },
+            logs: await adapter.readLogs(setupLogPath),
+        };
+    };
+    const start = async (worktreePath) => {
+        const current = await adapter.readActive();
+        if (current?.worktreePath === worktreePath) {
+            const model = await adapter.refresh();
+            return {
+                ...model,
+                activePath: current.worktreePath,
+                activeBranch: current.branch,
+                status: { kind: 'idle', message: 'already active' },
+            };
+        }
+        const invalidReason = await adapter.getInvalidReason(worktreePath);
+        if (invalidReason) {
+            throw new Error(invalidReason);
+        }
+        if (current) {
+            await adapter.stopSession(current);
+            await adapter.clearSession();
+        }
+        const branch = await adapter.readWorktreeBranch(worktreePath);
+        const started = await adapter.startCommand({
+            command: config.command,
+            cwd: worktreePath,
+            logsDir: paths.logsDir,
+            logFileBase: toLogFileBase(branch),
+        });
+        await adapter.writeSession({
+            namespace: config.namespace,
+            worktreePath,
+            branch,
+            pid: started.pid,
+            pgid: started.pgid,
+            port: config.port,
+            logPath: started.logPath,
+            startedAt: adapter.nowIso(),
+        });
+        const model = await adapter.refresh();
+        return {
+            ...model,
+            activePath: worktreePath,
+            activeBranch: branch,
+            status: { kind: 'running', message: `started ${branch}` },
+        };
+    };
+    const openEditor = async (worktreePath) => refreshWithStatus(() => adapter.openEditor(worktreePath), true);
+    const openPullRequest = async (worktreePath) => refreshWithStatus(() => adapter.openPullRequest(worktreePath), true);
+    const deleteWorktree = async (worktreePath) => refreshWithStatus(() => adapter.deleteWorktree(worktreePath), false);
+    return { setup, start, stop, refresh: adapter.refresh, refreshLogs, openEditor, openPullRequest, deleteWorktree };
+}