From 84dfef8cd476401c1b9eab27067059384a1d0ec8 Mon Sep 17 00:00:00 2001 From: Jean-Baptiste Date: Fri, 13 Nov 2026 00:24:45 +0100 Subject: [PATCH 1/8] (projects): offer to remove linked worktree folders when deleting a project (#474) --- .ai/contexts/project-delete.md | 73 +++++- CHANGELOG.md | 2 +- docs/session-browser.md | 12 +- docs/worktrees.md | 26 +- main.js | 2 +- public/sidebar.js | 22 +- src/main/projects/project-delete-main.js | 58 ++++- src/main/projects/project-delete-plan.js | 34 ++- src/main/projects/project-delete-worktrees.js | 91 +++++++ src/main/projects/project-delete.js | 39 ++- src/main/shared/project-operation-gate.js | 20 +- test/dom-project-delete.test.js | 44 ++++ test/project-delete-main.test.js | 37 +++ .../project-delete-worktrees-real-git.test.js | 63 +++++ test/project-delete-worktrees.test.js | 243 ++++++++++++++++++ 15 files changed, 727 insertions(+), 39 deletions(-) create mode 100644 src/main/projects/project-delete-worktrees.js create mode 100644 test/project-delete-worktrees-real-git.test.js create mode 100644 test/project-delete-worktrees.test.js diff --git a/.ai/contexts/project-delete.md b/.ai/contexts/project-delete.md index 4d17d9acd..57e80b369 100644 --- a/.ai/contexts/project-delete.md +++ b/.ai/contexts/project-delete.md @@ -1,4 +1,68 @@ -# Project deletion (#474 A4a–A4d) +# Project deletion (#474 A4a–A4d, E) + +## Linked worktree folders (E) + +Preview accepts optional `worktrees: string[]` alongside the unchanged five +boolean writer options. These are exact paths from the main-owned Git inventory, +not arbitrary filesystem targets. Missing means empty; duplicates and more than +128 selections refuse. Every registered checkout has a row: path, branch, +main/project-directory identity, dirty/untracked status, sessions, jobs and an +availability reason. Status/activity failures are explicit, never rendered as +clean/idle. The main checkout, the selected project directory and its ancestors +are never removable. Remote selection refuses because no authoritative remote +filesystem/removal port exists. Local discovery uses NUL-delimited Git porcelain; +Git versions without that list format leave physical deletion unavailable. + +`project-delete-worktrees.js` calls the existing `worktree-delete` readStatus and +removeWorktree functions. Clean removal uses no force; dirty content is hashed +and rechecked. Locked/submodule rows are disabled here and direct users to the +dedicated dialog for its extra confirmations. Directory-link refusal is shared: +remove a node_modules junction with nonrecursive `rmdir` before reopening. E +does not unlink automatically, traverse junctions, delete branches or invoke +cleanupWorktree. Linked histories remain outside the parent's metadata manifest. + +The runtime reads all CLI descriptor writers, indexed session evidence, active +tabs, schedules and background job files/list. Descendant cwd counts as worktree +activity. Live or uncertain sessions disable the row; E does not extend A4 stop +authority to a linked project's sessions. Background records remain refused +under #1090 even when done. Local subtree launch holds cover selected directories +and wait for previously admitted descendant launches; archive reservations include +the selected linked identities as well as the parent. External processes and +filesystem writers are not locked by these holds. + +Rows and selection enter the planner fingerprint, retained in the single-use +document-bound token. Renderer boxes are individually unchecked on every open +with no rememberKey. A changed selected row fingerprint requires reopening: +a newer hidden detail panel cannot silently authorize newly dirty bytes. +Unselected physical content is kept. Selecting a directory necessarily removes +all its contents, including ignored files and any schedules/memory/work-files +inside it; category `kept` applies to the parent's data, not files inside selected +linked directories. + +Execution drains holds, revalidates, stops/verifies parent targets, preflights all +selected rows, then removes sequentially through the shared path with fresh +per-removal activity/status checks. A failed removal stops the sequence. Only +after removal does it reread writer scope and revalidate parent membership/death, +omitting already-consumed physical selections from this final preview. The +writer's manifest/options remain metadata-only. The operation retains launch +holds until Git settles, even after an early IPC unknown reply. + +`worktrees` on operation views records removed/failed/remaining paths. An attempted +disk effect followed by failure remains partial even when the metadata receipt +proves notStarted. The renderer's persistent notice lists these paths and offers +fresh review, never replay. A metadata commit still publishes only its own exact +invalidation targets. Filesystem and SQLite effects are not an atomic transaction. +Physical progress is process-local: recovered writer receipts explicitly set +worktreeHistoryUnknown; a crash before writer submission leaves no disk receipt. +Fresh Git/disk inspection and user consent establish remaining work. Recovery +never repeats disk removal or treats a metadata receipt as proof of disk success. + +Plain-Node tests cover the production planner, service, activity reader, subtree +gate and shared removal with controlled Git replies and real disposable files. +The composition witness includes the real writer/SQLite fixture. Separate real +Git worktree tests are retained for CI; the local sandbox refuses their temporary +linked `.git` creation. Native UI, full process restart, live process death and +filesystem races after the shared last scan remain unverified locally. ## Renderer boundary (A4d) @@ -17,7 +81,7 @@ the strict backend STOP_UNSUPPORTED behavior remains unchanged. R6: a bounded read-only capabilities preview precedes the dialog. Only session metadata (initial false) and available project settings (initial true) are remembered on acceptance. Disabled remembered choices become unchecked without -a write. Physical categories stay kept. The literal expandable full plan is +a write. E adds separately unremembered physical worktree choices above. The literal expandable full plan is installed only after latest-response/answer matching; failures cannot enable Confirm. Changed membership requires a new dialog/confirmation. @@ -190,8 +254,9 @@ The service, inventory and planner share optional `now/schedule/cancel` clock po allow expiry, deadlines and retention to share one clock. Tokens are 32 random bytes, five-minute, boot/document-bound, with 32 outstanding globally. Preview rechecks document authority after discovery/scope reads before minting. Input -options remain the five booleans; extra fields and physical/worktree choices -refuse. Reply timeout is separate from accepted main-owned work. The operation +options remain the five booleans; E's optional worktrees path array belongs to +preview only and never enters writer options. Other extra fields refuse. +Reply timeout is separate from accepted main-owned work. The operation ID and registry entry precede the first await, and readState cannot fence work still admitting or stopping. Reuse/foreign tokens never submit or stop twice. diff --git a/CHANGELOG.md b/CHANGELOG.md index ff8347291..d29f0cf90 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,7 +5,7 @@ What changes for you in each release of Switchboard. How to write an entry: [doc ## Unreleased ### New -- Delete a project from its sidebar header or Project Settings with a full preview and separate choices for session metadata and project settings. Files stay on disk; interrupted deletions show their outcome before you try again. (#474) +- Delete a project from its sidebar header or Project Settings with a full preview and separate choices for session metadata, project settings and individual linked worktree folders. Worktree removal always starts unchecked; the main checkout stays on disk, and partial deletions show what happened before you try again. (#474) ### Fixed - Arch/Manjaro downloads now include a separate package for each architecture, so x64 users no longer sometimes receive an ARM package. (#1089) diff --git a/docs/session-browser.md b/docs/session-browser.md index c46bcf63a..37aa170aa 100644 --- a/docs/session-browser.md +++ b/docs/session-browser.md @@ -49,7 +49,7 @@ Buttons on a project header: | Create scheduled task | Opens a Claude session that writes a schedule file — see [Automation](automation.md#creating-a-schedule) | | Project settings | Per-project overrides — see [Settings reference](settings.md#project-settings) | | Archive folder | Opens a dialog that archives the folder's sessions and disables its schedules, each optional, and hides the folder — see [Archive a folder](#archive-a-folder) | -| Delete | Previews removal from Switchboard with separate session metadata and project settings choices. Files and nested worktrees stay on disk — see [Settings reference](settings.md#project-settings). | +| Delete | Previews removal from Switchboard with separate session metadata, project settings and individual linked worktree folder choices. Worktree removal starts unchecked; the main checkout stays — see [Worktree cleanup](worktrees.md#cleaning-up). | | New session (`+`) | The launch menu — see [Launching sessions](launching-sessions.md) | A project on a [remote host](remote-hosts.md) carries a host status dot and a @@ -66,8 +66,14 @@ project from the sidebar without asking. A notice offers **Undo** for about their files. **Unarchive** in Settings → **Archived projects**, or **Add Project** on the same local folder, restores it and resumes scheduling. Unlike **Archive folder**, a new session does not restore it automatically. **Delete Project** -separately removes settings, cache, search entries and schedule registration; -its confirmation names these losses. It deletes no folder or transcript. +offers separate choices for app metadata and project settings, and optionally +removes individually selected linked worktree folders from disk. Each folder's +path, branch, changed files and live sessions are previewed; its checkbox is +never remembered. The project directory, main checkout, unselected worktrees +and external transcripts are kept. Contents inside a selected worktree, including +ignored files, are removed. Busy, uncertain, locked or remote worktrees cannot +be selected here. A partial deletion lists disk outcomes and requires a fresh +preview before retrying; see [Worktree cleanup](worktrees.md#cleaning-up). Sessions run in a git worktree are listed in their repository's project — see [Worktree sessions](worktrees.md). A worktree folder is nested under its diff --git a/docs/worktrees.md b/docs/worktrees.md index 0cad5e9ec..7b59865b9 100644 --- a/docs/worktrees.md +++ b/docs/worktrees.md @@ -59,9 +59,29 @@ it empty (placeholder `auto`) to let the CLI name each worktree. ## Cleaning up -Deleting the parent project from its header or Project Settings keeps nested -worktree histories and directories. The full project-deletion preview lists -those groups as kept; it offers no physical worktree deletion choice. +Deleting the parent project from its header or Project Settings keeps linked +worktree histories and offers a separate checkbox for each registered linked +worktree folder. Each choice starts unchecked every time. The preview names the +full path, branch, dirty/untracked files and sessions. The main checkout and the +selected project directory cannot be removed. Unselected folders and branches +are kept. Selecting a folder removes its contents, including ignored files, +memory, schedules or `.work-files` stored inside it; their contents are not backed up. + +Stop linked-worktree sessions before selecting their folders. Unknown activity +and background job records refuse removal; background jobs remain unsupported +even when reported done. Locked worktrees and submodules require the dedicated +worktree dialog below. Remote disk removal is unavailable. Directory links use +the same guards as the dedicated dialog: remove a `node_modules` junction with +`rmdir ` without recursive deletion, then reopen the preview. + +After the parent project's sessions stop, selected folders are removed one at a +time before the project's app metadata is changed. A changed preview requires +fresh confirmation. A failed removal stops the sequence and lists removed, +failed and remaining paths in a persistent notice. Review disk and Git +registration, then choose **Review remaining deletion** for fresh consent. +There is no rollback or automatic replay. After restarting the app, previous +disk outcomes may be unknown: a new preview inspects the remaining registration +and folders; a metadata receipt alone does not prove disk removal succeeded. When the work is merged or abandoned, remove the worktree from Switchboard or with git. diff --git a/main.js b/main.js index 83adeaefc..82aa1278c 100644 --- a/main.js +++ b/main.js @@ -3820,7 +3820,7 @@ const unsubscribeBgAgents = require('./src/main/bg-agents/bg-agents-ipc').init({ activeSessions, cliSessionState, sessionHasPty, ptyPids, getSetting: key => getSetting(key) }); const { createProjectDeleteMain } = require('./src/main/projects/project-delete-main'); const projectDeleteMain = createProjectDeleteMain({ - writer, ipcMain, activeSessions, cliSessionState, log, homeDir: os.homedir(), + writer, ipcMain, activeSessions, cliSessionState, log, homeDir: os.homedir(), worktreeGit, projectsDir: PROJECTS_DIR, dataDir: path.dirname(DB_PATH), jobsDir: path.join(CLAUDE_DIR, 'jobs'), bg: unsubscribeBgAgents, remote: remoteStopAdapter, runClaude: runClaudeCommand, gate: require('./src/main/shared/project-operation-gate').projectOperationGate, diff --git a/public/sidebar.js b/public/sidebar.js index f971b16c7..d8a350db3 100644 --- a/public/sidebar.js +++ b/public/sidebar.js @@ -1011,7 +1011,7 @@ function projectDeletionDetails(reply) { const plan = reply.plan; return JSON.stringify({ project: plan.project, counts: plan.counts, categories: plan.categories, groups: plan.groups, members: plan.members, tabs: plan.tabs, stops: plan.stops, jobs: plan.jobs, - schedules: plan.schedules, warnings: plan.warnings, refusals: plan.refusals }, null, 2); + schedules: plan.schedules, worktrees: plan.worktrees, warnings: plan.warnings, refusals: plan.refusals }, null, 2); } function projectDeletionNotice(project, message, action) { @@ -1044,7 +1044,8 @@ async function settleProjectDeletion(project, result, { historical = false } = { setProjectDeletionBusy(project, true); projectDeletionNotice(project, `Deletion is ${result.state === 'unknown' ? 'unresolved' : 'partially completed'}. No deletion will be replayed.\n` + JSON.stringify({ completed: result.completed, kept: result.kept, failed: result.failed, skipped: result.skipped, - stopped: result.stopped, stoppedHistoryUnknown: result.stoppedHistoryUnknown }, null, 2), + stopped: result.stopped, stoppedHistoryUnknown: result.stoppedHistoryUnknown, + worktrees: result.worktrees, worktreeHistoryUnknown: result.worktreeHistoryUnknown }, null, 2), result.state === 'partial' ? { actionLabel: 'Review remaining deletion', onAction: () => { projectDeletionOperations.delete(key); setProjectDeletionBusy(project, false); const current = cachedAllProjects.find(row => projectDeletionKey(row) === key) || project; @@ -1062,7 +1063,8 @@ async function settleProjectDeletion(project, result, { historical = false } = { const operation = projectDeletionOperations.get(key); projectDeletionNotice(project, (result?.error || result?.code || 'Deletion could not be completed.') + (result?.refresh ? ' Review a fresh preview before confirming again.' : ' Check the project, then retry.') + '\n' + - JSON.stringify({ completed: result?.completed, kept: result?.kept, failed: result?.failed, skipped: result?.skipped, stopped: result?.stopped }, null, 2), + JSON.stringify({ completed: result?.completed, kept: result?.kept, failed: result?.failed, skipped: result?.skipped, stopped: result?.stopped, + worktrees: result?.worktrees, worktreeHistoryUnknown: result?.worktreeHistoryUnknown }, null, 2), operation ? { actionLabel: 'Check deletion state', onAction: () => reconcileProjectDeletions({ operations: [ { operationId: operation.operationId, host: project.remoteAlias ?? project.host ?? null, projectPath: project.projectPath }, ] }) } : { actionLabel: 'Review deletion', onAction: () => confirmAndDeleteProjectFolder(project) }); @@ -1105,24 +1107,32 @@ async function confirmAndDeleteProjectFolder(project, button) { let accepted = false, unresolved = false; try { await window.flushProjectDeletionWrites?.(); + let worktreeChoices = []; const request = options => ({ projectPath: project.projectPath, ...(project.folder ? { folderKey: project.folder } : {}), + worktrees: worktreeChoices.filter((row, i) => options['worktree:' + i]).map(row => row.path), options: { sessions: options.sessions, settings: options.settings, schedules: false, transcripts: false, stopBackgroundJobs: false } }); const capabilities = await projectDeletionCall('previewProjectDelete', request({ sessions: false, settings: false }), { retryRecovery: true }); if (!capabilities?.plan) { projectDeletionNotice(project, projectDeletionPlanReason(capabilities)); return false; } const categories = capabilities.plan.categories; + worktreeChoices = (capabilities.plan.worktrees || []).map(row => ({ ...row })); const answers = await showChoiceDialog({ title: 'Delete project from Switchboard?', message: [`${project.remoteAlias || 'Local'} — ${capabilities.plan.project.projectPath}`, 'Choose which app data to discard. Retained session metadata is archived.', - 'Kept on disk: project folder, transcripts, schedules, memory, .work-files and nested worktrees. All remote server files are kept.', + 'The project folder is always kept. Only individually selected linked worktree folders are removed, including their ignored files. All remote server files are kept.', + 'Other transcripts, schedules, memory and .work-files stay on disk. Linked worktree history is kept in Switchboard.', 'Kept schedules may reactivate when you add the project again. Retained transcripts may restore their titles.'], choices: [ { id: 'sessions', label: 'Discard session names, pins and app metadata', checked: false, rememberKey: 'deleteProject.sessions', disabled: categories.sessions?.available !== true, disabledReason: categories.sessions?.reason || 'Session metadata is unavailable' }, { id: 'settings', label: 'Delete project settings', checked: true, rememberKey: 'deleteProject.settings', disabled: categories.settings?.available !== true, disabledReason: categories.settings?.reason || 'Project settings are unavailable' }, + ...worktreeChoices.map((row, i) => ({ id: 'worktree:' + i, + label: `${row.main ? 'Main checkout (kept)' : 'Remove worktree from disk'}: ${row.path} — ${row.branch}. ${row.statusKnown === false ? 'Status unavailable' : row.dirty?.length ? row.dirty.join('; ') : 'Clean'}. Sessions: ${row.sessionsKnown === false ? 'uncertain' : (row.sessions || []).map(session => session.sessionId || session.id).join(', ') || 'none'}. Ignored files are removed too.`, + checked: false, disabled: row.removable !== true || row.main || row.projectDirectory, + disabledReason: row.reason || 'This worktree cannot be removed.' })), ], onChange: async values => { const reply = await projectDeletionCall('previewProjectDelete', request(values)); @@ -1130,6 +1140,10 @@ async function confirmAndDeleteProjectFolder(project, button) { for (const id of ['sessions', 'settings']) if (values[id] && reply.plan.categories[id]?.available !== true) { throw new Error(reply.plan.categories[id]?.reason || 'This choice is no longer available. Close and reopen Delete.'); } + for (const [i, row] of worktreeChoices.entries()) if (values['worktree:' + i]) { + const fresh = reply.plan.worktrees?.find(item => item.path === row.path); + if (!fresh?.removable || fresh.main || fresh.projectDirectory || fresh.fingerprint !== row.fingerprint) throw new Error(fresh?.reason || 'Worktree changed. Close and reopen Delete.'); + } return reply; }, planDetails: projectDeletionDetails, planUnavailable: projectDeletionPlanReason, diff --git a/src/main/projects/project-delete-main.js b/src/main/projects/project-delete-main.js index 89f7ae020..27913450c 100644 --- a/src/main/projects/project-delete-main.js +++ b/src/main/projects/project-delete-main.js @@ -11,6 +11,8 @@ const { registerProjectDeleteIpc } = require('./project-delete-ipc'); const { parseJobState, parseCliList, JOB_ID_RE } = require('../bg-agents/bg-agents-roster'); const { stopPtyWithEvidence, detachPty } = require('../terminals/pty-ops'); const { fail } = require('./project-delete-identity'); +const { createProjectDeleteWorktrees } = require('./project-delete-worktrees'); +const { parseFolderKey } = require('../remote/remote-hosts'); const RECOVERY_TIMEOUT_MS = 4096 * 30000 + 65 * 10000 + 32 * 80000; const HOLDS_TIMEOUT_MS = 120000; @@ -95,7 +97,7 @@ function createProjectDeleteRuntime(ports) { if (error.code !== 'ENOENT') candidates.push({ id, reason: error.message }); continue; } - if (normalize(cwd) !== normalize(root)) continue; + if (normalize(cwd) !== normalize(root) && !(project.includeDescendants && normalize(cwd).startsWith(normalize(root) + '/'))) continue; jobs.push({ id, jobId: id, alias: null, projectPath: root, runtime: 'claude', verified: true, conversationId: row.sessionId, sessionIds: [row.sessionId], liveness: { state: 'unknown', source: 'job' } }); candidates.push({ id, reason: 'Background deletion awaits worker-incarnation control (#1090).' }); @@ -158,7 +160,49 @@ function createProjectDeleteRuntime(ports) { } return { known: true, complete: true, owners }; } - return { readJobs, readLiveness, readTarget, readConversation, withScope, captureRuntimeRelease, + async function readWorktreeActivity(project, budget) { + if (project.alias !== null) throw fail('DISCOVERY_UNAVAILABLE', 'Remote worktree activity is unavailable.'); + const root = normalize(await bounded(() => io.realpath(project.projectPath), budget)); + const sessions = [], jobs = [], candidates = [], seen = new Set(); + const descriptors = await bounded(() => ports.cliSessionState.getSidebarDescriptors({ allWriters: true }), budget); + const snapshot = budget.snapshot || await ports.readWorktreeSnapshot?.(budget); + if (!Array.isArray(descriptors) || !Array.isArray(snapshot?.sessions) || !(ports.activeSessions instanceof Map)) { + throw fail('DISCOVERY_UNAVAILABLE', 'Worktree session inventory is incomplete.'); + } + const rows = [...ports.activeSessions].map(([id, row]) => ({ ...row, sessionId: row.realSessionId || row.sessionId || id, active: !row.exited })); + rows.push(...descriptors, ...snapshot.sessions); + if (rows.length > budget.limit) throw fail('DISCOVERY_LIMIT', 'Too many worktree sessions to inspect.'); + const within = async row => { + if (row.host || row.remoteAlias || row.alias || row.folder && parseFolderKey(row.folder).alias !== null) return false; + const value = row.cwd || row.projectPath; + if (typeof value !== 'string' || !path.isAbsolute(value)) { candidates.push({ id: row.sessionId, reason: 'Session cwd unavailable.' }); return false; } + let cwd; + try { cwd = normalize(await bounded(() => io.realpath(value), budget)); } + catch (error) { + if (error.code !== 'ENOENT') candidates.push({ id: row.sessionId, reason: 'Session cwd unreadable.' }); + return false; + } + return cwd === root || cwd.startsWith(root + '/'); + }; + for (const row of rows) { + if (!await within(row)) continue; + const id = row.sessionId || row.id; + if (row.active) { sessions.push({ sessionId: id, cwd: row.cwd || row.projectPath }); continue; } + if (!id || row.runtime === 'codex') { candidates.push({ id, reason: 'Worktree runtime liveness unavailable.' }); continue; } + if (seen.has(id)) continue; + seen.add(id); + const evidence = await bounded(() => ports.cliSessionState.readStatusEvidence(id, budget.deadline), budget); + if (!evidence?.known || evidence.ambiguous) candidates.push({ id, reason: 'Worktree session liveness uncertain.' }); + else if (evidence.live) sessions.push({ sessionId: id, cwd: row.cwd || row.projectPath }); + } + const roster = await readJobs({ ...project, includeDescendants: true }, budget); + jobs.push(...roster.jobs); candidates.push(...roster.candidates); + const runs = await bounded(() => ports.cliSessionState.getScheduleRunSnapshot(), budget); + if (!Array.isArray(runs) || runs.length + rows.length + jobs.length > budget.limit) throw fail('DISCOVERY_LIMIT', 'Schedule inventory unavailable or oversized.'); + for (const run of runs) if (await within(run)) jobs.push(run); + return { complete: true, sessions, jobs, candidates }; + } + return { readJobs, readLiveness, readTarget, readConversation, readWorktreeActivity, withScope, captureRuntimeRelease, getScheduleRunSnapshot: () => ports.cliSessionState.getScheduleRunSnapshot(), bg: ports.bg, remote: ports.remote, detach: attachment => detachPty(attachment.session, attachment.sessionKey), @@ -195,11 +239,13 @@ function createProjectDeleteMain(deps) { catch (error) { delivered.delete(key); throw error; } for (const [old, at] of delivered) if (now() - at >= 86400000) delivered.delete(old); }; - const runtime = createProjectDeleteRuntime({ ...deps, ...clock }); - const inventory = createProjectDeleteInventory({ ...deps, ...runtime, ...clock, writer }); - const planner = createProjectDeletePlanner({ ...inventory, ...clock }); + let inventory; + const runtime = createProjectDeleteRuntime({ ...deps, ...clock, readWorktreeSnapshot: budget => inventory.readSnapshot(budget) }); + inventory = createProjectDeleteInventory({ ...deps, ...runtime, ...clock, writer }); + const worktrees = deps.worktreeGit ? createProjectDeleteWorktrees({ runGit: deps.worktreeGit, readActivity: runtime.readWorktreeActivity, now }) : null; + const planner = createProjectDeletePlanner({ ...inventory, ...clock, worktrees }); const stop = createProjectDeleteStop({ ...deps, ...runtime, ...clock }); - const service = createProjectDeleteService({ ...clock, writer, inventory, planner, stop, gate: deps.gate, + const service = createProjectDeleteService({ ...clock, writer, inventory, planner, stop, worktrees, gate: deps.gate, captureRuntimeRelease: runtime.captureRuntimeRelease, onHoldsInstalled: () => settleHolds?.(!disposed), notifyProjects: notify('notifyProjects'), notifySchedules: notify('notifySchedules') }); diff --git a/src/main/projects/project-delete-plan.js b/src/main/projects/project-delete-plan.js index c5679a175..319153148 100644 --- a/src/main/projects/project-delete-plan.js +++ b/src/main/projects/project-delete-plan.js @@ -6,7 +6,7 @@ const { worktreeParentPath } = require('../../../public/worktree-nesting'); const { OPTION_KEYS, isRecord, text, fail, canonicalPath, identity, stable, digest, compare, membershipRecord } = require('./project-delete-identity'); function validateRequest(request) { - if (!isRecord(request) || Object.keys(request).some(key => !['projectPath', 'folderKey', 'options'].includes(key)) + if (!isRecord(request) || Object.keys(request).some(key => !['projectPath', 'folderKey', 'options', 'worktrees'].includes(key)) || !text(request.projectPath) || (request.folderKey !== undefined && !text(request.folderKey)) || !isRecord(request.options) || Object.keys(request.options).length !== OPTION_KEYS.length || Object.keys(request.options).some(key => !OPTION_KEYS.includes(key)) @@ -14,6 +14,11 @@ function validateRequest(request) { || request.options.schedules || request.options.transcripts) { throw fail('INVALID_REQUEST', 'Use the five explicit boolean A4 options; physical deletion is unavailable.'); } + if (request.worktrees !== undefined && (!Array.isArray(request.worktrees) || request.worktrees.length > 128 + || request.worktrees.some(value => !text(value) || !path.isAbsolute(value)) + || new Set(request.worktrees).size !== request.worktrees.length)) { + throw fail('INVALID_REQUEST', 'Select each linked worktree by its exact preview path.'); + } } async function resolveProject(request, snapshot, boundKey, memo, each, ordered) { @@ -108,6 +113,22 @@ function createProjectDeletePlanner(deps) { const rawTabs = items(runtime.tabs), rawJobs = items(runtime.jobs), runtimeCandidates = items(runtime.candidates); const refusals = [], warnings = []; const refuse = (code, target, error) => refusals.push({ code, target, error }); + const selectedWorktrees = request.worktrees || []; + let worktrees = []; + try { + if (project.alias !== null && selectedWorktrees.length) throw fail('WORKTREE_UNAVAILABLE', 'Remote worktree removal is unavailable.'); + if (deps.worktrees && project.alias === null) worktrees = items(await deps.worktrees.preview(project, { ...budget, snapshot })); + worktrees = worktrees.map(row => ({ ...row, selected: selectedWorktrees.includes(row.path) })); + for (const target of selectedWorktrees) { + const row = worktrees.find(row => row.path === target); + if (!row?.removable || row.main || canonicalPath(target, null, memo) === project.projectPath) { + refuse('WORKTREE_UNAVAILABLE', target, row?.reason || 'This linked worktree is not removable. Reopen Delete for a fresh preview.'); + } + } + } catch (error) { + if (selectedWorktrees.length) refuse('WORKTREE_UNAVAILABLE', project.projectPath, error.message); + else warnings.push({ code: 'WORKTREE_UNAVAILABLE', error: error.message }); + } const rowPath = (row, key, code) => { if (row[key] === null) return null; try { return canonicalPath(row[key], row.alias, memo); } @@ -224,7 +245,7 @@ function createProjectDeletePlanner(deps) { schedules: { selected: false, available: false, effect: 'kept' }, transcripts: { selected: false, available: false, effect: 'kept' }, stopBackgroundJobs: { selected: request.options.stopBackgroundJobs, available: true }, - memory: { effect: 'kept' }, workFiles: { effect: 'kept' }, worktrees: { effect: 'kept' }, projectDirectory: { effect: 'kept' }, branches: { effect: 'kept' }, + memory: { effect: 'kept' }, workFiles: { effect: 'kept' }, worktrees: { effect: selectedWorktrees.length ? 'selected' : 'kept' }, projectDirectory: { effect: 'kept' }, branches: { effect: 'kept' }, }; warnings.push({ code: 'RETAINED_TRANSCRIPTS', error: 'Retained transcripts can restore transcript titles on re-add even when app names are discarded.' }); if (schedules.length) warnings.push({ code: 'SCHEDULE_REACTIVATION', error: 'Kept schedule files may reactivate when this project is re-added.' }); @@ -241,11 +262,11 @@ function createProjectDeletePlanner(deps) { } await ordered(refusals); const membershipDigest = digest({ project: { alias: project.alias, projectPath: project.projectPath }, ...membership }); - const fingerprint = digest({ membershipDigest, groups, members, tabs, jobs, schedules, options: request.options, stops, categories, warnings, refusals }); + const fingerprint = digest({ membershipDigest, groups, members, tabs, jobs, schedules, worktrees, options: request.options, stops, categories, warnings, refusals }); const revision = await deps.readRevision(budget); expired(); if (revision !== snapshot.revision) throw fail('SNAPSHOT_STALE', 'Writer changed during discovery; request a fresh preview.'); - return { ok: true, plan: { project, groups, members, tabs, jobs, stops, schedules, categories, + return { ok: true, plan: { project, groups, members, tabs, jobs, stops, schedules, categories, worktrees, counts: { conversations: new Set(members.map(row => row.conversationId)).size, parts: new Set(members.filter(row => !row.subagentId).map(row => row.partId)).size, subagents: members.filter(row => row.subagentId).length, transcripts: members.length, tabs: tabs.length, @@ -263,11 +284,12 @@ function createProjectDeletePlanner(deps) { } } - async function revalidate(plan) { + async function revalidate(plan, { withoutWorktrees = false } = {}) { try { const options = Object.fromEntries(OPTION_KEYS.map(key => [key, plan.categories[key].selected])); if (identity(plan.project).key !== plan.project.key) return { same: false, plan: null }; - const reply = await preview({ projectPath: plan.project.projectPath, options }, plan.project.key); + const reply = await preview({ projectPath: plan.project.projectPath, options, + worktrees: withoutWorktrees ? [] : (plan.worktrees || []).filter(row => row.selected).map(row => row.path) }, plan.project.key); return { same: reply.ok && reply.plan.fingerprint === plan.fingerprint && reply.plan.refusals.length === 0, plan: reply.ok ? reply.plan : null }; } catch { diff --git a/src/main/projects/project-delete-worktrees.js b/src/main/projects/project-delete-worktrees.js new file mode 100644 index 000000000..c5af42ec7 --- /dev/null +++ b/src/main/projects/project-delete-worktrees.js @@ -0,0 +1,91 @@ +'use strict'; + +const path = require('node:path'); +const deletion = require('../../../worktree-delete'); +const { canonicalPath, fail } = require('./project-delete-identity'); + +function createProjectDeleteWorktrees({ runGit, readActivity, now = Date.now }) { + const check = budget => { + if (budget.signal.aborted || now() >= budget.deadline) throw fail('DISCOVERY_TIMEOUT', 'Worktree preview timed out. Reopen Delete to retry.'); + }; + async function preview(project, budget) { + if (project.alias !== null) throw fail('WORKTREE_UNAVAILABLE', 'Remote worktree removal is unavailable.'); + check(budget); + const list = await runGit(['-C', project.projectPath, 'worktree', 'list', '--porcelain', '-z']); + check(budget); + const records = list.split('\0\0').filter(Boolean).map(value => value.split('\0')); + if (records.length > Math.min(128, budget.limit) || records.some(fields => !fields[0].startsWith('worktree '))) { + throw fail('DISCOVERY_LIMIT', 'Worktree registration is invalid or exceeds 128 entries. Review it with Git.'); + } + const rows = []; + for (const [index, fields] of records.entries()) { + check(budget); + const directory = fields[0].slice(9); + if (!path.isAbsolute(directory)) throw fail('WORKTREE_UNAVAILABLE', 'Git returned a relative worktree path.'); + const candidate = canonicalPath(directory, null), owner = canonicalPath(project.projectPath, null); + const row = { path: directory, branch: fields.find(field => field.startsWith('branch '))?.slice(7).replace(/^refs\/heads\//, '') || '(detached HEAD)', + main: index === 0, projectDirectory: candidate === owner || owner.startsWith(candidate + '/'), + removable: false, sessions: [], dirty: [], selected: false, statusKnown: false, sessionsKnown: false }; + if (row.main || row.projectDirectory) { + row.reason = 'The main checkout and the selected project directory are always kept.'; + try { + const status = await runGit(['-C', directory, 'status', '--porcelain=v1', '-z', '--untracked-files=all']); + row.dirty = status.split('\0').filter(Boolean); row.statusKnown = true; + const activity = await readActivity({ alias: null, projectPath: directory }, budget); + row.sessions = activity.sessions || []; row.jobs = activity.jobs || []; + row.sessionsKnown = activity.complete === true && !activity.candidates?.length; + } catch (error) { row.reason += ' Preview unavailable: ' + error.message; } + } + else { + try { + const status = await deletion.readStatus(directory, project.projectPath, runGit); + check(budget); + const activity = await readActivity({ alias: null, projectPath: directory }, budget); + check(budget); + Object.assign(row, status, { statusKnown: true, sessions: activity.sessions || [], jobs: activity.jobs || [], + sessionsKnown: activity.complete === true && !activity.candidates?.length }); + if (activity.complete !== true || !Array.isArray(activity.sessions) || !Array.isArray(activity.jobs) + || !Array.isArray(activity.candidates) || activity.candidates.length) row.reason = 'Worktree activity is uncertain. Check its sessions and Agents, then reopen Delete.'; + else if (activity.jobs.length) row.reason = 'Background jobs prevent worktree removal (#1090). Check the Agents view.'; + else if (activity.sessions.length) row.reason = 'Stop the sessions in this worktree first, then reopen Delete.'; + else if (status.locked || status.submodules?.length) row.reason = 'Locked worktrees and submodules require the dedicated Delete worktree dialog.'; + else row.removable = true; + } catch (error) { row.reason = error.message; } + } + rows.push(row); + } + return rows; + } + async function remove(project, selected, record) { + const budget = { signal: new AbortController().signal, deadline: now() + 15000, limit: 20000 }; + try { + const current = await preview(project, budget); + for (const row of selected) { + const fresh = current.find(item => item.path === row.path); + if (!fresh?.removable || fresh.main || fresh.projectDirectory || fresh.fingerprint !== row.fingerprint) { + record({ path: row.path, state: 'failed', error: fresh?.reason || 'Worktree changed. Review a fresh preview before confirming again.' }); + return false; + } + } + } catch (error) { + record({ path: selected[0]?.path, state: 'failed', error: error.message }); return false; + } + for (const row of selected) { + let result; + try { + result = await deletion.removeWorktree(row.path, project.projectPath, row, async () => { + const current = await preview(project, { ...budget, deadline: now() + 15000 }); + const fresh = current.find(item => item.path === row.path); + if (!fresh?.removable || fresh.main || fresh.projectDirectory) throw fail('WORKTREE_UNAVAILABLE', fresh?.reason || 'Worktree registration changed.'); + return fresh; + }, runGit); + } catch (error) { result = { ok: false, error: error.message }; } + record({ path: row.path, state: result.ok ? 'removed' : 'failed', error: result.error }); + if (!result.ok) return false; + } + return true; + } + return { preview, remove }; +} + +module.exports = { createProjectDeleteWorktrees }; diff --git a/src/main/projects/project-delete.js b/src/main/projects/project-delete.js index f852148d2..56d4314cd 100644 --- a/src/main/projects/project-delete.js +++ b/src/main/projects/project-delete.js @@ -2,7 +2,7 @@ const { randomUUID, randomBytes } = require('node:crypto'); const { operationId } = require('./project-delete-progress'); -const { membershipDigest, stable, isRecord, text, fail, OPTION_KEYS } = require('./project-delete-identity'); +const { membershipDigest, stable, isRecord, text, fail, OPTION_KEYS, identity } = require('./project-delete-identity'); function createProjectDeleteService(deps) { const { writer, planner, inventory, stop, gate, now = Date.now, schedule = setTimeout, cancel = clearTimeout } = deps; @@ -40,18 +40,27 @@ function createProjectDeleteService(deps) { function view(op) { return { ...failure('UNKNOWN'), operationId: op.id, state: 'unknown', ...op.result, host: op.project.alias, projectPath: op.project.projectPath, + worktrees: structuredClone(op.worktreeResults || []), ...(op.historyUnknown ? { worktreeHistoryUnknown: true } : {}), stopped: structuredClone(op.stopped), ...(op.historyUnknown ? { stoppedHistoryUnknown: true } : {}) }; } function acquire(op) { op.launch = gate.hold(op.project.projectPath, op.project.alias); - try { op.archive = writer.reserveProjectDeletion([op.project]); } - catch (error) { op.launch.release(); op.launch = null; throw error; } - op.admission = Promise.all([op.launch.ready, op.archive.ready]); + op.worktreeHolds = []; + try { + const linked = (op.plan?.worktrees || []).filter(row => row.selected); + for (const row of linked) op.worktreeHolds.push(gate.holdTree(row.path, op.project.alias)); + op.archive = writer.reserveProjectDeletion([op.project, ...linked.map(row => identity({ alias: op.project.alias, projectPath: row.path }))]); + } catch (error) { + for (const hold of op.worktreeHolds) hold.release(); + op.launch.release(); op.launch = null; throw error; + } + op.admission = Promise.all([op.launch.ready, op.archive.ready, ...op.worktreeHolds.map(hold => hold.ready)]); } async function release(op) { if (op.released) return; await op.admission; op.archive?.release(); op.launch?.release(); + for (const hold of op.worktreeHolds || []) hold.release(); op.releaseRuntime?.(); op.releaseRuntime = null; op.released = true; op.finished = op.historicalFinished ?? now(); if (projects.get(op.project.key) === op) projects.delete(op.project.key); @@ -126,12 +135,13 @@ function createProjectDeleteService(deps) { async function acceptState(op, state) { const committed = state.state === 'committed' && state.receiptAvailable === true && state.terminal === true && state.invalidation; const known = state.receiptAvailable === true && state.terminal === true && ['partial', 'notStarted'].includes(state.state); - op.result = { ...failure('UNKNOWN'), operationId: op.id, state: committed ? 'committed' : known ? state.state : 'unknown', - ok: !!committed, partial: known && state.state === 'partial', retryable: false, + const partial = known && (state.state === 'partial' || op.worktreeResults?.some(row => row.state !== 'remaining')); + op.result = { ...failure('UNKNOWN'), operationId: op.id, state: committed ? 'committed' : partial ? 'partial' : known ? state.state : 'unknown', + ok: !!committed, partial: !!partial, retryable: false, completed: state.completed || [], kept: state.kept || [], failed: state.failed || [], skipped: state.remaining || [], observations: { projectHidden: state.projectHidden, settingsPresent: state.settingsPresent, metadata: state.metadata, readRevision: state.readRevision }, ...(committed ? { code: undefined, invalidation: structuredClone(state.invalidation) } : {}), - ...(known ? { code: state.state === 'partial' ? 'PARTIAL' : 'NOT_STARTED', refresh: true } : {}) }; + ...(known ? { code: partial ? 'PARTIAL' : 'NOT_STARTED', refresh: true } : {}) }; if (state.terminal || state.noLateCommit) await release(op); if (committed) { for (const name of ['notifyProjects', 'notifySchedules']) { @@ -200,8 +210,17 @@ function createProjectDeleteService(deps) { if (!after.plan) throw fail('REVALIDATION_UNAVAILABLE', after.error || 'Post-stop inventory read unavailable.'); let manifestInventory = acceptedInventory(op, after.plan); if (!manifestInventory || !(await stop.verify(prepared)).ok) throw fail('PREVIEW_CHANGED', 'Post-stop ownership changed.'); + const selected = (op.plan.worktrees || []).filter(row => row.selected); + if (selected.length) { + if (!deps.worktrees) throw fail('WORKTREE_UNAVAILABLE', 'Worktree deletion is unavailable.'); + const removed = await deps.worktrees.remove(op.project, selected, result => { + op.worktreeResults = op.worktreeResults.filter(row => row.path !== result.path); + op.worktreeResults.push(result); + }); + if (!removed) throw fail('WORKTREE_FAILED', 'Worktree removal did not complete. Inspect the listed folders and Git registration; review a fresh preview before trying again.'); + } const fresh = await bounded(() => writer.readProjectDeletionScope({ project: op.project })); - const final = await planner.revalidate(op.plan); + const final = await planner.revalidate(op.plan, { withoutWorktrees: selected.length > 0 }); if (!final.plan) throw fail('REVALIDATION_UNAVAILABLE', final.error || 'Final inventory read unavailable.'); manifestInventory = acceptedInventory(op, final.plan); if (!manifestInventory || fresh.projectEpoch !== op.epoch || String(fresh.writerRevision) !== final.plan.revision @@ -212,7 +231,8 @@ function createProjectDeleteService(deps) { try { return await acceptState(op, await bounded(() => writer.completeProjectDeletion(manifest), 60000)); } catch { return await reconcile(op); } } catch (error) { - op.result = { ...failure(error.code || 'DELETE_UNAVAILABLE'), error: error.message, state: 'notStarted', refresh: true }; + const partial = op.worktreeResults?.some(row => row.state !== 'remaining'); + op.result = { ...failure(error.code || 'DELETE_UNAVAILABLE'), error: error.message, state: partial ? 'partial' : 'notStarted', partial: !!partial, refresh: true }; return view(op); } finally { op.running = false; @@ -234,6 +254,7 @@ function createProjectDeleteService(deps) { catch (error) { return Promise.resolve(failure(error.code || 'DELETION_ID')); } const op = { id, project: token.plan.project, epoch: token.epoch, plan: token.plan, options: token.options, stopped: [], authorities: new Set([sender]), notified: new Set(), running: true, + worktreeResults: (token.plan.worktrees || []).filter(row => row.selected).map(row => ({ path: row.path, state: 'remaining' })), releaseRuntime: deps.captureRuntimeRelease?.() }; operations.set(op.id, op); projects.set(op.project.key, op); try { acquire(op); } diff --git a/src/main/shared/project-operation-gate.js b/src/main/shared/project-operation-gate.js index 090f24b7e..ff01d46ba 100644 --- a/src/main/shared/project-operation-gate.js +++ b/src/main/shared/project-operation-gate.js @@ -6,6 +6,7 @@ const PROJECT_OPERATION_ERROR = 'A project operation is in progress. Wait for it function createProjectOperationGate() { const entries = new Map(); + const trees = new Map(); const keyFor = (project, alias) => { const remote = typeof alias === 'string' && alias.length > 0; const normalized = remote ? path.posix.normalize(project || '/').replace(/\/$/, '') || '/' : normalizeProjectPath(path.resolve(project || '.')); @@ -20,9 +21,14 @@ function createProjectOperationGate() { for (const resolve of entry.drained.splice(0)) resolve(); if (!entry.held) entries.delete(key); }; + const contains = (root, key) => { + const [host, directory] = JSON.parse(root), [candidateHost, candidate] = JSON.parse(key); + return host === candidateHost && (directory === candidate || candidate.startsWith(directory.replace(/\/$/, '') + '/')); + }; + const treeBlocked = key => [...trees.keys()].some(root => contains(root, key)); const tryAdmitAll = (projects, alias = null) => { const keys = [...new Set(projects.filter(project => project != null && project !== '').map(project => keyFor(project, alias)))]; - if (keys.some(key => entries.get(key)?.held)) return null; + if (keys.some(key => entries.get(key)?.held || treeBlocked(key))) return null; const admitted = keys.map(key => [key, entryFor(key)]); for (const [, entry] of admitted) entry.active++; let released = false; @@ -40,10 +46,20 @@ function createProjectOperationGate() { return tryAdmitAll([project], alias); }, tryAdmitAll, + holdTree(project, alias = null) { + const key = keyFor(project, alias); + if ([...trees.keys()].some(root => contains(root, key) || contains(key, root)) + || [...entries].some(([candidate, entry]) => entry.held && contains(key, candidate))) throw new Error(PROJECT_OPERATION_ERROR); + const pending = [...entries].filter(([candidate, entry]) => entry.active && contains(key, candidate)); + const marker = {}; + trees.set(key, marker); + return { ready: Promise.all(pending.map(([, entry]) => new Promise(resolve => entry.drained.push(resolve)))), + release() { if (trees.get(key) === marker) trees.delete(key); } }; + }, hold(project, alias = null) { const key = keyFor(project, alias); const entry = entryFor(key); - if (entry.held) throw new Error(PROJECT_OPERATION_ERROR); + if (entry.held || treeBlocked(key)) throw new Error(PROJECT_OPERATION_ERROR); entry.held = true; const ready = entry.active ? new Promise(resolve => { entry.drained.push(resolve); }) : Promise.resolve(); let released = false; diff --git a/test/dom-project-delete.test.js b/test/dom-project-delete.test.js index debf28e92..f00639629 100644 --- a/test/dom-project-delete.test.js +++ b/test/dom-project-delete.test.js @@ -9,6 +9,50 @@ const fs = require('node:fs'); const path = require('node:path'); const vm = require('node:vm'); +test('E worktree choices are individually previewed, never remembered, and main remains disabled', async t => { + const rows = [ + { path: 'C:/repo', branch: 'main', main: true, removable: false, reason: 'Main checkout is kept', sessions: [], dirty: [] }, + { path: 'C:/linked', branch: 'topic', main: false, removable: true, sessions: [], dirty: ['?? draft.txt'] }, + ]; + const h = setup(t, { worktrees: rows }); + h.w.localStorage.setItem('deleteProject.worktree:1', '1'); + let pending = h.start(); await flush(); + let box = h.document.querySelector('[data-choice-id="worktree:1"]'); + assert.ok(box, 'every linked worktree needs its own checkbox'); + assert.equal(box.checked, false); + assert.equal(h.document.querySelector('[data-choice-id="worktree:0"]').disabled, true); + assert.match(h.document.querySelector('.choice-dialog').textContent, /C:\/linked.*topic/s); + assert.match(h.document.querySelector('.choice-dialog').textContent, /draft\.txt/); + box.click(); await flush(); + assert.deepEqual(Array.from(h.calls.preview.at(-1).worktrees), ['C:/linked']); + h.confirm().click(); await pending; + pending = h.start(); await flush(); + box = h.document.querySelector('[data-choice-id="worktree:1"]'); + assert.equal(box.checked, false, 'accepted destructive worktree choices must reset on every open'); + h.cancel(); await pending; +}); + +test('E partial disk removal notice preserves per-path outcomes and recovery action', async t => { + const h = setup(t); + await h.w.settleProjectDeletion(h.p, { state: 'partial', operationId: 'disk', + worktrees: [{ path: 'C:/removed', state: 'removed' }, { path: 'C:/failed', state: 'failed', error: 'Inspect registration' }] }); + const notice = h.document.querySelector('.app-notice'); + assert.match(notice.textContent, /C:\/removed/, 'partial notice must show disk outcomes'); + assert.match(notice.textContent, /Inspect registration/); + assert.equal(notice.querySelector('.app-notice-action').textContent, 'Review remaining deletion'); +}); + +test('E changed dirty bytes after the visible row require reopening rather than silent new consent', async t => { + const row = { path: 'C:/linked', branch: 'topic', removable: true, fingerprint: 'shown', dirty: [], sessions: [] }; + const h = setup(t, { worktrees: [row] }); + const pending = h.start(); await flush(); + row.fingerprint = 'new-bytes'; row.dirty = ['?? unseen.txt']; + h.document.querySelector('[data-choice-id="worktree:0"]').click(); await flush(); + assert.equal(h.confirm().disabled, true, 'changed worktree preview must require reopening'); + assert.match(h.document.querySelector('.choice-dialog').textContent, /reopen/i); + h.cancel(); await pending; +}); + function persistence(h) { let global = { hiddenProjects: [], sidebarWidth: 100 }; Object.assign(h.w, { exitingApp: false, skippedWorkingSetEntries: new Map(), dormantWorkingSet: new Map(), diff --git a/test/project-delete-main.test.js b/test/project-delete-main.test.js index 7ec4afebc..282d4ccba 100644 --- a/test/project-delete-main.test.js +++ b/test/project-delete-main.test.js @@ -120,6 +120,43 @@ for (const populated of [false, true]) test(`real composition previews and commi if (populated) assert.ok(fs.existsSync(h.transcript)); }); +test('E main composition removes a selected folder before real writer completion and keeps external transcripts', supported, async t => { + const h = await setup(t, true); + h.main.dispose(); + const linked = path.join(h.projectPath, 'linked'); fs.mkdirSync(linked); + fs.writeFileSync(path.join(linked, 'draft'), 'discard only on consent'); + h.ports.cliSessionState.getSidebarDescriptors = () => []; + const removed = []; + h.ports.worktreeGit = async args => { + if (args.includes('list')) { + const separator = args.includes('-z') ? '\0' : '\n'; + return [h.projectPath, linked].filter(p => fs.existsSync(p)).map(p => + ['worktree ' + p.replaceAll('\\', '/'), 'HEAD abc', 'branch refs/heads/topic', ''].join(separator) + separator).join(''); + } + if (args.includes('rev-parse')) return path.join(h.projectPath, 'no-lock') + '\n'; + if (args.includes('ls-files')) return ''; + if (args.includes('status')) return path.resolve(args[1]) === linked ? '?? draft\0' : ''; + if (args.includes('remove')) { + assert.equal(h.calls.includes('completeProjectDeletion'), false, 'disk must precede writer submission'); + removed.push(args.at(-1)); fs.rmSync(linked, { recursive: true }); return ''; + } + throw new Error('Unexpected git call'); + }; + const main = h.compose(); main.attach(h.ports.getMainWindow()); h.load(); await main.startRecovery(); + const capability = await h.preview(); + const selected = capability.plan.worktrees.find(row => path.resolve(row.path) === linked); + assert.equal(selected.removable, true, JSON.stringify(selected)); + const preview = await h.invoke('preview-project-delete', { projectPath: h.projectPath, options, worktrees: [selected.path] }); + assert.ok(preview.token, JSON.stringify(preview)); + assert.equal(fs.existsSync(linked), true, 'preview must have no filesystem effects'); + const result = await h.execute(preview); + assert.equal(result.state, 'committed', JSON.stringify(result)); + assert.deepEqual(removed, [selected.path]); + assert.equal(result.worktrees[0].state, 'removed'); + assert.ok(fs.existsSync(h.transcript)); + assert.equal(fs.existsSync(linked), false); +}); + test('early attach binds first loaded document and reload revokes old token', supported, async t => { const h = await setup(t); await h.main.startRecovery(); assert.equal((await h.preview()).code, 'UNAUTHORIZED'); diff --git a/test/project-delete-worktrees-real-git.test.js b/test/project-delete-worktrees-real-git.test.js new file mode 100644 index 000000000..a5f2c0079 --- /dev/null +++ b/test/project-delete-worktrees-real-git.test.js @@ -0,0 +1,63 @@ +'use strict'; + +const test = require('node:test'); +const assert = require('node:assert/strict'); +const fs = require('node:fs'); +const os = require('node:os'); +const path = require('node:path'); +const { execFileSync } = require('node:child_process'); +const { localGitEnv } = require('../src/main/changes/git-changes-runner'); +const shared = require('../worktree-delete'); +let implementation; +try { implementation = require('../src/main/projects/project-delete-worktrees'); } +catch (error) { if (error.code !== 'MODULE_NOT_FOUND') throw error; } + +function gitFixture(t) { + assert.equal(typeof implementation?.createProjectDeleteWorktrees, 'function', 'production linked-worktree adapter must exist'); + const root = fs.realpathSync.native(fs.mkdtempSync(path.join(os.tmpdir(), 'delete-e-'))); + t.after(() => fs.rmSync(root, { recursive: true, force: true })); + const env = { ...localGitEnv(), GIT_CONFIG_GLOBAL: path.join(root, 'no-config'), GIT_CONFIG_NOSYSTEM: '1', + GIT_AUTHOR_NAME: 'Test', GIT_AUTHOR_EMAIL: 'test@example.invalid', GIT_COMMITTER_NAME: 'Test', GIT_COMMITTER_EMAIL: 'test@example.invalid' }; + const commands = [], git = args => execFileSync('git', args, { cwd: root, env, encoding: 'utf8', timeout: 15000, windowsHide: true }); + git(['init', '-q', '--template=']); fs.writeFileSync(path.join(root, 'tracked'), 'base'); + git(['add', '.']); git(['commit', '-qm', 'fixture']); + const target = path.join(root, 'linked é'), kept = path.join(root, 'kept'); + git(['worktree', 'add', '-qb', 'topic', target]); git(['worktree', 'add', '-qb', 'keep', kept]); + const state = { sessions: [], candidates: [], jobs: [] }; + const runGit = async (args, consume) => { commands.push(args); return consume ? shared.streamGit(args, consume, { env }) : git(args); }; + const adapter = implementation.createProjectDeleteWorktrees({ runGit, readActivity: async () => ({ complete: true, ...state }) }); + const project = { alias: null, projectPath: root }; + const budget = () => ({ signal: new AbortController().signal, deadline: Date.now() + 15000, limit: 20000 }); + return { root, target, kept, state, commands, adapter, project, budget }; +} + +test('E real Git discovery lists main, branch, dirty/untracked bytes; removes exactly the reviewed linked directory', async t => { + const f = gitFixture(t); + fs.writeFileSync(path.join(f.target, 'untracked'), 'discard'); + const rows = await f.adapter.preview(f.project, f.budget()); + assert.equal(rows.find(row => row.main).removable, false); + const selected = rows.find(row => path.resolve(row.path) === f.target); + assert.equal(selected.branch, 'topic'); assert.equal(selected.removable, true); + assert.ok(selected.dirty.some(line => line.includes('untracked'))); + const results = []; + assert.equal(await f.adapter.remove(f.project, [selected], row => results.push(row)), true); + assert.equal(fs.existsSync(f.target), false); assert.equal(fs.existsSync(f.kept), true); + assert.equal(fs.readFileSync(path.join(f.root, 'tracked'), 'utf8'), 'base'); + assert.deepEqual(results.map(row => row.state), ['removed']); + assert.equal(f.commands.filter(args => args.includes('remove')).length, 1); +}); + +test('E real Git changed contents and new live sessions refuse before any disk removal', async t => { + const f = gitFixture(t); + fs.writeFileSync(path.join(f.target, 'untracked'), 'old'); + const rows = await f.adapter.preview(f.project, f.budget()), selected = rows.find(row => path.resolve(row.path) === f.target); + fs.writeFileSync(path.join(f.target, 'untracked'), 'new'); + assert.equal(await f.adapter.remove(f.project, [selected], () => {}), false); + assert.equal(fs.existsSync(f.target), true); + const fresh = (await f.adapter.preview(f.project, f.budget())).find(row => path.resolve(row.path) === f.target); + f.state.sessions.push({ sessionId: 'live', cwd: f.target }); + assert.equal(await f.adapter.remove(f.project, [fresh], () => {}), false); + assert.equal(f.commands.some(args => args.includes('remove')), false, 'late activity must prevent Git removal'); + const blocked = (await f.adapter.preview(f.project, f.budget())).find(row => path.resolve(row.path) === f.target); + assert.equal(blocked.removable, false); assert.equal(blocked.sessions[0].sessionId, 'live'); +}); diff --git a/test/project-delete-worktrees.test.js b/test/project-delete-worktrees.test.js new file mode 100644 index 000000000..7f75b5a7c --- /dev/null +++ b/test/project-delete-worktrees.test.js @@ -0,0 +1,243 @@ +'use strict'; + +const test = require('node:test'); +const assert = require('node:assert/strict'); +const fs = require('node:fs'); +const os = require('node:os'); +const path = require('node:path'); +const { createProjectDeletePlanner } = require('../src/main/projects/project-delete-plan'); +const { createProjectDeleteService } = require('../src/main/projects/project-delete'); +const { createProjectOperationGate } = require('../src/main/shared/project-operation-gate'); +let implementation; +try { implementation = require('../src/main/projects/project-delete-worktrees'); } +catch (error) { if (error.code !== 'MODULE_NOT_FOUND') throw error; } +const options = { sessions: false, settings: false, schedules: false, transcripts: false, stopBackgroundJobs: false }; + +test('E production activity reader includes descendant sessions, schedules and refused background records', async t => { + const { createProjectDeleteRuntime } = require('../src/main/projects/project-delete-main'); + const root = fs.realpathSync.native(fs.mkdtempSync(path.join(os.tmpdir(), 'e-activity-'))); + t.after(() => fs.rmSync(root, { recursive: true, force: true })); + const child = path.join(root, 'child'); fs.mkdirSync(child); + const jobsDir = path.join(root, 'jobs'); fs.mkdirSync(path.join(jobsDir, '1234abcd'), { recursive: true }); + fs.writeFileSync(path.join(jobsDir, '1234abcd', 'state.json'), JSON.stringify({ state: 'done', cwd: child, + sessionId: '12345678-1234-1234-1234-123456789abc' })); + const runtime = createProjectDeleteRuntime({ activeSessions: new Map([['live', { cwd: child, sessionId: 'live' }]]), jobsDir, + homeDir: root, runClaude: async () => ({ code: 0, stdout: '[]' }), cliSessionState: { + getSidebarDescriptors: options => { + assert.equal(options?.allWriters, true, 'worktree deletion must include every descriptor writer'); + return [{ sessionId: 'external', cwd: child }]; + }, + readStatusEvidence: async () => ({ known: true, live: { pid: 123 }, ambiguous: false }), + getScheduleRunSnapshot: () => [{ sessionId: 'schedule', cwd: child }], + } }); + assert.equal(typeof runtime.readWorktreeActivity, 'function', 'linked worktrees require authoritative descendant activity'); + const result = await runtime.readWorktreeActivity({ alias: null, projectPath: root }, + { signal: new AbortController().signal, deadline: Date.now() + 15000, limit: 20000, snapshot: { sessions: [] } }); + assert.ok(result.sessions.some(row => row.sessionId === 'live')); + assert.ok(result.sessions.some(row => row.sessionId === 'external')); + assert.ok(result.jobs.some(row => row.id === '1234abcd'), 'done background record must remain refused'); + assert.ok(result.jobs.some(row => row.sessionId === 'schedule')); + assert.ok(result.candidates.some(row => row.reason.includes('#1090'))); +}); + +function planning(rows) { + const projectPath = path.resolve(os.tmpdir(), 'e-planning'); + const state = { rows, removed: [], events: [], revision: '1' }; + const empty = { complete: true, groups: [], members: [], tabs: [], jobs: [], schedules: [], candidates: [] }; + const worktrees = { + preview: async () => structuredClone(state.rows), + async remove(project, selected, record) { + for (const row of selected) { + state.events.push('remove:' + row.path); + const result = { path: row.path, state: state.fail === row.path ? 'failed' : 'removed', error: state.fail === row.path ? 'Git refused; inspect disk' : undefined }; + record(result); + if (result.state === 'failed') return false; + state.removed.push(row.path); + } + return true; + }, + }; + const deps = { + waitForIndex: async () => {}, readSnapshot: async () => ({ complete: true, initialScanComplete: true, revision: state.revision, + projects: [{ alias: null, projectPath, folderKeys: [] }], declaredHosts: [] }), + discoverOwnership: async () => empty, discoverSchedules: async () => empty, + readRuntimeState: async () => empty, readRevision: async () => state.revision, worktrees, + }; + const planner = createProjectDeletePlanner(deps); + const request = selected => ({ projectPath, options, worktrees: selected }); + return { state, deps, planner, request, projectPath, worktrees }; +} + +test('E planner binds exact individual selection and content to the fingerprint', async () => { + const row = { path: path.resolve(os.tmpdir(), 'linked-e'), branch: 'topic', removable: true, fingerprint: 'one', sessions: [], dirty: [] }; + const f = planning([row]); + const kept = await f.planner.preview(f.request([])); + assert.equal(kept.ok, true, 'empty worktree selection must be accepted'); + const chosen = await f.planner.preview(f.request([row.path])); + assert.equal(chosen.ok, true, 'individual worktree selection must be accepted'); + assert.equal(chosen.plan.worktrees[0].selected, true); + assert.notEqual(chosen.plan.fingerprint, kept.plan.fingerprint, 'selection must change the token fingerprint'); + assert.equal((await f.planner.revalidate(chosen.plan)).same, true); + f.state.rows[0].fingerprint = 'changed-content'; + assert.equal((await f.planner.revalidate(chosen.plan)).same, false, 'changed worktree content must invalidate consent'); + for (const selected of [[row.path, row.path], [path.resolve(os.tmpdir(), 'foreign')], [f.projectPath]]) { + const reply = await f.planner.preview(f.request(selected)); + assert.ok(!reply.ok || reply.plan.refusals.length, 'foreign, main and duplicate selections must refuse'); + } + f.state.rows[0].removable = false; f.state.rows[0].reason = 'Stop live session first'; + assert.ok((await f.planner.preview(f.request([row.path]))).plan.refusals.length); +}); + +test('E subtree holds drain admitted children and reject new descendant launches', async () => { + const gate = createProjectOperationGate(), root = path.resolve(os.tmpdir(), 'e-gate'); + assert.equal(typeof gate.holdTree, 'function', 'worktree deletion needs subtree exclusion'); + const lease = gate.tryAdmit(path.join(root, 'nested')); + const hold = gate.holdTree(root); let ready = false; + hold.ready.then(() => { ready = true; }); await Promise.resolve(); + assert.equal(ready, false, 'existing descendant launch must drain'); + assert.equal(gate.tryAdmit(path.join(root, 'new')), null); + assert.throws(() => gate.hold(path.join(root, 'child'))); + const sibling = gate.tryAdmit(root + '-sibling'); assert.ok(sibling); sibling.release(); + const remote = gate.tryAdmit(root, 'remote'); assert.ok(remote); remote.release(); + lease.release(); await hold.ready; hold.release(); + const reopened = gate.tryAdmit(path.join(root, 'new')); assert.ok(reopened); reopened.release(); +}); + +async function serviceFixture(t, fail) { + const a = path.resolve(os.tmpdir(), 'e-selected-a'), b = path.resolve(os.tmpdir(), 'e-selected-b'); + const f = planning([a, b].map(p => ({ path: p, removable: true, fingerprint: p, sessions: [], dirty: [] }))); + f.state.fail = fail ? b : undefined; + const gate = createProjectOperationGate(), sender = { valid: () => true }; + const writer = { + listProjectDeletionOperations: async () => ({ rows: [], revision: 1, nextCursor: null }), + readProjectDeletionScope: async () => ({ writerRevision: 1, projectEpoch: 0, writerMembershipDigest: 'durable' }), + reserveProjectDeletion: () => ({ ready: Promise.resolve(), release() {} }), + async completeProjectDeletion() { + f.state.events.push('metadata'); + return { state: 'committed', terminal: true, receiptAvailable: true, invalidation: {}, committedRevision: 2 }; + }, + }; + const stop = { preflight: async () => ({ ok: true }), stop: async () => { + f.state.events.push('stop'); return { ok: true, stopped: [], failed: [], skipped: [] }; + }, verify: async () => ({ ok: true }) }; + const service = createProjectDeleteService({ writer, planner: f.planner, inventory: { inspectRetainedFiles: async () => [] }, + stop, gate, worktrees: f.worktrees }); + t.after(() => service.dispose()); await service.initialize(); + return { ...f, a, b, gate, service, sender, writer }; +} + +test('E disk effects remain partial when the metadata writer proves no commit', async t => { + const f = await serviceFixture(t); + f.writer.completeProjectDeletion = async () => ({ state: 'notStarted', terminal: true, receiptAvailable: true, noLateCommit: true }); + const preview = await f.service.preview(f.sender, f.request([f.a])); + const result = await f.service.execute(f.sender, { token: preview.token, fingerprint: preview.plan.fingerprint }); + assert.equal(result.state, 'partial', 'removed folders cannot be reported as an operation that never started'); + assert.equal(result.partial, true); + assert.equal(result.worktrees[0].state, 'removed'); +}); + +test('E service holds selected descendant launches until the removal promise settles', async t => { + const f = await serviceFixture(t); let finish, entered; + const started = new Promise(resolve => { entered = resolve; }); + f.worktrees.remove = async () => { entered(); await new Promise(resolve => { finish = resolve; }); return false; }; + const preview = await f.service.preview(f.sender, f.request([f.a])); + const executing = f.service.execute(f.sender, { token: preview.token, fingerprint: preview.plan.fingerprint }); + await started; + const lease = f.gate.tryAdmit(path.join(f.a, 'new-session')); + finish(); await executing; + assert.equal(lease, null, 'no descendant may launch while disk removal is in flight'); +}); + +test('E service removes only selected worktrees after stop and before metadata', async t => { + const f = await serviceFixture(t); + const preview = await f.service.preview(f.sender, f.request([f.a])); + assert.ok(preview.token, 'selected worktrees must produce an owned token'); + const result = await f.service.execute(f.sender, { token: preview.token, fingerprint: preview.plan.fingerprint }); + assert.equal(result.ok, true); + assert.deepEqual(f.state.events, ['stop', 'remove:' + f.a, 'metadata']); + assert.deepEqual(result.worktrees.map(row => [row.path, row.state]), [[f.a, 'removed']]); + assert.deepEqual(f.state.removed, [f.a]); +}); + +test('E failed second removal seals a partial result, never submits metadata or replays on state read', async t => { + const f = await serviceFixture(t, true); + const preview = await f.service.preview(f.sender, f.request([f.a, f.b])); + assert.ok(preview.token, 'selected worktrees must produce an owned token'); + const result = await f.service.execute(f.sender, { token: preview.token, fingerprint: preview.plan.fingerprint }); + assert.equal(result.state, 'partial'); assert.equal(result.ok, false); + assert.deepEqual(result.worktrees.map(row => row.state), ['removed', 'failed']); + assert.equal(f.state.events.includes('metadata'), false, 'disk failure must keep parent metadata untouched'); + await f.service.readState(f.sender, { operationId: result.operationId }); + assert.deepEqual(f.state.events, ['stop', 'remove:' + f.a, 'remove:' + f.b]); + const lease = f.gate.tryAdmit(path.join(f.a, 'child')); assert.ok(lease); lease.release(); +}); + +function gitFixture(t) { + assert.equal(typeof implementation?.createProjectDeleteWorktrees, 'function', 'production linked-worktree adapter must exist'); + const root = fs.realpathSync.native(fs.mkdtempSync(path.join(os.tmpdir(), 'delete-e-'))); + t.after(() => fs.rmSync(root, { recursive: true, force: true })); + const target = path.join(root, 'linked'), kept = path.join(root, 'kept'); + fs.mkdirSync(target); fs.mkdirSync(kept); fs.writeFileSync(path.join(root, 'tracked'), 'base'); + const commands = [], state = { sessions: [], candidates: [], jobs: [] }; + const runGit = async args => { + commands.push(args); + if (args.includes('list')) { + const separator = args.includes('-z') ? '\0' : '\n'; + return [root, target, kept].filter(p => fs.existsSync(p)).map(p => + ['worktree ' + p.replaceAll('\\', '/'), 'HEAD abc', 'branch refs/heads/topic', ''].join(separator) + separator).join(''); + } + if (args.includes('rev-parse')) return path.join(root, 'absent-lock') + '\n'; + if (args.includes('ls-files')) return ''; + if (args.includes('status')) return fs.existsSync(path.join(args[1], 'untracked')) ? '?? untracked\0' : ''; + if (args.includes('remove')) { fs.rmSync(args.at(-1), { recursive: true }); return ''; } + throw new Error('Unexpected Git command: ' + args.join(' ')); + }; + const adapter = implementation.createProjectDeleteWorktrees({ runGit, readActivity: async () => ({ complete: true, ...state }) }); + const project = { alias: null, projectPath: root.replaceAll('\\', '/').toLowerCase() }; + if (process.platform !== 'win32') project.projectPath = root; + const budget = () => ({ signal: new AbortController().signal, deadline: Date.now() + 15000, limit: 20000 }); + return { root, target, kept, state, commands, adapter, project, budget }; +} + +test('E shared removal with a controlled Git port discovery lists main, branch, dirty/untracked bytes; removes exactly the reviewed linked directory', async t => { + const f = gitFixture(t); + fs.writeFileSync(path.join(f.target, 'untracked'), 'discard'); + const rows = await f.adapter.preview(f.project, f.budget()); + assert.equal(rows.find(row => row.main).removable, false); + assert.equal(rows.find(row => row.main).statusKnown, true, 'main checkout status must be previewed even though it is never removable'); + const selected = rows.find(row => path.resolve(row.path) === f.target); + assert.equal(selected.branch, 'topic'); assert.equal(selected.removable, true); + assert.ok(selected.dirty.some(line => line.includes('untracked'))); + const results = []; + assert.equal(await f.adapter.remove(f.project, [selected], row => results.push(row)), true); + assert.equal(fs.existsSync(f.target), false); assert.equal(fs.existsSync(f.kept), true); + assert.equal(fs.readFileSync(path.join(f.root, 'tracked'), 'utf8'), 'base'); + assert.deepEqual(results.map(row => row.state), ['removed']); + assert.equal(f.commands.filter(args => args.includes('remove')).length, 1); +}); + +test('E adapter rejects remote, main checkout and uncertain activity without invoking Git removal', async t => { + const f = gitFixture(t); + await assert.rejects(f.adapter.preview({ ...f.project, alias: 'remote' }, f.budget()), { code: 'WORKTREE_UNAVAILABLE' }); + let rows = await f.adapter.preview(f.project, f.budget()); + assert.equal(await f.adapter.remove(f.project, [rows.find(row => row.main)], () => {}), false); + f.state.candidates.push({ reason: 'External ownership unknown' }); + rows = await f.adapter.preview(f.project, f.budget()); + assert.equal(rows.find(row => path.resolve(row.path) === f.target).removable, false); + assert.equal(f.commands.some(args => args.includes('remove')), false); +}); + +test('E shared removal with a controlled Git port changed contents and new live sessions refuse before any disk removal', async t => { + const f = gitFixture(t); + fs.writeFileSync(path.join(f.target, 'untracked'), 'old'); + const rows = await f.adapter.preview(f.project, f.budget()), selected = rows.find(row => path.resolve(row.path) === f.target); + fs.writeFileSync(path.join(f.target, 'untracked'), 'new'); + assert.equal(await f.adapter.remove(f.project, [selected], () => {}), false); + assert.equal(fs.existsSync(f.target), true); + const fresh = (await f.adapter.preview(f.project, f.budget())).find(row => path.resolve(row.path) === f.target); + f.state.sessions.push({ sessionId: 'live', cwd: f.target }); + assert.equal(await f.adapter.remove(f.project, [fresh], () => {}), false); + assert.equal(f.commands.some(args => args.includes('remove')), false, 'late activity must prevent Git removal'); + const blocked = (await f.adapter.preview(f.project, f.budget())).find(row => path.resolve(row.path) === f.target); + assert.equal(blocked.removable, false); assert.equal(blocked.sessions[0].sessionId, 'live'); +}); From 49cb3cea71c9fda73643e5f2cc4b95fafd984e4c Mon Sep 17 00:00:00 2001 From: Jean-Baptiste Date: Fri, 13 Nov 2026 01:55:19 +0100 Subject: [PATCH 2/8] (projects): keep worktree removal labels out of the settings-default scan (#474) --- .ai/contexts/project-delete.md | 7 +++++++ public/sidebar.js | 13 ++++++++----- 2 files changed, 15 insertions(+), 5 deletions(-) diff --git a/.ai/contexts/project-delete.md b/.ai/contexts/project-delete.md index 57e80b369..19aae91c8 100644 --- a/.ai/contexts/project-delete.md +++ b/.ai/contexts/project-delete.md @@ -39,6 +39,13 @@ all its contents, including ignored files and any schedules/memory/work-files inside it; category `kept` applies to the parent's data, not files inside selected linked directories. +The dialog keeps the explicit `Kept on disk:` project-folder notice alongside +the selected linked-folder removal warning. Row session fallbacks are computed +before formatting the worktree label, and the unavailable reason uses an +explicit conditional: these are display text, not `SETTING_DEFAULTS` overrides. +The renderer settings-default scanner remains unchanged; the Settings deletion +regression retains its disk-retention, cancellation and in-app-dialog assertions. + Execution drains holds, revalidates, stops/verifies parent targets, preflights all selected rows, then removes sequentially through the shared path with fresh per-removal activity/status checks. A failed removal stops the sequence. Only diff --git a/public/sidebar.js b/public/sidebar.js index d8a350db3..5b8a640e2 100644 --- a/public/sidebar.js +++ b/public/sidebar.js @@ -1121,7 +1121,7 @@ async function confirmAndDeleteProjectFolder(project, button) { title: 'Delete project from Switchboard?', message: [`${project.remoteAlias || 'Local'} — ${capabilities.plan.project.projectPath}`, 'Choose which app data to discard. Retained session metadata is archived.', - 'The project folder is always kept. Only individually selected linked worktree folders are removed, including their ignored files. All remote server files are kept.', + 'Kept on disk: the project folder. Only individually selected linked worktree folders are removed, including their ignored files. All remote server files are kept.', 'Other transcripts, schedules, memory and .work-files stay on disk. Linked worktree history is kept in Switchboard.', 'Kept schedules may reactivate when you add the project again. Retained transcripts may restore their titles.'], choices: [ @@ -1129,10 +1129,13 @@ async function confirmAndDeleteProjectFolder(project, button) { disabled: categories.sessions?.available !== true, disabledReason: categories.sessions?.reason || 'Session metadata is unavailable' }, { id: 'settings', label: 'Delete project settings', checked: true, rememberKey: 'deleteProject.settings', disabled: categories.settings?.available !== true, disabledReason: categories.settings?.reason || 'Project settings are unavailable' }, - ...worktreeChoices.map((row, i) => ({ id: 'worktree:' + i, - label: `${row.main ? 'Main checkout (kept)' : 'Remove worktree from disk'}: ${row.path} — ${row.branch}. ${row.statusKnown === false ? 'Status unavailable' : row.dirty?.length ? row.dirty.join('; ') : 'Clean'}. Sessions: ${row.sessionsKnown === false ? 'uncertain' : (row.sessions || []).map(session => session.sessionId || session.id).join(', ') || 'none'}. Ignored files are removed too.`, - checked: false, disabled: row.removable !== true || row.main || row.projectDirectory, - disabledReason: row.reason || 'This worktree cannot be removed.' })), + ...worktreeChoices.map((row, i) => { + const sessionLabel = row.sessionsKnown === false ? 'uncertain' : (row.sessions || []).map(session => session.sessionId || session.id).join(', ') || 'none'; + return { id: 'worktree:' + i, + label: `${row.main ? 'Main checkout (kept)' : 'Remove worktree from disk'}: ${row.path} — ${row.branch}. ${row.statusKnown === false ? 'Status unavailable' : row.dirty?.length ? row.dirty.join('; ') : 'Clean'}. Sessions: ${sessionLabel}. Ignored files are removed too.`, + checked: false, disabled: row.removable !== true || row.main || row.projectDirectory, + disabledReason: row.reason ? row.reason : 'This worktree cannot be removed.' }; + }), ], onChange: async values => { const reply = await projectDeletionCall('previewProjectDelete', request(values)); From fe772153607c34d64a2719ce2d9d9145339d2ac9 Mon Sep 17 00:00:00 2001 From: Jean-Baptiste Date: Fri, 13 Nov 2026 03:25:05 +0100 Subject: [PATCH 3/8] (projects): list worktrees without -z and scope the deletion preview (#474) Git before 2.36 has no 'worktree list -z', so the dialog showed no worktree rows on older Git. Scan activity once per preview, fingerprint only selected rows, keep refusals apart from partial failures, and tidy the row labels. --- .ai/contexts/project-delete.md | 34 ++++--- main.js | 5 +- public/sidebar.js | 9 +- src/main/projects/project-delete-main.js | 96 ++++++++++++------- src/main/projects/project-delete-plan.js | 9 +- src/main/projects/project-delete-worktrees.js | 76 ++++++++------- src/main/projects/project-delete.js | 4 +- test/dom-project-delete.test.js | 24 +++++ .../project-delete-worktrees-real-git.test.js | 3 +- test/project-delete-worktrees.test.js | 88 ++++++++++++++++- test/worktree-delete.test.js | 15 +++ worktree-delete.js | 37 ++++--- 12 files changed, 295 insertions(+), 105 deletions(-) diff --git a/.ai/contexts/project-delete.md b/.ai/contexts/project-delete.md index 19aae91c8..72fc5bc62 100644 --- a/.ai/contexts/project-delete.md +++ b/.ai/contexts/project-delete.md @@ -10,8 +10,11 @@ main/project-directory identity, dirty/untracked status, sessions, jobs and an availability reason. Status/activity failures are explicit, never rendered as clean/idle. The main checkout, the selected project directory and its ancestors are never removable. Remote selection refuses because no authoritative remote -filesystem/removal port exists. Local discovery uses NUL-delimited Git porcelain; -Git versions without that list format leave physical deletion unavailable. +filesystem/removal port exists. Local discovery uses newline-delimited Git +`worktree list --porcelain`, with the shared parser decoding Git-quoted paths, +compatible with Git 2.24. Inventory failures have a visible dialog reason. +Kept rows do not read status, scan activity or hash content. Removable labels +show the ignored-entry count and at most five dirty entries plus the remainder. `project-delete-worktrees.js` calls the existing `worktree-delete` readStatus and removeWorktree functions. Clean removal uses no force; dirty content is hashed @@ -22,7 +25,10 @@ does not unlink automatically, traverse junctions, delete branches or invoke cleanupWorktree. Linked histories remain outside the parent's metadata manifest. The runtime reads all CLI descriptor writers, indexed session evidence, active -tabs, schedules and background job files/list. Descendant cwd counts as worktree +tabs, schedules and background job files/list once per preview, shared with the +parent runtime inventory. Path resolutions and background records are cached only +within that inventory; the results are partitioned by folder in memory. +Descendant cwd counts as worktree activity. Live or uncertain sessions disable the row; E does not extend A4 stop authority to a linked project's sessions. Background records remain refused under #1090 even when done. Local subtree launch holds cover selected directories @@ -30,7 +36,7 @@ and wait for previously admitted descendant launches; archive reservations inclu the selected linked identities as well as the parent. External processes and filesystem writers are not locked by these holds. -Rows and selection enter the planner fingerprint, retained in the single-use +Only selected removable rows enter the planner fingerprint, retained in the single-use document-bound token. Renderer boxes are individually unchecked on every open with no rememberKey. A changed selected row fingerprint requires reopening: a newer hidden detail panel cannot silently authorize newly dirty bytes. @@ -40,21 +46,22 @@ inside it; category `kept` applies to the parent's data, not files inside select linked directories. The dialog keeps the explicit `Kept on disk:` project-folder notice alongside -the selected linked-folder removal warning. Row session fallbacks are computed -before formatting the worktree label, and the unavailable reason uses an -explicit conditional: these are display text, not `SETTING_DEFAULTS` overrides. -The renderer settings-default scanner remains unchanged; the Settings deletion -regression retains its disk-retention, cancellation and in-app-dialog assertions. +the selected linked-folder removal warning. Kept rows carry no ignored-file +removal warning. Unselected dirty content does not invalidate project consent. Execution drains holds, revalidates, stops/verifies parent targets, preflights all selected rows, then removes sequentially through the shared path with fresh -per-removal activity/status checks. A failed removal stops the sequence. Only +per-removal activity/status checks. Confirm inventories inspect only selected +folders; the final metadata preview skips physical inventory. A failed removal +stops the sequence. Only after removal does it reread writer scope and revalidate parent membership/death, omitting already-consumed physical selections from this final preview. The writer's manifest/options remain metadata-only. The operation retains launch holds until Git settles, even after an early IPC unknown reply. -`worktrees` on operation views records removed/failed/remaining paths. An attempted +`worktrees` on operation views records removed/failed/refused/remaining paths. +A refusal before Git removal has no disk effect and does not make the operation +partial. An inventory-wide refusal has no individual path. An attempted disk effect followed by failure remains partial even when the metadata receipt proves notStarted. The renderer's persistent notice lists these paths and offers fresh review, never replay. A metadata commit still publishes only its own exact @@ -67,8 +74,9 @@ never repeats disk removal or treats a metadata receipt as proof of disk success Plain-Node tests cover the production planner, service, activity reader, subtree gate and shared removal with controlled Git replies and real disposable files. The composition witness includes the real writer/SQLite fixture. Separate real -Git worktree tests are retained for CI; the local sandbox refuses their temporary -linked `.git` creation. Native UI, full process restart, live process death and +Git worktree tests exercise the installed Git version. The former `list -z` +command required Git 2.36 and failed on Git 2.24 before inventory could complete. +Native UI, full process restart, live process death and filesystem races after the shared last scan remain unverified locally. ## Renderer boundary (A4d) diff --git a/main.js b/main.js index 82aa1278c..75e9eacf3 100644 --- a/main.js +++ b/main.js @@ -1150,8 +1150,11 @@ ipcMain.handle('check-delete-worktree', (_event, worktreePath) => { function worktreeGit(args, consume) { if (consume) return worktreeDelete.streamGit(args, consume, { spawn: spawnChild, env: localGitEnv() }); + let command = 0; + while (args[command] === '-C' || args[command] === '-c') command += 2; + const removing = args[command] === 'worktree' && args[command + 1] === 'remove'; return new Promise((resolve, reject) => { - execFile('git', args, { env: localGitEnv(), timeout: args.includes('remove') ? 120000 : 15000, maxBuffer: 16 * 1024 * 1024 }, (err, stdout, stderr) => { + execFile('git', args, { env: localGitEnv(), timeout: removing ? 120000 : 15000, maxBuffer: 16 * 1024 * 1024 }, (err, stdout, stderr) => { if (err) reject(Object.assign(new Error((stderr || err.message || String(err)).trim()), { code: err.code, killed: err.killed, signal: err.signal })); else resolve(stdout); }); diff --git a/public/sidebar.js b/public/sidebar.js index 5b8a640e2..f12854124 100644 --- a/public/sidebar.js +++ b/public/sidebar.js @@ -1123,7 +1123,8 @@ async function confirmAndDeleteProjectFolder(project, button) { 'Choose which app data to discard. Retained session metadata is archived.', 'Kept on disk: the project folder. Only individually selected linked worktree folders are removed, including their ignored files. All remote server files are kept.', 'Other transcripts, schedules, memory and .work-files stay on disk. Linked worktree history is kept in Switchboard.', - 'Kept schedules may reactivate when you add the project again. Retained transcripts may restore their titles.'], + 'Kept schedules may reactivate when you add the project again. Retained transcripts may restore their titles.', + ...(capabilities.plan.warnings || []).filter(row => row.code === 'WORKTREE_UNAVAILABLE').map(row => 'Worktree inventory unavailable: ' + row.error)], choices: [ { id: 'sessions', label: 'Discard session names, pins and app metadata', checked: false, rememberKey: 'deleteProject.sessions', disabled: categories.sessions?.available !== true, disabledReason: categories.sessions?.reason || 'Session metadata is unavailable' }, @@ -1131,8 +1132,12 @@ async function confirmAndDeleteProjectFolder(project, button) { disabled: categories.settings?.available !== true, disabledReason: categories.settings?.reason || 'Project settings are unavailable' }, ...worktreeChoices.map((row, i) => { const sessionLabel = row.sessionsKnown === false ? 'uncertain' : (row.sessions || []).map(session => session.sessionId || session.id).join(', ') || 'none'; + const kept = row.main || row.projectDirectory; + const dirty = row.dirty?.slice(0, 5).join('; ') + (row.dirty?.length > 5 ? `; and ${row.dirty.length - 5} more` : ''); + const status = kept ? '' : ` ${row.statusKnown === false ? 'Status unavailable' : row.dirty?.length ? dirty : 'Clean'}. Sessions: ${sessionLabel}.`; + const ignored = row.removable ? ` ${row.ignoredCount || 0} ignored entries. Ignored files are removed too.` : ''; return { id: 'worktree:' + i, - label: `${row.main ? 'Main checkout (kept)' : 'Remove worktree from disk'}: ${row.path} — ${row.branch}. ${row.statusKnown === false ? 'Status unavailable' : row.dirty?.length ? row.dirty.join('; ') : 'Clean'}. Sessions: ${sessionLabel}. Ignored files are removed too.`, + label: `${row.main ? 'Main checkout (kept)' : kept ? 'Project directory (kept)' : 'Remove worktree from disk'}: ${row.path} — ${row.branch}.${status}${ignored}`, checked: false, disabled: row.removable !== true || row.main || row.projectDirectory, disabledReason: row.reason ? row.reason : 'This worktree cannot be removed.' }; }), diff --git a/src/main/projects/project-delete-main.js b/src/main/projects/project-delete-main.js index 27913450c..b3eb40047 100644 --- a/src/main/projects/project-delete-main.js +++ b/src/main/projects/project-delete-main.js @@ -21,6 +21,17 @@ function createProjectDeleteRuntime(ports) { const io = ports.fs || fs, now = ports.now || Date.now; const schedule = ports.schedule || setTimeout, cancel = ports.cancel || clearTimeout; const scopes = new AsyncLocalStorage(); + const inventories = new WeakMap(); + const inventoryFor = budget => { + const key = budget.signal || budget; + if (!inventories.has(key)) inventories.set(key, { paths: new Map() }); + return inventories.get(key); + }; + const resolvePath = (value, budget) => { + const paths = inventoryFor(budget).paths; + if (!paths.has(value)) paths.set(value, bounded(() => io.realpath(value), budget)); + return paths.get(value); + }; const captureRuntimeRelease = () => { const scope = scopes.getStore(); return () => { scope?.members.clear(); scope?.pins.clear(); }; @@ -45,9 +56,8 @@ function createProjectDeleteRuntime(ports) { if (dispose && !accepted) void work.then(dispose, () => {}).catch(() => {}); } } - async function readJobs(project, budget) { - if (project.alias !== null) throw fail('DISCOVERY_UNAVAILABLE', 'Remote background inventory has no exhaustive read port.'); - const jobs = [], candidates = [], records = new Map(); + async function scanJobs(budget) { + const candidates = [], records = new Map(); let directory, count = 0, bytes = 0; try { if ((await bounded(() => io.lstat(ports.jobsDir), budget)).isSymbolicLink()) throw fail('DISCOVERY_CANDIDATE', 'Linked job directory.'); @@ -88,11 +98,20 @@ function createProjectDeleteRuntime(ports) { if (!row.id || !records.has(row.id)) candidates.push({ id: row.id || row.sessionId, reason: 'Background list has no durable job record.' }); else records.set(row.id, { ...records.get(row.id), cwd: row.cwd || records.get(row.id).cwd }); } - const root = await bounded(() => io.realpath(project.projectPath), budget); + return { candidates, records }; + } + async function readJobs(project, budget) { + if (project.alias !== null) throw fail('DISCOVERY_UNAVAILABLE', 'Remote background inventory has no exhaustive read port.'); + const inventory = inventoryFor(budget); + inventory.jobs ||= scanJobs(budget); + const scanned = await inventory.jobs; + const candidates = [...scanned.candidates], jobs = []; + const root = await resolvePath(project.projectPath, budget); + const records = scanned.records; for (const [id, row] of records) { if (!row.cwd || !path.isAbsolute(row.cwd) || !row.sessionId) { candidates.push({ id, reason: 'Background ownership unavailable.' }); continue; } let cwd; - try { cwd = row.cwd === project.projectPath ? root : await bounded(() => io.realpath(row.cwd), budget); } + try { cwd = row.cwd === project.projectPath ? root : await resolvePath(row.cwd, budget); } catch (error) { if (error.code !== 'ENOENT') candidates.push({ id, reason: error.message }); continue; @@ -162,8 +181,6 @@ function createProjectDeleteRuntime(ports) { } async function readWorktreeActivity(project, budget) { if (project.alias !== null) throw fail('DISCOVERY_UNAVAILABLE', 'Remote worktree activity is unavailable.'); - const root = normalize(await bounded(() => io.realpath(project.projectPath), budget)); - const sessions = [], jobs = [], candidates = [], seen = new Set(); const descriptors = await bounded(() => ports.cliSessionState.getSidebarDescriptors({ allWriters: true }), budget); const snapshot = budget.snapshot || await ports.readWorktreeSnapshot?.(budget); if (!Array.isArray(descriptors) || !Array.isArray(snapshot?.sessions) || !(ports.activeSessions instanceof Map)) { @@ -172,35 +189,46 @@ function createProjectDeleteRuntime(ports) { const rows = [...ports.activeSessions].map(([id, row]) => ({ ...row, sessionId: row.realSessionId || row.sessionId || id, active: !row.exited })); rows.push(...descriptors, ...snapshot.sessions); if (rows.length > budget.limit) throw fail('DISCOVERY_LIMIT', 'Too many worktree sessions to inspect.'); - const within = async row => { - if (row.host || row.remoteAlias || row.alias || row.folder && parseFolderKey(row.folder).alias !== null) return false; - const value = row.cwd || row.projectPath; - if (typeof value !== 'string' || !path.isAbsolute(value)) { candidates.push({ id: row.sessionId, reason: 'Session cwd unavailable.' }); return false; } - let cwd; - try { cwd = normalize(await bounded(() => io.realpath(value), budget)); } - catch (error) { - if (error.code !== 'ENOENT') candidates.push({ id: row.sessionId, reason: 'Session cwd unreadable.' }); - return false; + const runs = await bounded(() => ports.cliSessionState.getScheduleRunSnapshot(), budget); + if (!Array.isArray(runs) || runs.length + rows.length > budget.limit) throw fail('DISCOVERY_LIMIT', 'Schedule inventory unavailable or oversized.'); + const evidenceById = new Map(); + async function forPath(projectPath) { + const root = normalize(await resolvePath(projectPath, budget)); + const sessions = [], jobs = [], candidates = [], seen = new Set(); + const within = async row => { + if (row.host || row.remoteAlias || row.alias || row.folder && parseFolderKey(row.folder).alias !== null) return false; + const value = row.cwd || row.projectPath; + if (typeof value !== 'string' || !path.isAbsolute(value)) { candidates.push({ id: row.sessionId, reason: 'Session cwd unavailable.' }); return false; } + let cwd; + try { cwd = normalize(await resolvePath(value, budget)); } + catch (error) { + if (error.code !== 'ENOENT') candidates.push({ id: row.sessionId, reason: 'Session cwd unreadable.' }); + return false; + } + return cwd === root || cwd.startsWith(root + '/'); + }; + for (const row of rows) { + if (!await within(row)) continue; + const id = row.sessionId || row.id; + if (row.active) { sessions.push({ sessionId: id, cwd: row.cwd || row.projectPath }); continue; } + if (!id || row.runtime === 'codex') { candidates.push({ id, reason: 'Worktree runtime liveness unavailable.' }); continue; } + if (seen.has(id)) continue; + seen.add(id); + if (!evidenceById.has(id)) evidenceById.set(id, bounded(() => ports.cliSessionState.readStatusEvidence(id, budget.deadline), budget)); + const evidence = await evidenceById.get(id); + if (!evidence?.known || evidence.ambiguous) candidates.push({ id, reason: 'Worktree session liveness uncertain.' }); + else if (evidence.live) sessions.push({ sessionId: id, cwd: row.cwd || row.projectPath }); } - return cwd === root || cwd.startsWith(root + '/'); - }; - for (const row of rows) { - if (!await within(row)) continue; - const id = row.sessionId || row.id; - if (row.active) { sessions.push({ sessionId: id, cwd: row.cwd || row.projectPath }); continue; } - if (!id || row.runtime === 'codex') { candidates.push({ id, reason: 'Worktree runtime liveness unavailable.' }); continue; } - if (seen.has(id)) continue; - seen.add(id); - const evidence = await bounded(() => ports.cliSessionState.readStatusEvidence(id, budget.deadline), budget); - if (!evidence?.known || evidence.ambiguous) candidates.push({ id, reason: 'Worktree session liveness uncertain.' }); - else if (evidence.live) sessions.push({ sessionId: id, cwd: row.cwd || row.projectPath }); + const roster = await readJobs({ ...project, projectPath, includeDescendants: true }, budget); + jobs.push(...roster.jobs); candidates.push(...roster.candidates); + if (runs.length + rows.length + jobs.length > budget.limit) throw fail('DISCOVERY_LIMIT', 'Schedule inventory unavailable or oversized.'); + for (const run of runs) if (await within(run)) jobs.push(run); + return { complete: true, sessions, jobs, candidates }; } - const roster = await readJobs({ ...project, includeDescendants: true }, budget); - jobs.push(...roster.jobs); candidates.push(...roster.candidates); - const runs = await bounded(() => ports.cliSessionState.getScheduleRunSnapshot(), budget); - if (!Array.isArray(runs) || runs.length + rows.length + jobs.length > budget.limit) throw fail('DISCOVERY_LIMIT', 'Schedule inventory unavailable or oversized.'); - for (const run of runs) if (await within(run)) jobs.push(run); - return { complete: true, sessions, jobs, candidates }; + if (!project.worktreePaths) return forPath(project.projectPath); + const byPath = Object.create(null); + for (const directory of project.worktreePaths) byPath[directory] = await forPath(directory); + return { byPath }; } return { readJobs, readLiveness, readTarget, readConversation, readWorktreeActivity, withScope, captureRuntimeRelease, getScheduleRunSnapshot: () => ports.cliSessionState.getScheduleRunSnapshot(), diff --git a/src/main/projects/project-delete-plan.js b/src/main/projects/project-delete-plan.js index 319153148..5be2b987c 100644 --- a/src/main/projects/project-delete-plan.js +++ b/src/main/projects/project-delete-plan.js @@ -117,7 +117,10 @@ function createProjectDeletePlanner(deps) { let worktrees = []; try { if (project.alias !== null && selectedWorktrees.length) throw fail('WORKTREE_UNAVAILABLE', 'Remote worktree removal is unavailable.'); - if (deps.worktrees && project.alias === null) worktrees = items(await deps.worktrees.preview(project, { ...budget, snapshot })); + if (deps.worktrees && project.alias === null && (boundKey === undefined || selectedWorktrees.length)) { + worktrees = items(await deps.worktrees.preview(project, { ...budget, snapshot, + ...(boundKey === undefined ? {} : { worktreePaths: selectedWorktrees }) })); + } worktrees = worktrees.map(row => ({ ...row, selected: selectedWorktrees.includes(row.path) })); for (const target of selectedWorktrees) { const row = worktrees.find(row => row.path === target); @@ -262,7 +265,9 @@ function createProjectDeletePlanner(deps) { } await ordered(refusals); const membershipDigest = digest({ project: { alias: project.alias, projectPath: project.projectPath }, ...membership }); - const fingerprint = digest({ membershipDigest, groups, members, tabs, jobs, schedules, worktrees, options: request.options, stops, categories, warnings, refusals }); + const fingerprint = digest({ membershipDigest, groups, members, tabs, jobs, schedules, + worktrees: worktrees.filter(row => row.selected && !row.main && !row.projectDirectory), + options: request.options, stops, categories, warnings: warnings.filter(row => row.code !== 'WORKTREE_UNAVAILABLE'), refusals }); const revision = await deps.readRevision(budget); expired(); if (revision !== snapshot.revision) throw fail('SNAPSHOT_STALE', 'Writer changed during discovery; request a fresh preview.'); diff --git a/src/main/projects/project-delete-worktrees.js b/src/main/projects/project-delete-worktrees.js index c5af42ec7..fd8ecc40f 100644 --- a/src/main/projects/project-delete-worktrees.js +++ b/src/main/projects/project-delete-worktrees.js @@ -11,76 +11,78 @@ function createProjectDeleteWorktrees({ runGit, readActivity, now = Date.now }) async function preview(project, budget) { if (project.alias !== null) throw fail('WORKTREE_UNAVAILABLE', 'Remote worktree removal is unavailable.'); check(budget); - const list = await runGit(['-C', project.projectPath, 'worktree', 'list', '--porcelain', '-z']); + if (budget.worktreePaths?.length === 0) return []; + const list = await runGit(['-C', project.projectPath, 'worktree', 'list', '--porcelain']); check(budget); - const records = list.split('\0\0').filter(Boolean).map(value => value.split('\0')); - if (records.length > Math.min(128, budget.limit) || records.some(fields => !fields[0].startsWith('worktree '))) { + const records = deletion.parseWorktreeList(list); + if (records.length > Math.min(128, budget.limit)) { throw fail('DISCOVERY_LIMIT', 'Worktree registration is invalid or exceeds 128 entries. Review it with Git.'); } - const rows = []; - for (const [index, fields] of records.entries()) { + const rows = [], memo = new Map(), inventory = { records }; + const owner = canonicalPath(project.projectPath, null, memo); + for (const [index, { path: directory, fields }] of records.entries()) { check(budget); - const directory = fields[0].slice(9); + if (budget.worktreePaths && !budget.worktreePaths.includes(directory)) continue; if (!path.isAbsolute(directory)) throw fail('WORKTREE_UNAVAILABLE', 'Git returned a relative worktree path.'); - const candidate = canonicalPath(directory, null), owner = canonicalPath(project.projectPath, null); + const candidate = canonicalPath(directory, null, memo); const row = { path: directory, branch: fields.find(field => field.startsWith('branch '))?.slice(7).replace(/^refs\/heads\//, '') || '(detached HEAD)', main: index === 0, projectDirectory: candidate === owner || owner.startsWith(candidate + '/'), removable: false, sessions: [], dirty: [], selected: false, statusKnown: false, sessionsKnown: false }; if (row.main || row.projectDirectory) { row.reason = 'The main checkout and the selected project directory are always kept.'; - try { - const status = await runGit(['-C', directory, 'status', '--porcelain=v1', '-z', '--untracked-files=all']); - row.dirty = status.split('\0').filter(Boolean); row.statusKnown = true; - const activity = await readActivity({ alias: null, projectPath: directory }, budget); - row.sessions = activity.sessions || []; row.jobs = activity.jobs || []; - row.sessionsKnown = activity.complete === true && !activity.candidates?.length; - } catch (error) { row.reason += ' Preview unavailable: ' + error.message; } - } - else { - try { - const status = await deletion.readStatus(directory, project.projectPath, runGit); - check(budget); - const activity = await readActivity({ alias: null, projectPath: directory }, budget); - check(budget); - Object.assign(row, status, { statusKnown: true, sessions: activity.sessions || [], jobs: activity.jobs || [], - sessionsKnown: activity.complete === true && !activity.candidates?.length }); - if (activity.complete !== true || !Array.isArray(activity.sessions) || !Array.isArray(activity.jobs) - || !Array.isArray(activity.candidates) || activity.candidates.length) row.reason = 'Worktree activity is uncertain. Check its sessions and Agents, then reopen Delete.'; - else if (activity.jobs.length) row.reason = 'Background jobs prevent worktree removal (#1090). Check the Agents view.'; - else if (activity.sessions.length) row.reason = 'Stop the sessions in this worktree first, then reopen Delete.'; - else if (status.locked || status.submodules?.length) row.reason = 'Locked worktrees and submodules require the dedicated Delete worktree dialog.'; - else row.removable = true; - } catch (error) { row.reason = error.message; } } rows.push(row); } + const eligible = rows.filter(row => !row.main && !row.projectDirectory); + let activities, activityError; + if (eligible.length) { + try { activities = await readActivity({ ...project, worktreePaths: eligible.map(row => row.path) }, budget); } + catch (error) { activityError = error; } + } + for (const row of eligible) { + try { + if (activityError) throw activityError; + const status = await deletion.readStatus(row.path, project.projectPath, runGit, undefined, inventory); + check(budget); + const activity = activities.byPath ? activities.byPath[row.path] : activities; + check(budget); + Object.assign(row, status, { statusKnown: true, sessions: activity.sessions || [], jobs: activity.jobs || [], + sessionsKnown: activity.complete === true && !activity.candidates?.length }); + if (activity.complete !== true || !Array.isArray(activity.sessions) || !Array.isArray(activity.jobs) + || !Array.isArray(activity.candidates) || activity.candidates.length) row.reason = 'Worktree activity is uncertain. Check its sessions and Agents, then reopen Delete.'; + else if (activity.jobs.length) row.reason = 'Background jobs prevent worktree removal (#1090). Check the Agents view.'; + else if (activity.sessions.length) row.reason = 'Stop the sessions in this worktree first, then reopen Delete.'; + else if (status.locked || status.submodules?.length) row.reason = 'Locked worktrees and submodules require the dedicated Delete worktree dialog.'; + else row.removable = true; + } catch (error) { row.reason = error.message; } + } return rows; } async function remove(project, selected, record) { const budget = { signal: new AbortController().signal, deadline: now() + 15000, limit: 20000 }; try { - const current = await preview(project, budget); + const current = await preview(project, { ...budget, worktreePaths: selected.map(row => row.path) }); for (const row of selected) { const fresh = current.find(item => item.path === row.path); if (!fresh?.removable || fresh.main || fresh.projectDirectory || fresh.fingerprint !== row.fingerprint) { - record({ path: row.path, state: 'failed', error: fresh?.reason || 'Worktree changed. Review a fresh preview before confirming again.' }); + record({ path: row.path, state: 'refused', error: fresh?.reason || 'Worktree changed. Review a fresh preview before confirming again.' }); return false; } } } catch (error) { - record({ path: selected[0]?.path, state: 'failed', error: error.message }); return false; + record({ state: 'refused', error: error.message }); return false; } for (const row of selected) { - let result; + let result, attempted = false; try { result = await deletion.removeWorktree(row.path, project.projectPath, row, async () => { - const current = await preview(project, { ...budget, deadline: now() + 15000 }); + const current = await preview(project, { ...budget, signal: new AbortController().signal, deadline: now() + 15000, worktreePaths: [row.path] }); const fresh = current.find(item => item.path === row.path); if (!fresh?.removable || fresh.main || fresh.projectDirectory) throw fail('WORKTREE_UNAVAILABLE', fresh?.reason || 'Worktree registration changed.'); return fresh; - }, runGit); + }, async args => { attempted = true; return runGit(args); }); } catch (error) { result = { ok: false, error: error.message }; } - record({ path: row.path, state: result.ok ? 'removed' : 'failed', error: result.error }); + record({ path: row.path, state: result.ok ? 'removed' : attempted ? 'failed' : 'refused', error: result.error }); if (!result.ok) return false; } return true; diff --git a/src/main/projects/project-delete.js b/src/main/projects/project-delete.js index 56d4314cd..9f32ddc11 100644 --- a/src/main/projects/project-delete.js +++ b/src/main/projects/project-delete.js @@ -135,7 +135,7 @@ function createProjectDeleteService(deps) { async function acceptState(op, state) { const committed = state.state === 'committed' && state.receiptAvailable === true && state.terminal === true && state.invalidation; const known = state.receiptAvailable === true && state.terminal === true && ['partial', 'notStarted'].includes(state.state); - const partial = known && (state.state === 'partial' || op.worktreeResults?.some(row => row.state !== 'remaining')); + const partial = known && (state.state === 'partial' || op.worktreeResults?.some(row => ['removed', 'failed'].includes(row.state))); op.result = { ...failure('UNKNOWN'), operationId: op.id, state: committed ? 'committed' : partial ? 'partial' : known ? state.state : 'unknown', ok: !!committed, partial: !!partial, retryable: false, completed: state.completed || [], kept: state.kept || [], failed: state.failed || [], skipped: state.remaining || [], @@ -231,7 +231,7 @@ function createProjectDeleteService(deps) { try { return await acceptState(op, await bounded(() => writer.completeProjectDeletion(manifest), 60000)); } catch { return await reconcile(op); } } catch (error) { - const partial = op.worktreeResults?.some(row => row.state !== 'remaining'); + const partial = op.worktreeResults?.some(row => ['removed', 'failed'].includes(row.state)); op.result = { ...failure(error.code || 'DELETE_UNAVAILABLE'), error: error.message, state: partial ? 'partial' : 'notStarted', partial: !!partial, refresh: true }; return view(op); } finally { diff --git a/test/dom-project-delete.test.js b/test/dom-project-delete.test.js index f00639629..fc888e903 100644 --- a/test/dom-project-delete.test.js +++ b/test/dom-project-delete.test.js @@ -9,6 +9,30 @@ const fs = require('node:fs'); const path = require('node:path'); const vm = require('node:vm'); +test('E unavailable worktree inventory has a visible reason outside JSON details', async t => { + const h = setup(t, { warnings: [{ code: 'WORKTREE_UNAVAILABLE', error: 'Git inventory unavailable' }] }); + const pending = h.start(); await flush(); + const dialog = h.document.querySelector('.choice-dialog').cloneNode(true); + dialog.querySelectorAll('details').forEach(node => node.remove()); + assert.match(dialog.textContent, /Git inventory unavailable/); + h.cancel(); await pending; +}); + +test('E kept labels omit removal warnings and removable labels bound dirty entries and count ignored files', async t => { + const h = setup(t, { worktrees: [ + { path: 'C:/repo', main: true, removable: false, dirty: [], sessions: [] }, + { path: 'C:/linked', removable: true, dirty: Array.from({ length: 8 }, (_, i) => '?? file-' + i), ignoredCount: 3, sessions: [] }, + ] }); + const pending = h.start(); await flush(); + const kept = h.document.querySelector('[data-choice-id="worktree:0"]').closest('label').textContent; + const linked = h.document.querySelector('[data-choice-id="worktree:1"]').closest('label').textContent; + assert.doesNotMatch(kept, /Ignored files are removed/); + assert.match(linked, /3 ignored/); + assert.match(linked, /and 3 more/); + assert.doesNotMatch(linked, /file-5/); + h.cancel(); await pending; +}); + test('E worktree choices are individually previewed, never remembered, and main remains disabled', async t => { const rows = [ { path: 'C:/repo', branch: 'main', main: true, removable: false, reason: 'Main checkout is kept', sessions: [], dirty: [] }, diff --git a/test/project-delete-worktrees-real-git.test.js b/test/project-delete-worktrees-real-git.test.js index a5f2c0079..fe2dabfb5 100644 --- a/test/project-delete-worktrees-real-git.test.js +++ b/test/project-delete-worktrees-real-git.test.js @@ -34,7 +34,8 @@ function gitFixture(t) { test('E real Git discovery lists main, branch, dirty/untracked bytes; removes exactly the reviewed linked directory', async t => { const f = gitFixture(t); fs.writeFileSync(path.join(f.target, 'untracked'), 'discard'); - const rows = await f.adapter.preview(f.project, f.budget()); + let rows; + await assert.doesNotReject(async () => { rows = await f.adapter.preview(f.project, f.budget()); }, 'installed Git must support worktree inventory'); assert.equal(rows.find(row => row.main).removable, false); const selected = rows.find(row => path.resolve(row.path) === f.target); assert.equal(selected.branch, 'topic'); assert.equal(selected.removable, true); diff --git a/test/project-delete-worktrees.test.js b/test/project-delete-worktrees.test.js index 7f75b5a7c..4bc5cd668 100644 --- a/test/project-delete-worktrees.test.js +++ b/test/project-delete-worktrees.test.js @@ -204,7 +204,7 @@ test('E shared removal with a controlled Git port discovery lists main, branch, fs.writeFileSync(path.join(f.target, 'untracked'), 'discard'); const rows = await f.adapter.preview(f.project, f.budget()); assert.equal(rows.find(row => row.main).removable, false); - assert.equal(rows.find(row => row.main).statusKnown, true, 'main checkout status must be previewed even though it is never removable'); + assert.equal(rows.find(row => row.main).statusKnown, false, 'kept checkout must not be scanned'); const selected = rows.find(row => path.resolve(row.path) === f.target); assert.equal(selected.branch, 'topic'); assert.equal(selected.removable, true); assert.ok(selected.dirty.some(line => line.includes('untracked'))); @@ -241,3 +241,89 @@ test('E shared removal with a controlled Git port changed contents and new live const blocked = (await f.adapter.preview(f.project, f.budget())).find(row => path.resolve(row.path) === f.target); assert.equal(blocked.removable, false); assert.equal(blocked.sessions[0].sessionId, 'live'); }); + +test('E inventory supports Git 2.24 newline porcelain and scans only removable rows', async t => { + const f = gitFixture(t); + await f.adapter.preview(f.project, f.budget()); + assert.equal(f.commands.some(args => args.includes('list') && args.includes('-z')), false, 'Git 2.24 rejects list -z'); + assert.equal(f.commands.filter(args => args.includes('list')).length, 1, 'registration is read once per inventory'); + assert.equal(f.commands.some(args => args.includes('status') && path.resolve(args[1]) === f.root), false, 'main checkout must not be scanned'); +}); + +test('E no selection ignores dirty changes while selected bytes invalidate consent', async t => { + const f = await serviceFixture(t); + const preview = await f.service.preview(f.sender, f.request([])); + f.state.rows[0].dirty.push('?? new.txt'); f.state.rows[0].fingerprint = 'new'; + const result = await f.service.execute(f.sender, { token: preview.token, fingerprint: preview.plan.fingerprint }); + assert.equal(result.state, 'committed', 'unselected dirty bytes must not invalidate project consent'); + const g = await serviceFixture(t); + const selected = await g.service.preview(g.sender, g.request([g.a])); + g.state.rows[0].fingerprint = 'new'; + const changed = await g.service.execute(g.sender, { token: selected.token, fingerprint: selected.plan.fingerprint }); + assert.equal(changed.code, 'PREVIEW_CHANGED'); + assert.equal(g.state.removed.length, 0); +}); + +test('E precheck refusal has no partial disk effect or invented failed path', async t => { + const f = gitFixture(t), results = []; + const rows = await f.adapter.preview(f.project, f.budget()); + const selected = rows.find(row => path.resolve(row.path) === f.target); + fs.writeFileSync(path.join(f.target, 'untracked'), 'late'); + await f.adapter.remove(f.project, [selected], row => results.push(row)); + assert.equal(results[0].state, 'refused', 'no Git remove was attempted'); +}); + +test('E whole-inventory failure refuses without blaming the first selected path', async t => { + const f = gitFixture(t); + const selected = (await f.adapter.preview(f.project, f.budget())).find(row => path.resolve(row.path) === f.target); + const adapter = implementation.createProjectDeleteWorktrees({ runGit: async () => { throw new Error('inventory offline'); }, readActivity: async () => ({ complete: true }) }); + const failures = []; + await adapter.remove(f.project, [selected], row => failures.push(row)); + assert.equal(failures[0].state, 'refused'); + assert.equal(failures[0].path, undefined, 'whole inventory failure has no individual path'); +}); + +test('E service reports precheck refusal without partially completed deletion', async t => { + const f = await serviceFixture(t); + f.worktrees.remove = async (_project, _selected, record) => { record({ state: 'refused', error: 'inventory offline' }); return false; }; + const preview = await f.service.preview(f.sender, f.request([f.a])); + const result = await f.service.execute(f.sender, { token: preview.token, fingerprint: preview.plan.fingerprint }); + assert.equal(result.partial, false, 'refusal is not a disk effect'); + assert.equal(result.state, 'notStarted'); + assert.equal(f.state.events.includes('metadata'), false); +}); + +test('E confirm only inspects selected worktrees and retains the last removal guard', async t => { + const f = gitFixture(t); + const selected = (await f.adapter.preview(f.project, f.budget())).find(row => path.resolve(row.path) === f.target); + f.commands.length = 0; + assert.equal(await f.adapter.remove(f.project, [selected], () => {}), true); + assert.equal(f.commands.some(args => args.includes('status') && path.resolve(args[1]) !== f.target), false, 'confirm must not inspect unselected folders'); + assert.equal(f.commands.filter(args => args.includes('status') && !args.includes('--ignored')).length, 2, 'preflight and immediately before removal'); +}); + +test('E preview shares one Claude roster and path resolution across sibling worktree rows', async t => { + const f = gitFixture(t), { createProjectDeleteRuntime } = require('../src/main/projects/project-delete-main'); + let spawns = 0, descriptors = 0; + const resolutions = new Map(); + const runtime = createProjectDeleteRuntime({ fs: { ...fs.promises, realpath: async value => { + resolutions.set(value, (resolutions.get(value) || 0) + 1); return fs.promises.realpath(value); + } }, activeSessions: new Map(), jobsDir: path.join(f.root, 'jobs'), homeDir: f.root, + runClaude: async () => { spawns++; return { code: 0, stdout: '[]' }; }, cliSessionState: { + getSidebarDescriptors: () => { descriptors++; return [{ sessionId: 'one', cwd: f.target }, { sessionId: 'two', cwd: f.target }]; }, + readStatusEvidence: async () => ({ known: true, live: null }), getScheduleRunSnapshot: () => [], + } }); + const adapter = implementation.createProjectDeleteWorktrees({ runGit: async args => { + f.commands.push(args); + if (args.includes('list')) return [f.root, f.target, f.kept].map(p => `worktree ${p.replaceAll('\\', '/')}\nHEAD abc\n\n`).join('').replaceAll('\n', args.includes('-z') ? '\0' : '\n'); + if (args.includes('rev-parse')) return path.join(f.root, 'absent-lock'); + return ''; + }, readActivity: runtime.readWorktreeActivity }); + const budget = { ...f.budget(), snapshot: { sessions: [] } }; + await runtime.readJobs(f.project, budget); + const rows = await adapter.preview(f.project, budget); + assert.equal(rows.length, 3); + assert.equal(spawns, 1, 'one claude agents spawn per preview, including parent inventory'); + assert.equal(descriptors, 1, 'session inventory is read once'); + assert.equal(Math.max(...resolutions.values()), 1, 'paths resolve once per inventory'); +}); diff --git a/test/worktree-delete.test.js b/test/worktree-delete.test.js index 93e7f9844..3558381e6 100644 --- a/test/worktree-delete.test.js +++ b/test/worktree-delete.test.js @@ -9,6 +9,21 @@ const deletion = require('../worktree-delete'); const target = '/home/jb/repo/.claude/worktrees/task'; +test('Git removal timeout follows the subcommand after leading options, never a path called remove', async () => { + const fs = require('node:fs'), vm = require('node:vm'); + const filename = path.join(__dirname, '../main.js'); + const source = fs.readFileSync(filename, 'utf8'); + const timeouts = []; + const context = vm.createContext({ localGitEnv: () => ({}), execFile: (_exe, _args, options, cb) => { + timeouts.push(options.timeout); cb(null, '', ''); + } }); + vm.runInContext(require('./app-source').extractFunction(source, 'worktreeGit'), context, { filename }); + await context.worktreeGit(['-C', 'remove', 'status']); + await context.worktreeGit(['-c', 'x=y', '-C', '/repo', 'worktree', 'remove', '--', '/linked']); + await context.worktreeGit(['-C', '/repo', 'worktree', 'list', 'remove']); + assert.deepEqual(timeouts, [15000, 120000, 15000]); +}); + function fixture() { const state = { dirty: '', lock: null, removes: [], cleaned: 0, failRemove: false }; const handlers = loadProjectActionHandlers({ diff --git a/worktree-delete.js b/worktree-delete.js index 3baade8d2..6c1c0c09a 100644 --- a/worktree-delete.js +++ b/worktree-delete.js @@ -141,10 +141,11 @@ async function canonicalPath(value) { return comparablePath(await fs.promises.realpath(value).catch(() => value)); } -async function registeredPath(value) { +async function registeredPath(value, memo = new Map()) { const absolute = path.resolve(value); const parent = path.dirname(absolute); - return comparablePath(path.join(await fs.promises.realpath(parent).catch(() => parent), path.basename(absolute))); + if (!memo.has(parent)) memo.set(parent, fs.promises.realpath(parent).catch(() => parent)); + return comparablePath(path.join(await memo.get(parent), path.basename(absolute))); } async function runningSessions(worktreePath, activeSessions, descriptors) { @@ -182,6 +183,14 @@ function unquote(value) { return Buffer.from(bytes).toString('utf8'); } +function parseWorktreeList(list) { + return list.split(/\r?\n\r?\n/).filter(record => record.trim()).map(record => { + const fields = record.split(/\r?\n/); + if (!fields[0].startsWith('worktree ')) throw new Error('Git returned invalid worktree registration.'); + return { path: unquote(fields[0].slice(9)), fields }; + }); +} + async function fileFingerprint(root, name, submodules, runGit, depth, budget) { const absolute = path.resolve(root, name); const relative = path.relative(path.resolve(root), absolute); @@ -191,8 +200,13 @@ async function fileFingerprint(root, name, submodules, runGit, depth, budget) { let stat; try { stat = await fs.promises.lstat(absolute); } catch (error) { if (error.code === 'ENOENT') return ['missing']; throw error; } - const realRoot = resolveOnDisk(root); - const candidate = resolveOnDisk(stat.isSymbolicLink() ? path.dirname(absolute) : absolute); + const resolve = value => { + budget.resolutions ||= new Map(); + if (!budget.resolutions.has(value)) budget.resolutions.set(value, resolveOnDisk(value)); + return budget.resolutions.get(value); + }; + const realRoot = resolve(root); + const candidate = resolve(stat.isSymbolicLink() ? path.dirname(absolute) : absolute); if (!realRoot || !candidate || (candidate !== realRoot && !within(realRoot, candidate))) { throw new Error('A file resolves outside the worktree. Review its directory links before deleting.'); } @@ -265,7 +279,7 @@ async function statusSnapshot(worktreePath, runGit, depth = 0, budget = { used: return { dirty, ignored, submodules, index, records: recordsForFingerprint.sort() }; } -async function readStatus(worktreePath, parentRepo, runGit, readFile = fs.promises.readFile) { +async function readStatus(worktreePath, parentRepo, runGit, readFile = fs.promises.readFile, inventory = {}) { const rawGit = runGit; runGit = async (...args) => { try { return await rawGit(...args); } @@ -277,12 +291,11 @@ async function readStatus(worktreePath, parentRepo, runGit, readFile = fs.promis throw error; } }; - const list = await runGit(['-C', parentRepo, 'worktree', 'list', '--porcelain']); - const records = list.split(/\r?\n\r?\n/).map(record => record.split(/\r?\n/)); - const registered = records.filter(record => record[0]?.startsWith('worktree ')); - const requestedPath = await registeredPath(worktreePath); - const registeredPaths = await Promise.all(registered.map(record => registeredPath(unquote(record[0].slice(9))))); - const fields = registered[registeredPaths.indexOf(requestedPath)]; + const registered = inventory.records || parseWorktreeList(await runGit(['-C', parentRepo, 'worktree', 'list', '--porcelain'])); + const memo = inventory.resolutions ||= new Map(); + const requestedPath = await registeredPath(worktreePath, memo); + const registeredPaths = inventory.registeredPaths ||= await Promise.all(registered.map(record => registeredPath(record.path, memo))); + const fields = registered[registeredPaths.indexOf(requestedPath)]?.fields; if (!fields) throw new Error('This path is no longer a registered worktree. Refresh the project list before trying Delete again.'); if (requestedPath === registeredPaths[0]) throw new Error('The main worktree cannot be deleted. Select a linked worktree instead.'); const branch = fields.find(line => line.startsWith('branch '))?.slice(7).replace(/^refs\/heads\//, '') || '(detached HEAD)'; @@ -339,4 +352,4 @@ async function removeWorktree(worktreePath, parentRepo, shown, read, runGit) { } } -module.exports = { readStatus, removeWorktree, runningSessions, streamGit }; +module.exports = { readStatus, removeWorktree, runningSessions, streamGit, parseWorktreeList }; From 15ea89001bc1834b72d64f077a38f794185a7042 Mon Sep 17 00:00:00 2001 From: Jean-Baptiste Date: Fri, 13 Nov 2026 04:26:14 +0100 Subject: [PATCH 4/8] (projects): never let the worktree inventory block a plain deletion (#474) The inventory takes a bounded share of the preview budget and marks late rows not inspected; a record that cannot be tied to a folder is shown once instead of marking every worktree uncertain. --- .ai/contexts/project-delete.md | 29 +++++-- src/main/projects/project-delete-main.js | 64 +++++++++++--- src/main/projects/project-delete-plan.js | 8 +- src/main/projects/project-delete-worktrees.js | 32 +++++-- test/project-delete-worktrees.test.js | 87 +++++++++++++++++++ worktree-delete.js | 27 ++++-- 6 files changed, 215 insertions(+), 32 deletions(-) diff --git a/.ai/contexts/project-delete.md b/.ai/contexts/project-delete.md index 72fc5bc62..0cd5cbdd2 100644 --- a/.ai/contexts/project-delete.md +++ b/.ai/contexts/project-delete.md @@ -5,17 +5,35 @@ Preview accepts optional `worktrees: string[]` alongside the unchanged five boolean writer options. These are exact paths from the main-owned Git inventory, not arbitrary filesystem targets. Missing means empty; duplicates and more than -128 selections refuse. Every registered checkout has a row: path, branch, -main/project-directory identity, dirty/untracked status, sessions, jobs and an -availability reason. Status/activity failures are explicit, never rendered as +128 selections refuse. Every registered checkout has a row with its path, branch, +main/project-directory identity and availability reason. Eligible linked rows +also report inspected dirty/untracked status, sessions and jobs; always-kept +main/project-directory rows read none of those details. Status/activity failures are explicit, never rendered as clean/idle. The main checkout, the selected project directory and its ancestors are never removable. Remote selection refuses because no authoritative remote filesystem/removal port exists. Local discovery uses newline-delimited Git `worktree list --porcelain`, with the shared parser decoding Git-quoted paths, compatible with Git 2.24. Inventory failures have a visible dialog reason. -Kept rows do not read status, scan activity or hash content. Removable labels +Always-kept main/project-directory rows do not read status, scan activity or hash content. Removable labels show the ignored-entry count and at most five dirty entries plus the remainder. +Preview worktree discovery receives at most two seconds and half the remaining +planner budget. Git listing, activity and each status read are deadline-bounded; +status traversal and hashing also check the deadline/signal. Exhausted rows say +"not inspected" and cannot be removed. The metadata plan still completes: an +unchecked row adds no refusal; selecting an uninspected row refuses that physical +selection until it is unchecked or a fresh inspection succeeds. + +Missing session cwd is a folder candidate only when an absolute project path or +the snapshot's local folder-key mapping ties the record to that subtree. Without +such a tie its reason is reported once at dialog level. Global background-job +candidates are likewise reported once, never copied into every row. A selected +folder is blocked when a global job has no resolvable absolute cwd, or its cwd +is that folder or a descendant. A resolvable cwd outside the selected subtree +does not block it. This conservative rule also applies during removal preflight +and the final per-folder guard. The parent metadata runtime retains its own +existing background ownership checks. + `project-delete-worktrees.js` calls the existing `worktree-delete` readStatus and removeWorktree functions. Clean removal uses no force; dirty content is hashed and rechecked. Locked/submodule rows are disabled here and direct users to the @@ -74,8 +92,7 @@ never repeats disk removal or treats a metadata receipt as proof of disk success Plain-Node tests cover the production planner, service, activity reader, subtree gate and shared removal with controlled Git replies and real disposable files. The composition witness includes the real writer/SQLite fixture. Separate real -Git worktree tests exercise the installed Git version. The former `list -z` -command required Git 2.36 and failed on Git 2.24 before inventory could complete. +Git worktree tests exercise the installed Git version. Native UI, full process restart, live process death and filesystem races after the shared last scan remain unverified locally. diff --git a/src/main/projects/project-delete-main.js b/src/main/projects/project-delete-main.js index b3eb40047..f7b354917 100644 --- a/src/main/projects/project-delete-main.js +++ b/src/main/projects/project-delete-main.js @@ -95,7 +95,7 @@ function createProjectDeleteRuntime(ports) { if (!Array.isArray(raw) || !listed || listed.length !== raw.length || listed.length + count > Math.min(budget.limit, 20000)) throw fail('DISCOVERY_LIMIT', 'Background list invalid or oversized.'); for (const row of listed.filter(row => row.kind === 'background')) { - if (!row.id || !records.has(row.id)) candidates.push({ id: row.id || row.sessionId, reason: 'Background list has no durable job record.' }); + if (!row.id || !records.has(row.id)) candidates.push({ id: row.id || row.sessionId, cwd: row.cwd, reason: 'Background list has no durable job record.' }); else records.set(row.id, { ...records.get(row.id), cwd: row.cwd || records.get(row.id).cwd }); } return { candidates, records }; @@ -105,15 +105,15 @@ function createProjectDeleteRuntime(ports) { const inventory = inventoryFor(budget); inventory.jobs ||= scanJobs(budget); const scanned = await inventory.jobs; - const candidates = [...scanned.candidates], jobs = []; + const globalCandidates = [...scanned.candidates], candidates = [], jobs = []; const root = await resolvePath(project.projectPath, budget); const records = scanned.records; for (const [id, row] of records) { - if (!row.cwd || !path.isAbsolute(row.cwd) || !row.sessionId) { candidates.push({ id, reason: 'Background ownership unavailable.' }); continue; } + if (!row.cwd || !path.isAbsolute(row.cwd) || !row.sessionId) { globalCandidates.push({ id, cwd: row.cwd, reason: 'Background ownership unavailable.' }); continue; } let cwd; try { cwd = row.cwd === project.projectPath ? root : await resolvePath(row.cwd, budget); } catch (error) { - if (error.code !== 'ENOENT') candidates.push({ id, reason: error.message }); + if (error.code !== 'ENOENT') globalCandidates.push({ id, cwd: row.cwd, reason: error.message }); continue; } if (normalize(cwd) !== normalize(root) && !(project.includeDescendants && normalize(cwd).startsWith(normalize(root) + '/'))) continue; @@ -121,7 +121,7 @@ function createProjectDeleteRuntime(ports) { conversationId: row.sessionId, sessionIds: [row.sessionId], liveness: { state: 'unknown', source: 'job' } }); candidates.push({ id, reason: 'Background deletion awaits worker-incarnation control (#1090).' }); } - return { complete: true, jobs, candidates }; + return { complete: true, jobs, candidates: project.worktreeInventory ? candidates : [...globalCandidates, ...candidates], globalCandidates }; } const sessionsFor = id => [...ports.activeSessions].filter(([key, session]) => [key, session.sessionId, session.realSessionId].includes(id)); @@ -191,14 +191,39 @@ function createProjectDeleteRuntime(ports) { if (rows.length > budget.limit) throw fail('DISCOVERY_LIMIT', 'Too many worktree sessions to inspect.'); const runs = await bounded(() => ports.cliSessionState.getScheduleRunSnapshot(), budget); if (!Array.isArray(runs) || runs.length + rows.length > budget.limit) throw fail('DISCOVERY_LIMIT', 'Schedule inventory unavailable or oversized.'); - const evidenceById = new Map(); + const evidenceById = new Map(), dialogCandidates = new Map(); + const report = candidate => dialogCandidates.set(JSON.stringify([candidate.id, candidate.reason]), candidate); + const local = row => !(row.host || row.remoteAlias || row.alias || parseFolderKey(row.folder || row.folderKey).alias !== null); + const associatedPaths = row => { + const paths = []; + if (typeof row.projectPath === 'string' && path.isAbsolute(row.projectPath)) paths.push(row.projectPath); + const folder = row.folder || row.folderKey; + if (folder) for (const project of snapshot.projects || []) { + if (project.alias === null && project.folderKeys?.includes(folder)) paths.push(project.projectPath); + } + return paths; + }; + for (const row of [...rows, ...runs]) { + const value = row.cwd; + if (local(row) && (typeof value !== 'string' || !path.isAbsolute(value)) && !associatedPaths(row).length) { + report({ id: row.sessionId || row.id, reason: 'Session cwd unavailable.' }); + } + } async function forPath(projectPath) { const root = normalize(await resolvePath(projectPath, budget)); const sessions = [], jobs = [], candidates = [], seen = new Set(); const within = async row => { - if (row.host || row.remoteAlias || row.alias || row.folder && parseFolderKey(row.folder).alias !== null) return false; - const value = row.cwd || row.projectPath; - if (typeof value !== 'string' || !path.isAbsolute(value)) { candidates.push({ id: row.sessionId, reason: 'Session cwd unavailable.' }); return false; } + if (!local(row)) return false; + const value = row.cwd; + if (typeof value !== 'string' || !path.isAbsolute(value)) { + for (const value of associatedPaths(row)) { + const owner = normalize(await resolvePath(value, budget)); + if (owner === root || owner.startsWith(root + '/')) { + candidates.push({ id: row.sessionId || row.id, reason: 'Session cwd unavailable.' }); break; + } + } + return false; + } let cwd; try { cwd = normalize(await resolvePath(value, budget)); } catch (error) { @@ -219,16 +244,29 @@ function createProjectDeleteRuntime(ports) { if (!evidence?.known || evidence.ambiguous) candidates.push({ id, reason: 'Worktree session liveness uncertain.' }); else if (evidence.live) sessions.push({ sessionId: id, cwd: row.cwd || row.projectPath }); } - const roster = await readJobs({ ...project, projectPath, includeDescendants: true }, budget); + const roster = await readJobs({ ...project, projectPath, includeDescendants: true, worktreeInventory: true }, budget); jobs.push(...roster.jobs); candidates.push(...roster.candidates); + let ownershipUncertain = false; + for (const candidate of roster.globalCandidates) { + report(candidate); + if (!(budget.selectedWorktrees || budget.worktreePaths || []).some(value => normalize(value) === normalize(projectPath))) continue; + let owner; + if (typeof candidate.cwd === 'string' && path.isAbsolute(candidate.cwd)) { + try { owner = normalize(await resolvePath(candidate.cwd, budget)); } catch {} + } + if (!owner || owner === root || owner.startsWith(root + '/')) ownershipUncertain = true; + } if (runs.length + rows.length + jobs.length > budget.limit) throw fail('DISCOVERY_LIMIT', 'Schedule inventory unavailable or oversized.'); for (const run of runs) if (await within(run)) jobs.push(run); - return { complete: true, sessions, jobs, candidates }; + return { complete: true, sessions, jobs, candidates, ownershipUncertain }; + } + if (!project.worktreePaths) { + const result = await forPath(project.projectPath); + return { ...result, candidates: [...result.candidates, ...dialogCandidates.values()] }; } - if (!project.worktreePaths) return forPath(project.projectPath); const byPath = Object.create(null); for (const directory of project.worktreePaths) byPath[directory] = await forPath(directory); - return { byPath }; + return { byPath, candidates: [...dialogCandidates.values()] }; } return { readJobs, readLiveness, readTarget, readConversation, readWorktreeActivity, withScope, captureRuntimeRelease, getScheduleRunSnapshot: () => ports.cliSessionState.getScheduleRunSnapshot(), diff --git a/src/main/projects/project-delete-plan.js b/src/main/projects/project-delete-plan.js index 5be2b987c..317771d26 100644 --- a/src/main/projects/project-delete-plan.js +++ b/src/main/projects/project-delete-plan.js @@ -118,7 +118,13 @@ function createProjectDeletePlanner(deps) { try { if (project.alias !== null && selectedWorktrees.length) throw fail('WORKTREE_UNAVAILABLE', 'Remote worktree removal is unavailable.'); if (deps.worktrees && project.alias === null && (boundKey === undefined || selectedWorktrees.length)) { - worktrees = items(await deps.worktrees.preview(project, { ...budget, snapshot, + worktrees = items(await deps.worktrees.preview(project, { ...budget, snapshot, selectedWorktrees, + deadline: now() + Math.min(2000, Math.max(0, (budget.deadline - now()) / 2)), + reportCandidate: candidate => { + if (!warnings.some(row => row.code === 'WORKTREE_UNAVAILABLE' && row.target === candidate.id && row.error === candidate.reason)) { + warnings.push({ code: 'WORKTREE_UNAVAILABLE', target: candidate.id, error: candidate.reason }); + } + }, ...(boundKey === undefined ? {} : { worktreePaths: selectedWorktrees }) })); } worktrees = worktrees.map(row => ({ ...row, selected: selectedWorktrees.includes(row.path) })); diff --git a/src/main/projects/project-delete-worktrees.js b/src/main/projects/project-delete-worktrees.js index fd8ecc40f..34a13f2b2 100644 --- a/src/main/projects/project-delete-worktrees.js +++ b/src/main/projects/project-delete-worktrees.js @@ -6,13 +6,25 @@ const { canonicalPath, fail } = require('./project-delete-identity'); function createProjectDeleteWorktrees({ runGit, readActivity, now = Date.now }) { const check = budget => { - if (budget.signal.aborted || now() >= budget.deadline) throw fail('DISCOVERY_TIMEOUT', 'Worktree preview timed out. Reopen Delete to retry.'); + if (budget.signal.aborted || now() >= budget.deadline) throw fail('DISCOVERY_TIMEOUT', 'Worktree not inspected: inventory time budget exhausted. Reopen Delete to retry.'); }; + async function bounded(read, budget) { + check(budget); + let timer; + try { + const result = await Promise.race([Promise.resolve().then(read), new Promise((_, reject) => { + timer = setTimeout(() => reject(fail('DISCOVERY_TIMEOUT', 'Worktree not inspected: inventory time budget exhausted. Reopen Delete to retry.')), + Math.max(1, budget.deadline - now())); + })]); + check(budget); + return result; + } finally { clearTimeout(timer); } + } async function preview(project, budget) { if (project.alias !== null) throw fail('WORKTREE_UNAVAILABLE', 'Remote worktree removal is unavailable.'); check(budget); if (budget.worktreePaths?.length === 0) return []; - const list = await runGit(['-C', project.projectPath, 'worktree', 'list', '--porcelain']); + const list = await bounded(() => runGit(['-C', project.projectPath, 'worktree', 'list', '--porcelain']), budget); check(budget); const records = deletion.parseWorktreeList(list); if (records.length > Math.min(128, budget.limit)) { @@ -36,19 +48,24 @@ function createProjectDeleteWorktrees({ runGit, readActivity, now = Date.now }) const eligible = rows.filter(row => !row.main && !row.projectDirectory); let activities, activityError; if (eligible.length) { - try { activities = await readActivity({ ...project, worktreePaths: eligible.map(row => row.path) }, budget); } + try { + activities = await bounded(() => readActivity({ ...project, worktreePaths: eligible.map(row => row.path) }, budget), budget); + for (const candidate of activities.candidates || []) budget.reportCandidate?.(candidate); + } catch (error) { activityError = error; } } for (const row of eligible) { try { if (activityError) throw activityError; - const status = await deletion.readStatus(row.path, project.projectPath, runGit, undefined, inventory); + const status = await bounded(() => deletion.readStatus(row.path, project.projectPath, runGit, undefined, inventory, + { ...budget, now }), budget); check(budget); const activity = activities.byPath ? activities.byPath[row.path] : activities; check(budget); Object.assign(row, status, { statusKnown: true, sessions: activity.sessions || [], jobs: activity.jobs || [], sessionsKnown: activity.complete === true && !activity.candidates?.length }); - if (activity.complete !== true || !Array.isArray(activity.sessions) || !Array.isArray(activity.jobs) + if (activity.ownershipUncertain) row.reason = 'Removal blocked by unattributed activity. Review the dialog-level inventory reasons.'; + else if (activity.complete !== true || !Array.isArray(activity.sessions) || !Array.isArray(activity.jobs) || !Array.isArray(activity.candidates) || activity.candidates.length) row.reason = 'Worktree activity is uncertain. Check its sessions and Agents, then reopen Delete.'; else if (activity.jobs.length) row.reason = 'Background jobs prevent worktree removal (#1090). Check the Agents view.'; else if (activity.sessions.length) row.reason = 'Stop the sessions in this worktree first, then reopen Delete.'; @@ -61,7 +78,7 @@ function createProjectDeleteWorktrees({ runGit, readActivity, now = Date.now }) async function remove(project, selected, record) { const budget = { signal: new AbortController().signal, deadline: now() + 15000, limit: 20000 }; try { - const current = await preview(project, { ...budget, worktreePaths: selected.map(row => row.path) }); + const current = await preview(project, { ...budget, worktreePaths: selected.map(row => row.path), selectedWorktrees: selected.map(row => row.path) }); for (const row of selected) { const fresh = current.find(item => item.path === row.path); if (!fresh?.removable || fresh.main || fresh.projectDirectory || fresh.fingerprint !== row.fingerprint) { @@ -76,7 +93,8 @@ function createProjectDeleteWorktrees({ runGit, readActivity, now = Date.now }) let result, attempted = false; try { result = await deletion.removeWorktree(row.path, project.projectPath, row, async () => { - const current = await preview(project, { ...budget, signal: new AbortController().signal, deadline: now() + 15000, worktreePaths: [row.path] }); + const current = await preview(project, { ...budget, signal: new AbortController().signal, deadline: now() + 15000, + worktreePaths: [row.path], selectedWorktrees: [row.path] }); const fresh = current.find(item => item.path === row.path); if (!fresh?.removable || fresh.main || fresh.projectDirectory) throw fail('WORKTREE_UNAVAILABLE', fresh?.reason || 'Worktree registration changed.'); return fresh; diff --git a/test/project-delete-worktrees.test.js b/test/project-delete-worktrees.test.js index 4bc5cd668..9c73700b4 100644 --- a/test/project-delete-worktrees.test.js +++ b/test/project-delete-worktrees.test.js @@ -13,6 +13,93 @@ try { implementation = require('../src/main/projects/project-delete-worktrees'); catch (error) { if (error.code !== 'MODULE_NOT_FOUND') throw error; } const options = { sessions: false, settings: false, schedules: false, transcripts: false, stopBackgroundJobs: false }; +for (const selected of [false, true]) test(`slow status leaves a metadata plan with ${selected ? 'selected' : 'unselected'} uninspected rows`, async t => { + const f = gitFixture(t), p = planning([]); + p.deps.readSnapshot = async () => ({ complete: true, initialScanComplete: true, revision: '1', + projects: [{ alias: null, projectPath: f.root, folderKeys: [] }], declaredHosts: [] }); + const calls = []; + p.deps.worktrees = implementation.createProjectDeleteWorktrees({ + runGit: async args => { + calls.push(args); + if (args.includes('list')) return [f.root, f.target, f.kept].map(dir => `worktree ${dir}\nHEAD abc\n\n`).join(''); + if (args.includes('rev-parse')) return path.join(f.root, 'absent-lock'); + return new Promise(() => {}); + }, readActivity: async () => ({ complete: true, sessions: [], jobs: [], candidates: [] }), + }); + const started = Date.now(); + const result = await createProjectDeletePlanner({ ...p.deps, timeoutMs: 1000 }).preview({ + projectPath: f.root, options, worktrees: selected ? [f.target] : [], + }); + assert.equal(result.ok, true, 'slow worktree status must not time out metadata planning'); + assert.ok(Date.now() - started < 1000, 'inventory must reserve time for metadata planning'); + for (const row of result.plan.worktrees.filter(row => !row.main)) { + assert.equal(row.removable, false); + assert.equal(row.statusKnown, false); + assert.match(row.reason, /not inspected/i); + } + assert.equal(calls.filter(args => args.includes('status')).length, 1, 'expired inventory starts no further status calls'); + assert.equal(result.plan.refusals.length, selected ? 1 : 0); + if (selected) assert.match(result.plan.refusals[0].error, /not inspected/i); +}); + +for (const cwd of ['relative', null]) for (const binding of [null, 'folder', 'projectPath']) test(`session cwd ${cwd} is scoped by ${binding || 'dialog-level ownership'}`, async t => { + const f = gitFixture(t), { createProjectDeleteRuntime } = require('../src/main/projects/project-delete-main'); + const row = { sessionId: 'stray', cwd, ...(binding === 'folder' ? { folder: 'linked-folder' } + : binding === 'projectPath' ? { projectPath: f.target } : {}) }; + const runtime = createProjectDeleteRuntime({ activeSessions: new Map(), jobsDir: path.join(f.root, 'jobs'), homeDir: f.root, + runClaude: async () => ({ code: 0, stdout: '[]' }), cliSessionState: { + getSidebarDescriptors: () => [row], getScheduleRunSnapshot: () => [], readStatusEvidence: async () => ({ known: true, live: null }), + } }); + const result = await runtime.readWorktreeActivity({ ...f.project, worktreePaths: [f.target, f.kept] }, { + ...f.budget(), snapshot: { sessions: [], projects: [{ alias: null, projectPath: f.target, folderKeys: ['linked-folder'] }] }, + }); + assert.deepEqual(result.byPath[f.kept].candidates, [], 'an unrelated row must not make every folder uncertain'); + assert.equal(result.byPath[f.target].candidates.length, binding ? 1 : 0); + assert.equal(result.candidates.length, binding ? 0 : 1, 'unattributed session reason is shown once at dialog level'); +}); + +test('global unknown job is shown once and blocks selected folders only', async t => { + const f = gitFixture(t), { createProjectDeleteRuntime } = require('../src/main/projects/project-delete-main'); + const runtime = createProjectDeleteRuntime({ activeSessions: new Map(), jobsDir: path.join(f.root, 'jobs'), homeDir: f.root, + runClaude: async () => ({ code: 0, stdout: JSON.stringify([{ id: '1234abcd', kind: 'background', sessionId: 'unknown' }]) }), + cliSessionState: { getSidebarDescriptors: () => [], getScheduleRunSnapshot: () => [] } }); + const result = await runtime.readWorktreeActivity({ ...f.project, worktreePaths: [f.target, f.kept] }, + { ...f.budget(), selectedWorktrees: [f.target], snapshot: { sessions: [] } }); + assert.deepEqual(result.byPath[f.kept].candidates, [], 'global job reason must not be copied to each folder'); + assert.equal(result.candidates.length, 1); + assert.match(result.candidates[0].reason, /no durable job record/); + assert.equal(result.byPath[f.target].ownershipUncertain, true, 'unknown job may own selected folder'); + assert.equal(result.byPath[f.kept].ownershipUncertain, false); + const p = planning([]); + p.deps.readSnapshot = async () => ({ complete: true, initialScanComplete: true, revision: '1', sessions: [], + projects: [{ alias: null, projectPath: f.root, folderKeys: [] }], declaredHosts: [] }); + p.deps.worktrees = implementation.createProjectDeleteWorktrees({ readActivity: runtime.readWorktreeActivity, + runGit: async args => args.includes('list') ? [f.root, f.target, f.kept].map(dir => `worktree ${dir}\nHEAD abc\n\n`).join('') + : args.includes('rev-parse') ? path.join(f.root, 'absent-lock') : '' }); + const planner = createProjectDeletePlanner(p.deps); + for (const selected of [[], [f.target]]) { + const preview = await planner.preview({ projectPath: f.root, options, worktrees: selected }); + assert.equal(preview.ok, true); + assert.equal(preview.plan.warnings.filter(row => /no durable job record/.test(row.error)).length, 1); + assert.equal(preview.plan.worktrees.find(row => row.path === f.target).removable, selected.length === 0); + assert.equal(preview.plan.worktrees.find(row => row.path === f.kept).removable, true); + assert.equal(preview.plan.refusals.length, selected.length); + } +}); + +test('shared status stops after a late Git reply when its inspection deadline expires', async t => { + const f = gitFixture(t), deletion = require('../worktree-delete'); + let now = 0; + const commands = []; + await assert.rejects(deletion.readStatus(f.target, f.root, async args => { + commands.push(args); + now = 20; + return args.includes('rev-parse') ? path.join(f.root, 'absent-lock') : ''; + }, undefined, { records: [f.root, f.target].map(directory => ({ path: directory, fields: [] })) }, + { deadline: 10, signal: new AbortController().signal, now: () => now }), /not inspected/i); + assert.equal(commands.length, 1, 'late Git reply must not trigger further status or hashing'); +}); + test('E production activity reader includes descendant sessions, schedules and refused background records', async t => { const { createProjectDeleteRuntime } = require('../src/main/projects/project-delete-main'); const root = fs.realpathSync.native(fs.mkdtempSync(path.join(os.tmpdir(), 'e-activity-'))); diff --git a/worktree-delete.js b/worktree-delete.js index 6c1c0c09a..3f3e4e28d 100644 --- a/worktree-delete.js +++ b/worktree-delete.js @@ -15,13 +15,21 @@ function within(root, candidate) { return relative && relative !== '..' && !relative.startsWith('..' + path.sep) && !path.isAbsolute(relative); } -async function refuseDirectoryLinks(root) { +function checkInspection(budget) { + if (budget?.signal?.aborted || (budget?.now || Date.now)() >= budget?.deadline) { + throw Object.assign(new Error('Worktree not inspected: inventory time budget exhausted. Reopen Delete to retry.'), { code: 'DISCOVERY_TIMEOUT' }); + } +} + +async function refuseDirectoryLinks(root, budget) { + checkInspection(budget); let stat; try { stat = await fs.promises.lstat(root); } catch (error) { if (error.code === 'ENOENT') return; throw error; } if (stat.isSymbolicLink()) throw new Error(`Deletion refused: the worktree path itself is a directory link: ${root}. Remove the link first without recursive deletion, then select the registered worktree.`); const started = Date.now(); const checkTime = () => { + checkInspection(budget); if (Date.now() - started >= DIRECTORY_SCAN_MS) throw new Error('Directory link scan exceeded its 5 second time budget. Review or reduce the worktree directories before trying Delete again.'); }; const realRoot = await fs.promises.realpath(root).catch(() => null); @@ -77,6 +85,7 @@ async function refuseDirectoryLinks(root) { } function hashBytes(budget, bytes) { + checkInspection(budget); budget.used += bytes; if (budget.used > HASH_LIMIT) { const largest = [...budget.files].sort((a, b) => b[1] - a[1]).slice(0, 10).map(([name, size]) => `${name} (${size} bytes)`); @@ -192,6 +201,7 @@ function parseWorktreeList(list) { } async function fileFingerprint(root, name, submodules, runGit, depth, budget) { + checkInspection(budget); const absolute = path.resolve(root, name); const relative = path.relative(path.resolve(root), absolute); if (!relative || relative === '..' || relative.startsWith('..' + path.sep) || path.isAbsolute(relative)) { @@ -279,10 +289,16 @@ async function statusSnapshot(worktreePath, runGit, depth = 0, budget = { used: return { dirty, ignored, submodules, index, records: recordsForFingerprint.sort() }; } -async function readStatus(worktreePath, parentRepo, runGit, readFile = fs.promises.readFile, inventory = {}) { +async function readStatus(worktreePath, parentRepo, runGit, readFile = fs.promises.readFile, inventory = {}, budget) { + checkInspection(budget); const rawGit = runGit; runGit = async (...args) => { - try { return await rawGit(...args); } + try { + checkInspection(budget); + const result = await rawGit(...args); + checkInspection(budget); + return result; + } catch (error) { if (error.code === 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER' || /maxBuffer/i.test(error.message)) { throw new Error('Git preview output is too large. Review or reduce the changed files with Git before trying Delete again.'); @@ -312,8 +328,9 @@ async function readStatus(worktreePath, parentRepo, runGit, readFile = fs.promis if (error.code !== 'ENOENT') throw error; } } - await refuseDirectoryLinks(worktreePath); - const snapshot = await statusSnapshot(worktreePath, runGit); + await refuseDirectoryLinks(worktreePath, budget); + const snapshot = await statusSnapshot(worktreePath, runGit, 0, { ...budget, used: 0, files: new Map() }); + checkInspection(budget); const { dirty, ignored, submodules } = snapshot; const fingerprint = createHash('sha256').update(JSON.stringify([ comparablePath(worktreePath), fields, locked, lockReason, snapshot, From e15185473689476d46684f3343bda39a48dc9b3c Mon Sep 17 00:00:00 2001 From: Jean-Baptiste Date: Fri, 13 Nov 2026 04:55:39 +0100 Subject: [PATCH 5/8] (projects): block selected worktrees on unlocated live sessions and give them the full budget (#474) An active tab, PTY or live CLI session with no known folder blocks every selected worktree again; dormant history only reports. Selected rows are inspected first with the remaining planner budget, and a failed inspection points to the dedicated Delete worktree action. --- .ai/contexts/project-delete.md | 35 +++--- src/main/projects/project-delete-main.js | 17 ++- src/main/projects/project-delete-plan.js | 11 +- src/main/projects/project-delete-worktrees.js | 58 +++++----- test/project-delete-worktrees.test.js | 105 +++++++++++++++++- 5 files changed, 178 insertions(+), 48 deletions(-) diff --git a/.ai/contexts/project-delete.md b/.ai/contexts/project-delete.md index 0cd5cbdd2..2fb96b956 100644 --- a/.ai/contexts/project-delete.md +++ b/.ai/contexts/project-delete.md @@ -17,20 +17,27 @@ compatible with Git 2.24. Inventory failures have a visible dialog reason. Always-kept main/project-directory rows do not read status, scan activity or hash content. Removable labels show the ignored-entry count and at most five dirty entries plus the remainder. -Preview worktree discovery receives at most two seconds and half the remaining -planner budget. Git listing, activity and each status read are deadline-bounded; -status traversal and hashing also check the deadline/signal. Exhausted rows say -"not inspected" and cannot be removed. The metadata plan still completes: an -unchecked row adds no refusal; selecting an uninspected row refuses that physical -selection until it is unchecked or a fresh inspection succeeds. +Unselected worktree discovery receives at most two seconds and half the remaining +planner budget. Selected folders are inspected first, with the remaining planner +budget, both after checkbox changes and on confirmation rechecks. Unselected +folders then retain their bounded share of the remaining time. Git listing, +activity and each status read are deadline-bounded; status traversal and hashing +also check the deadline/signal. Exhausted rows say "not inspected" and cannot be +removed. An unchecked row adds no refusal and the metadata plan still completes. +A selected inspection failure directs the user to the dedicated "Delete worktree" +action in the sidebar. Exhausting the overall planner deadline still fails the +preview, with that same fallback; selecting a folder never extends the deadline. Missing session cwd is a folder candidate only when an absolute project path or the snapshot's local folder-key mapping ties the record to that subtree. Without -such a tie its reason is reported once at dialog level. Global background-job -candidates are likewise reported once, never copied into every row. A selected -folder is blocked when a global job has no resolvable absolute cwd, or its cwd -is that folder or a descendant. A resolvable cwd outside the selected subtree -does not block it. This conservative rule also applies during removal preflight +such a tie its reason is reported once at dialog level. Unlocated active tabs/PTYs, +live or uncertain CLI descriptors, and rows carrying running/unknown liveness +evidence block every selected folder; dormant historical rows without that evidence +only produce the dialog reason. The single conservative rule for unattributed +activity is: live/uncertain sessions and global background-job candidates block +selected folders when their location cannot be resolved or belongs to the selected +subtree, and their reason is reported once at dialog level. A resolvable cwd outside +the selected subtree does not block it. This rule also applies during removal preflight and the final per-folder guard. The parent metadata runtime retains its own existing background ownership checks. @@ -43,9 +50,9 @@ does not unlink automatically, traverse junctions, delete branches or invoke cleanupWorktree. Linked histories remain outside the parent's metadata manifest. The runtime reads all CLI descriptor writers, indexed session evidence, active -tabs, schedules and background job files/list once per preview, shared with the -parent runtime inventory. Path resolutions and background records are cached only -within that inventory; the results are partitioned by folder in memory. +tabs and schedules for each selected/unselected inspection group. Background job +files/list and path resolutions are cached within the preview inventory, shared +with the parent runtime inventory; results are partitioned by folder in memory. Descendant cwd counts as worktree activity. Live or uncertain sessions disable the row; E does not extend A4 stop authority to a linked project's sessions. Background records remain refused diff --git a/src/main/projects/project-delete-main.js b/src/main/projects/project-delete-main.js index f7b354917..1fa3e6314 100644 --- a/src/main/projects/project-delete-main.js +++ b/src/main/projects/project-delete-main.js @@ -192,6 +192,8 @@ function createProjectDeleteRuntime(ports) { const runs = await bounded(() => ports.cliSessionState.getScheduleRunSnapshot(), budget); if (!Array.isArray(runs) || runs.length + rows.length > budget.limit) throw fail('DISCOVERY_LIMIT', 'Schedule inventory unavailable or oversized.'); const evidenceById = new Map(), dialogCandidates = new Map(); + const descriptorRows = new Set(descriptors); + let unlocatedActivity = false; const report = candidate => dialogCandidates.set(JSON.stringify([candidate.id, candidate.reason]), candidate); const local = row => !(row.host || row.remoteAlias || row.alias || parseFolderKey(row.folder || row.folderKey).alias !== null); const associatedPaths = row => { @@ -206,7 +208,17 @@ function createProjectDeleteRuntime(ports) { for (const row of [...rows, ...runs]) { const value = row.cwd; if (local(row) && (typeof value !== 'string' || !path.isAbsolute(value)) && !associatedPaths(row).length) { - report({ id: row.sessionId || row.id, reason: 'Session cwd unavailable.' }); + const id = row.sessionId || row.id; + report({ id, reason: 'Session cwd unavailable.' }); + if (row.active || row.liveness && row.liveness.state !== 'stopped') unlocatedActivity = true; + else if (descriptorRows.has(row)) { + if (!id || row.runtime === 'codex') unlocatedActivity = true; + else { + if (!evidenceById.has(id)) evidenceById.set(id, bounded(() => ports.cliSessionState.readStatusEvidence(id, budget.deadline), budget)); + const evidence = await evidenceById.get(id); + if (!evidence?.known || evidence.live || evidence.ambiguous) unlocatedActivity = true; + } + } } } async function forPath(projectPath) { @@ -246,7 +258,8 @@ function createProjectDeleteRuntime(ports) { } const roster = await readJobs({ ...project, projectPath, includeDescendants: true, worktreeInventory: true }, budget); jobs.push(...roster.jobs); candidates.push(...roster.candidates); - let ownershipUncertain = false; + let ownershipUncertain = unlocatedActivity + && (budget.selectedWorktrees || budget.worktreePaths || []).some(value => normalize(value) === normalize(projectPath)); for (const candidate of roster.globalCandidates) { report(candidate); if (!(budget.selectedWorktrees || budget.worktreePaths || []).some(value => normalize(value) === normalize(projectPath))) continue; diff --git a/src/main/projects/project-delete-plan.js b/src/main/projects/project-delete-plan.js index 317771d26..8c4b8bf82 100644 --- a/src/main/projects/project-delete-plan.js +++ b/src/main/projects/project-delete-plan.js @@ -119,7 +119,8 @@ function createProjectDeletePlanner(deps) { if (project.alias !== null && selectedWorktrees.length) throw fail('WORKTREE_UNAVAILABLE', 'Remote worktree removal is unavailable.'); if (deps.worktrees && project.alias === null && (boundKey === undefined || selectedWorktrees.length)) { worktrees = items(await deps.worktrees.preview(project, { ...budget, snapshot, selectedWorktrees, - deadline: now() + Math.min(2000, Math.max(0, (budget.deadline - now()) / 2)), + deadline: selectedWorktrees.length ? budget.deadline + : now() + Math.min(2000, Math.max(0, (budget.deadline - now()) / 2)), reportCandidate: candidate => { if (!warnings.some(row => row.code === 'WORKTREE_UNAVAILABLE' && row.target === candidate.id && row.error === candidate.reason)) { warnings.push({ code: 'WORKTREE_UNAVAILABLE', target: candidate.id, error: candidate.reason }); @@ -135,7 +136,8 @@ function createProjectDeletePlanner(deps) { } } } catch (error) { - if (selectedWorktrees.length) refuse('WORKTREE_UNAVAILABLE', project.projectPath, error.message); + if (selectedWorktrees.length) refuse('WORKTREE_UNAVAILABLE', project.projectPath, + `${error.message} Use the dedicated "Delete worktree" action in the sidebar.`); else warnings.push({ code: 'WORKTREE_UNAVAILABLE', error: error.message }); } const rowPath = (row, key, code) => { @@ -288,7 +290,10 @@ function createProjectDeletePlanner(deps) { timer = schedule(() => { controller.abort(); reject(fail('DISCOVERY_TIMEOUT', 'Planning timed out; retry after indexing settles.')); }, timeoutMs); })]); } catch (error) { - return { ok: false, code: error.code || 'DISCOVERY_UNAVAILABLE', error: error.message || 'Read-only planning unavailable.' }; + return { ok: false, code: error.code || 'DISCOVERY_UNAVAILABLE', + error: error.code === 'DISCOVERY_TIMEOUT' && input?.worktrees?.length + ? `${error.message} Use the dedicated "Delete worktree" action in the sidebar.` + : error.message || 'Read-only planning unavailable.' }; } finally { cancel(timer); controller.abort(); diff --git a/src/main/projects/project-delete-worktrees.js b/src/main/projects/project-delete-worktrees.js index 34a13f2b2..0dcb666f5 100644 --- a/src/main/projects/project-delete-worktrees.js +++ b/src/main/projects/project-delete-worktrees.js @@ -46,33 +46,41 @@ function createProjectDeleteWorktrees({ runGit, readActivity, now = Date.now }) rows.push(row); } const eligible = rows.filter(row => !row.main && !row.projectDirectory); - let activities, activityError; - if (eligible.length) { - try { - activities = await bounded(() => readActivity({ ...project, worktreePaths: eligible.map(row => row.path) }, budget), budget); - for (const candidate of activities.candidates || []) budget.reportCandidate?.(candidate); + const selected = eligible.filter(row => budget.selectedWorktrees?.includes(row.path)); + async function inspect(group, inspectionBudget) { + let activities, activityError; + if (group.length) { + try { + activities = await bounded(() => readActivity({ ...project, worktreePaths: group.map(row => row.path) }, inspectionBudget), inspectionBudget); + for (const candidate of activities.candidates || []) budget.reportCandidate?.(candidate); + } + catch (error) { activityError = error; } + } + for (const row of group) { + try { + if (activityError) throw activityError; + const status = await bounded(() => deletion.readStatus(row.path, project.projectPath, runGit, undefined, inventory, + { ...inspectionBudget, now }), inspectionBudget); + check(inspectionBudget); + const activity = activities.byPath ? activities.byPath[row.path] : activities; + check(inspectionBudget); + Object.assign(row, status, { statusKnown: true, sessions: activity.sessions || [], jobs: activity.jobs || [], + sessionsKnown: activity.complete === true && !activity.candidates?.length }); + if (activity.ownershipUncertain) row.reason = 'Removal blocked by unattributed activity. Review the dialog-level inventory reasons.'; + else if (activity.complete !== true || !Array.isArray(activity.sessions) || !Array.isArray(activity.jobs) + || !Array.isArray(activity.candidates) || activity.candidates.length) row.reason = 'Worktree activity is uncertain. Check its sessions and Agents, then reopen Delete.'; + else if (activity.jobs.length) row.reason = 'Background jobs prevent worktree removal (#1090). Check the Agents view.'; + else if (activity.sessions.length) row.reason = 'Stop the sessions in this worktree first, then reopen Delete.'; + else if (status.locked || status.submodules?.length) row.reason = 'Locked worktrees and submodules require the dedicated Delete worktree dialog.'; + else row.removable = true; + } catch (error) { + row.reason = error.message + (selected.includes(row) ? ' Use the dedicated "Delete worktree" action in the sidebar.' : ''); + } } - catch (error) { activityError = error; } - } - for (const row of eligible) { - try { - if (activityError) throw activityError; - const status = await bounded(() => deletion.readStatus(row.path, project.projectPath, runGit, undefined, inventory, - { ...budget, now }), budget); - check(budget); - const activity = activities.byPath ? activities.byPath[row.path] : activities; - check(budget); - Object.assign(row, status, { statusKnown: true, sessions: activity.sessions || [], jobs: activity.jobs || [], - sessionsKnown: activity.complete === true && !activity.candidates?.length }); - if (activity.ownershipUncertain) row.reason = 'Removal blocked by unattributed activity. Review the dialog-level inventory reasons.'; - else if (activity.complete !== true || !Array.isArray(activity.sessions) || !Array.isArray(activity.jobs) - || !Array.isArray(activity.candidates) || activity.candidates.length) row.reason = 'Worktree activity is uncertain. Check its sessions and Agents, then reopen Delete.'; - else if (activity.jobs.length) row.reason = 'Background jobs prevent worktree removal (#1090). Check the Agents view.'; - else if (activity.sessions.length) row.reason = 'Stop the sessions in this worktree first, then reopen Delete.'; - else if (status.locked || status.submodules?.length) row.reason = 'Locked worktrees and submodules require the dedicated Delete worktree dialog.'; - else row.removable = true; - } catch (error) { row.reason = error.message; } } + await inspect(selected, budget); + await inspect(eligible.filter(row => !selected.includes(row)), selected.length + ? { ...budget, deadline: now() + Math.min(2000, Math.max(0, (budget.deadline - now()) / 2)) } : budget); return rows; } async function remove(project, selected, record) { diff --git a/test/project-delete-worktrees.test.js b/test/project-delete-worktrees.test.js index 9c73700b4..6bda443ff 100644 --- a/test/project-delete-worktrees.test.js +++ b/test/project-delete-worktrees.test.js @@ -13,7 +13,7 @@ try { implementation = require('../src/main/projects/project-delete-worktrees'); catch (error) { if (error.code !== 'MODULE_NOT_FOUND') throw error; } const options = { sessions: false, settings: false, schedules: false, transcripts: false, stopBackgroundJobs: false }; -for (const selected of [false, true]) test(`slow status leaves a metadata plan with ${selected ? 'selected' : 'unselected'} uninspected rows`, async t => { +test('slow unselected status leaves a metadata plan with uninspected rows', async t => { const f = gitFixture(t), p = planning([]); p.deps.readSnapshot = async () => ({ complete: true, initialScanComplete: true, revision: '1', projects: [{ alias: null, projectPath: f.root, folderKeys: [] }], declaredHosts: [] }); @@ -28,7 +28,7 @@ for (const selected of [false, true]) test(`slow status leaves a metadata plan w }); const started = Date.now(); const result = await createProjectDeletePlanner({ ...p.deps, timeoutMs: 1000 }).preview({ - projectPath: f.root, options, worktrees: selected ? [f.target] : [], + projectPath: f.root, options, worktrees: [], }); assert.equal(result.ok, true, 'slow worktree status must not time out metadata planning'); assert.ok(Date.now() - started < 1000, 'inventory must reserve time for metadata planning'); @@ -38,8 +38,68 @@ for (const selected of [false, true]) test(`slow status leaves a metadata plan w assert.match(row.reason, /not inspected/i); } assert.equal(calls.filter(args => args.includes('status')).length, 1, 'expired inventory starts no further status calls'); - assert.equal(result.plan.refusals.length, selected ? 1 : 0); - if (selected) assert.match(result.plan.refusals[0].error, /not inspected/i); + assert.equal(result.plan.refusals.length, 0); +}); + +for (const selected of [false, true]) test(`three-second status gets the ${selected ? 'selected' : 'unselected'} inspection budget`, async t => { + const f = gitFixture(t), p = planning([]), deletion = require('../worktree-delete'); + let time = 0; + const deadlines = []; + t.mock.method(deletion, 'readStatus', async (directory, _root, _git, _unused, _inventory, budget) => { + deadlines.push({ directory, remaining: budget.deadline - time }); + time += 3000; + return { dirty: [], fingerprint: directory }; + }); + p.deps.readSnapshot = async () => ({ complete: true, initialScanComplete: true, revision: '1', + projects: [{ alias: null, projectPath: f.root, folderKeys: [] }], declaredHosts: [] }); + p.deps.worktrees = implementation.createProjectDeleteWorktrees({ now: () => time, + runGit: async () => [f.root, f.kept, f.target].map(dir => `worktree ${dir}\nHEAD abc\n\n`).join(''), + readActivity: async () => ({ complete: true, sessions: [], jobs: [], candidates: [] }), + }); + const planner = createProjectDeletePlanner({ ...p.deps, now: () => time, timeoutMs: 6500 }); + const result = await planner.preview({ projectPath: f.root, options, worktrees: selected ? [f.target] : [] }); + assert.equal(result.ok, true, 'slow physical inspection must leave a complete metadata plan'); + assert.deepEqual(result.plan.refusals, [], 'a three-second selected inspection must be allowed'); + const chosen = result.plan.worktrees.find(row => row.path === f.target); + assert.equal(chosen.removable, selected, 'selected rows must have enough time for a three-second status'); + assert.equal(chosen.statusKnown, selected); + const unselected = result.plan.worktrees.find(row => row.path === f.kept); + assert.equal(unselected.removable, false); + assert.match(unselected.reason, /not inspected/i); + for (const read of deadlines.filter(row => !selected || row.directory !== f.target)) { + assert.ok(read.remaining <= 2000, 'unselected reads retain the two-second cap even with a selection'); + assert.ok(read.remaining <= (selected ? 1750 : 3250), 'unselected reads take at most half the remaining planner budget'); + } + if (selected) { + assert.equal(deadlines[0].directory, f.target, 'unselected inventory cannot starve a selected row'); + assert.equal((await planner.revalidate(result.plan)).same, true, 'confirm must allow the same slow selected row'); + } +}); + +test('selected status cannot exceed the overall planner deadline and offers the sidebar fallback', async t => { + const f = gitFixture(t), p = planning([]), deletion = require('../worktree-delete'); + t.mock.method(deletion, 'readStatus', () => new Promise(() => {})); + p.deps.readSnapshot = async () => ({ complete: true, initialScanComplete: true, revision: '1', + projects: [{ alias: null, projectPath: f.root, folderKeys: [] }], declaredHosts: [] }); + p.deps.worktrees = implementation.createProjectDeleteWorktrees({ + runGit: async () => [f.root, f.target].map(dir => `worktree ${dir}\nHEAD abc\n\n`).join(''), + readActivity: async () => ({ complete: true, sessions: [], jobs: [], candidates: [] }), + }); + const result = await createProjectDeletePlanner({ ...p.deps, timeoutMs: 100 }).preview({ + projectPath: f.root, options, worktrees: [f.target], + }); + assert.equal(result.ok, false, 'the overall deadline remains authoritative for a hung selected inspection'); + assert.equal(result.code, 'DISCOVERY_TIMEOUT'); + assert.match(result.error, /Delete worktree.*sidebar/i); +}); + +test('selected inspection failure directs the user to Delete worktree in the sidebar', async t => { + const f = gitFixture(t), deletion = require('../worktree-delete'); + t.mock.method(deletion, 'readStatus', async () => { throw new Error('Worktree not inspected: status unavailable.'); }); + const rows = await f.adapter.preview(f.project, { ...f.budget(), selectedWorktrees: [f.target.replaceAll('\\', '/')] }); + const selected = rows.find(row => path.resolve(row.path) === f.target); + assert.equal(selected.removable, false); + assert.match(selected.reason, /Delete worktree.*sidebar/i, 'uninspectable selection must offer the dedicated sidebar action'); }); for (const cwd of ['relative', null]) for (const binding of [null, 'folder', 'projectPath']) test(`session cwd ${cwd} is scoped by ${binding || 'dialog-level ownership'}`, async t => { @@ -58,6 +118,43 @@ for (const cwd of ['relative', null]) for (const binding of [null, 'folder', 'pr assert.equal(result.candidates.length, binding ? 0 : 1, 'unattributed session reason is shown once at dialog level'); }); +for (const kind of ['active', 'live descriptor', 'unknown descriptor', 'ambiguous descriptor', 'stopped descriptor', 'dormant']) { + test(`unlocated ${kind} only blocks selected folders when activity is live or uncertain`, async t => { + const f = gitFixture(t), { createProjectDeleteRuntime } = require('../src/main/projects/project-delete-main'); + const row = { sessionId: 'unlocated', cwd: null }; + const blocking = !['stopped descriptor', 'dormant'].includes(kind); + const runtime = createProjectDeleteRuntime({ + activeSessions: new Map(kind === 'active' ? [[row.sessionId, row]] : []), + jobsDir: path.join(f.root, 'jobs'), homeDir: f.root, runClaude: async () => ({ code: 0, stdout: '[]' }), + cliSessionState: { + getSidebarDescriptors: () => kind.includes('descriptor') ? [row] : [], getScheduleRunSnapshot: () => [], + readStatusEvidence: async () => ({ known: kind !== 'unknown descriptor', + live: kind === 'live descriptor' ? { pid: 123 } : null, ambiguous: kind === 'ambiguous descriptor' }), + }, + }); + const p = planning([]); + p.deps.readSnapshot = async () => ({ complete: true, initialScanComplete: true, revision: '1', sessions: [row], + projects: [{ alias: null, projectPath: f.root, folderKeys: [] }], declaredHosts: [] }); + p.deps.worktrees = implementation.createProjectDeleteWorktrees({ readActivity: runtime.readWorktreeActivity, + runGit: async args => args.includes('list') ? [f.root, f.target, f.kept].map(dir => `worktree ${dir}\nHEAD abc\n\n`).join('') + : args.includes('rev-parse') ? path.join(f.root, 'absent-lock') : '' }); + const planner = createProjectDeletePlanner(p.deps); + for (const selected of [[], [f.target], [f.target, f.kept]]) { + const preview = await planner.preview({ projectPath: f.root, options, worktrees: selected }); + assert.equal(preview.ok, true, 'unlocated activity must not prevent the metadata plan'); + assert.equal(preview.plan.warnings.filter(row => /Session cwd unavailable/.test(row.error)).length, 1, + 'duplicate session sources must produce one dialog reason'); + assert.equal(preview.plan.refusals.length, blocking ? selected.length : 0, + 'unlocated live or uncertain session must refuse every selected folder'); + for (const row of preview.plan.worktrees.filter(row => !row.main)) { + const refused = blocking && selected.includes(row.path); + assert.equal(row.removable, !refused); + if (refused) assert.match(row.reason, /unattributed activity/i); + } + } + }); +} + test('global unknown job is shown once and blocks selected folders only', async t => { const f = gitFixture(t), { createProjectDeleteRuntime } = require('../src/main/projects/project-delete-main'); const runtime = createProjectDeleteRuntime({ activeSessions: new Map(), jobsDir: path.join(f.root, 'jobs'), homeDir: f.root, From 55c62cdbc8654886ade166b4440b45cba4ba23c6 Mon Sep 17 00:00:00 2001 From: Jean-Baptiste Date: Fri, 13 Nov 2026 05:25:17 +0100 Subject: [PATCH 6/8] (projects): block on unlocated schedule runs and keep a margin for the plan (#474) --- .ai/contexts/project-delete.md | 6 +++- src/main/projects/project-delete-main.js | 4 +-- src/main/projects/project-delete-plan.js | 4 ++- test/project-delete-worktrees.test.js | 46 +++++++++++++++++++++--- 4 files changed, 51 insertions(+), 9 deletions(-) diff --git a/.ai/contexts/project-delete.md b/.ai/contexts/project-delete.md index 2fb96b956..d3603b1a4 100644 --- a/.ai/contexts/project-delete.md +++ b/.ai/contexts/project-delete.md @@ -19,7 +19,10 @@ show the ignored-entry count and at most five dirty entries plus the remainder. Unselected worktree discovery receives at most two seconds and half the remaining planner budget. Selected folders are inspected first, with the remaining planner -budget, both after checkbox changes and on confirmation rechecks. Unselected +budget minus a 500 ms metadata finish margin, both after checkbox changes and on +confirmation rechecks. This reserves time for the writer revision fence and final +deadline check; an exhausted selected inspection returns a refused, "not inspected" +row while metadata planning can still complete. Unselected folders then retain their bounded share of the remaining time. Git listing, activity and each status read are deadline-bounded; status traversal and hashing also check the deadline/signal. Exhausted rows say "not inspected" and cannot be @@ -31,6 +34,7 @@ preview, with that same fallback; selecting a folder never extends the deadline. Missing session cwd is a folder candidate only when an absolute project path or the snapshot's local folder-key mapping ties the record to that subtree. Without such a tie its reason is reported once at dialog level. Unlocated active tabs/PTYs, +scheduled runs (live by definition, even without active or liveness fields), live or uncertain CLI descriptors, and rows carrying running/unknown liveness evidence block every selected folder; dormant historical rows without that evidence only produce the dialog reason. The single conservative rule for unattributed diff --git a/src/main/projects/project-delete-main.js b/src/main/projects/project-delete-main.js index 1fa3e6314..cb001c6a8 100644 --- a/src/main/projects/project-delete-main.js +++ b/src/main/projects/project-delete-main.js @@ -192,7 +192,7 @@ function createProjectDeleteRuntime(ports) { const runs = await bounded(() => ports.cliSessionState.getScheduleRunSnapshot(), budget); if (!Array.isArray(runs) || runs.length + rows.length > budget.limit) throw fail('DISCOVERY_LIMIT', 'Schedule inventory unavailable or oversized.'); const evidenceById = new Map(), dialogCandidates = new Map(); - const descriptorRows = new Set(descriptors); + const descriptorRows = new Set(descriptors), scheduledRows = new Set(runs); let unlocatedActivity = false; const report = candidate => dialogCandidates.set(JSON.stringify([candidate.id, candidate.reason]), candidate); const local = row => !(row.host || row.remoteAlias || row.alias || parseFolderKey(row.folder || row.folderKey).alias !== null); @@ -210,7 +210,7 @@ function createProjectDeleteRuntime(ports) { if (local(row) && (typeof value !== 'string' || !path.isAbsolute(value)) && !associatedPaths(row).length) { const id = row.sessionId || row.id; report({ id, reason: 'Session cwd unavailable.' }); - if (row.active || row.liveness && row.liveness.state !== 'stopped') unlocatedActivity = true; + if (row.active || scheduledRows.has(row) || row.liveness && row.liveness.state !== 'stopped') unlocatedActivity = true; else if (descriptorRows.has(row)) { if (!id || row.runtime === 'codex') unlocatedActivity = true; else { diff --git a/src/main/projects/project-delete-plan.js b/src/main/projects/project-delete-plan.js index 8c4b8bf82..cfb115be7 100644 --- a/src/main/projects/project-delete-plan.js +++ b/src/main/projects/project-delete-plan.js @@ -5,6 +5,8 @@ const { parseFolderKey } = require('../remote/remote-hosts'); const { worktreeParentPath } = require('../../../public/worktree-nesting'); const { OPTION_KEYS, isRecord, text, fail, canonicalPath, identity, stable, digest, compare, membershipRecord } = require('./project-delete-identity'); +const METADATA_FINISH_MARGIN_MS = 500; + function validateRequest(request) { if (!isRecord(request) || Object.keys(request).some(key => !['projectPath', 'folderKey', 'options', 'worktrees'].includes(key)) || !text(request.projectPath) || (request.folderKey !== undefined && !text(request.folderKey)) @@ -119,7 +121,7 @@ function createProjectDeletePlanner(deps) { if (project.alias !== null && selectedWorktrees.length) throw fail('WORKTREE_UNAVAILABLE', 'Remote worktree removal is unavailable.'); if (deps.worktrees && project.alias === null && (boundKey === undefined || selectedWorktrees.length)) { worktrees = items(await deps.worktrees.preview(project, { ...budget, snapshot, selectedWorktrees, - deadline: selectedWorktrees.length ? budget.deadline + deadline: selectedWorktrees.length ? budget.deadline - METADATA_FINISH_MARGIN_MS : now() + Math.min(2000, Math.max(0, (budget.deadline - now()) / 2)), reportCandidate: candidate => { if (!warnings.some(row => row.code === 'WORKTREE_UNAVAILABLE' && row.target === candidate.id && row.error === candidate.reason)) { diff --git a/test/project-delete-worktrees.test.js b/test/project-delete-worktrees.test.js index 6bda443ff..727092595 100644 --- a/test/project-delete-worktrees.test.js +++ b/test/project-delete-worktrees.test.js @@ -76,7 +76,7 @@ for (const selected of [false, true]) test(`three-second status gets the ${selec } }); -test('selected status cannot exceed the overall planner deadline and offers the sidebar fallback', async t => { +test('planner deadline still bounds the metadata fence after a selected inspection expires', async t => { const f = gitFixture(t), p = planning([]), deletion = require('../worktree-delete'); t.mock.method(deletion, 'readStatus', () => new Promise(() => {})); p.deps.readSnapshot = async () => ({ complete: true, initialScanComplete: true, revision: '1', @@ -85,14 +85,49 @@ test('selected status cannot exceed the overall planner deadline and offers the runGit: async () => [f.root, f.target].map(dir => `worktree ${dir}\nHEAD abc\n\n`).join(''), readActivity: async () => ({ complete: true, sessions: [], jobs: [], candidates: [] }), }); - const result = await createProjectDeletePlanner({ ...p.deps, timeoutMs: 100 }).preview({ + p.deps.readRevision = () => new Promise(() => {}); + const result = await createProjectDeletePlanner({ ...p.deps, timeoutMs: 1000 }).preview({ projectPath: f.root, options, worktrees: [f.target], }); - assert.equal(result.ok, false, 'the overall deadline remains authoritative for a hung selected inspection'); + assert.equal(result.ok, false, 'the overall deadline remains authoritative for a stalled metadata fence'); assert.equal(result.code, 'DISCOVERY_TIMEOUT'); assert.match(result.error, /Delete worktree.*sidebar/i); }); +test('selected inspection reserves 500ms for the metadata fence and returns an uninspected row', async t => { + const f = gitFixture(t), p = planning([]); + let time = 0, inspectionDeadline, fenceTime; + p.deps.readSnapshot = async () => ({ complete: true, initialScanComplete: true, revision: '1', + projects: [{ alias: null, projectPath: f.root, folderKeys: [] }], declaredHosts: [] }); + p.deps.readRevision = async () => { fenceTime = time; time += 100; return '1'; }; + p.deps.worktrees = implementation.createProjectDeleteWorktrees({ now: () => time, + runGit: async args => { + if (args.includes('list')) return [f.root, f.target].map(dir => `worktree ${dir}\nHEAD abc\n\n`).join(''); + if (args.includes('rev-parse')) return path.join(f.root, 'absent-lock'); + if (args.includes('status')) time = inspectionDeadline; + return ''; + }, + readActivity: async (_project, budget) => { + inspectionDeadline = budget.deadline; + return { complete: true, sessions: [], jobs: [], candidates: [] }; + }, + }); + const result = await createProjectDeletePlanner({ ...p.deps, now: () => time, timeoutMs: 10000 }).preview({ + projectPath: f.root, options, worktrees: [f.target], + }); + assert.equal(result.ok, true, 'exhausted selected inspection must leave time for metadata planning'); + assert.equal(inspectionDeadline, 9500, 'selected inspection must end 500ms before the planner deadline'); + assert.equal(fenceTime, 9500); + assert.equal(result.plan.revision, '1'); + const selected = result.plan.worktrees.find(row => row.path === f.target); + assert.equal(selected.removable, false); + assert.equal(selected.statusKnown, false); + assert.match(selected.reason, /not inspected/i); + assert.match(selected.reason, /Delete worktree.*sidebar/i); + assert.equal(result.plan.refusals.length, 1); + assert.equal(result.plan.refusals[0].target, f.target); +}); + test('selected inspection failure directs the user to Delete worktree in the sidebar', async t => { const f = gitFixture(t), deletion = require('../worktree-delete'); t.mock.method(deletion, 'readStatus', async () => { throw new Error('Worktree not inspected: status unavailable.'); }); @@ -118,7 +153,7 @@ for (const cwd of ['relative', null]) for (const binding of [null, 'folder', 'pr assert.equal(result.candidates.length, binding ? 0 : 1, 'unattributed session reason is shown once at dialog level'); }); -for (const kind of ['active', 'live descriptor', 'unknown descriptor', 'ambiguous descriptor', 'stopped descriptor', 'dormant']) { +for (const kind of ['active', 'scheduled run', 'live descriptor', 'unknown descriptor', 'ambiguous descriptor', 'stopped descriptor', 'dormant']) { test(`unlocated ${kind} only blocks selected folders when activity is live or uncertain`, async t => { const f = gitFixture(t), { createProjectDeleteRuntime } = require('../src/main/projects/project-delete-main'); const row = { sessionId: 'unlocated', cwd: null }; @@ -127,7 +162,8 @@ for (const kind of ['active', 'live descriptor', 'unknown descriptor', 'ambiguou activeSessions: new Map(kind === 'active' ? [[row.sessionId, row]] : []), jobsDir: path.join(f.root, 'jobs'), homeDir: f.root, runClaude: async () => ({ code: 0, stdout: '[]' }), cliSessionState: { - getSidebarDescriptors: () => kind.includes('descriptor') ? [row] : [], getScheduleRunSnapshot: () => [], + getSidebarDescriptors: () => kind.includes('descriptor') ? [row] : [], + getScheduleRunSnapshot: () => kind === 'scheduled run' ? [row] : [], readStatusEvidence: async () => ({ known: kind !== 'unknown descriptor', live: kind === 'live descriptor' ? { pid: 123 } : null, ambiguous: kind === 'ambiguous descriptor' }), }, From 1ffbbd5541707c5fc060f882345d3a3ea9be6c45 Mon Sep 17 00:00:00 2001 From: Jean-Baptiste Date: Fri, 13 Nov 2026 15:24:14 +0100 Subject: [PATCH 7/8] (projects): read worktree activity from the preview's own process table and follow worktree removal to the end (#474) The worktree activity read and the check before each removal use an isolated, per-preview process table instead of the shared cache, so a session started moments earlier cannot pass for stopped. The renderer's follow-up ceiling grows with the number of selected worktree folders. --- .ai/contexts/project-delete.md | 13 ++++ eslint.config.js | 3 +- public/setting-defaults.js | 5 +- public/sidebar.js | 5 +- src/main/projects/project-delete-main.js | 30 +++++--- src/main/projects/project-delete-worktrees.js | 9 ++- test/dom-project-delete.test.js | 21 ++++-- test/project-delete-main.test.js | 12 ++- test/project-delete-worktrees.test.js | 73 +++++++++++++++++++ 9 files changed, 145 insertions(+), 26 deletions(-) diff --git a/.ai/contexts/project-delete.md b/.ai/contexts/project-delete.md index c01321c77..29801a268 100644 --- a/.ai/contexts/project-delete.md +++ b/.ai/contexts/project-delete.md @@ -59,6 +59,13 @@ The runtime reads all CLI descriptor writers, indexed session evidence, active tabs and schedules for each selected/unselected inspection group. Background job files/list and path resolutions are cached within the preview inventory, shared with the parent runtime inventory; results are partitioned by folder in memory. +Both located and unattributed descriptor reads consume the process table for +that inventory's abort signal. They share A4's single deadline-bounded fresh +re-read if the early table expires; an expired replacement is not retried. +Missing, stale or mismatched process evidence retains the descriptor reader's +unknown result and cannot establish absence. Removal preflight and every final +per-folder guard start independent process reads for their own signals, so they +never reuse the preview table or the Windows global refresh cache. Descendant cwd counts as worktree activity. Live or uncertain sessions disable the row; E does not extend A4 stop authority to a linked project's sessions. Background records remain refused @@ -89,6 +96,12 @@ after removal does it reread writer scope and revalidate parent membership/death omitting already-consumed physical selections from this final preview. The writer's manifest/options remain metadata-only. The operation retains launch holds until Git settles, even after an early IPC unknown reply. +Renderer follow-up keeps the same operation ID and only reads state. With no +folders selected its ceiling stays 325 seconds. Otherwise it adds the 15-second +preflight and, per selected folder, the 15-second final inspection from +`project-delete-worktrees.js` plus the 120-second Git removal timeout from +`main.js`'s `worktreeGit`. The two named worktree constants beside the base +renderer timeout encode these bounds; two selections allow 610 seconds. `worktrees` on operation views records removed/failed/refused/remaining paths. A refusal before Git removal has no disk effect and does not make the operation diff --git a/eslint.config.js b/eslint.config.js index c95b02365..0d3af5f16 100644 --- a/eslint.config.js +++ b/eslint.config.js @@ -797,7 +797,8 @@ module.exports = [ { files: ['public/sidebar.js'], - languageOptions: { globals: { PROJECT_DELETE_DIALOG_TIMEOUT_MS: 'readonly', PROJECT_DELETE_FOLLOWUP_TIMEOUT_MS: 'readonly' } }, + languageOptions: { globals: { PROJECT_DELETE_DIALOG_TIMEOUT_MS: 'readonly', PROJECT_DELETE_FOLLOWUP_TIMEOUT_MS: 'readonly', + PROJECT_DELETE_WORKTREE_INSPECTION_TIMEOUT_MS: 'readonly', PROJECT_DELETE_WORKTREE_REMOVE_TIMEOUT_MS: 'readonly' } }, }, // CodeMirror setup file uses ESM-style imports/closure that don't lint well diff --git a/public/setting-defaults.js b/public/setting-defaults.js index 21b37b175..faf8a150b 100644 --- a/public/setting-defaults.js +++ b/public/setting-defaults.js @@ -40,6 +40,8 @@ const SETTING_DEFAULTS = { const PROJECT_DELETE_PREVIEW_TIMEOUT_MS = 20000; const PROJECT_DELETE_DIALOG_TIMEOUT_MS = PROJECT_DELETE_PREVIEW_TIMEOUT_MS + 1000; const PROJECT_DELETE_FOLLOWUP_TIMEOUT_MS = 3 * PROJECT_DELETE_PREVIEW_TIMEOUT_MS + 2 * 10000 + 60000 + 60000 + 70000 + 10000 + 3 * 10000 + 15000; +const PROJECT_DELETE_WORKTREE_INSPECTION_TIMEOUT_MS = 15000; +const PROJECT_DELETE_WORKTREE_REMOVE_TIMEOUT_MS = 120000; const BROWSER_MODES = Object.freeze([ Object.freeze({ value: 'off', label: 'Off' }), @@ -63,5 +65,6 @@ function normalizeBrowserSettings(settings, diagnostic = message => console.warn if (typeof module !== 'undefined' && module.exports) { module.exports = { SETTING_DEFAULTS, BROWSER_MODES, normalizeBrowserSettings, - PROJECT_DELETE_PREVIEW_TIMEOUT_MS, PROJECT_DELETE_DIALOG_TIMEOUT_MS, PROJECT_DELETE_FOLLOWUP_TIMEOUT_MS }; + PROJECT_DELETE_PREVIEW_TIMEOUT_MS, PROJECT_DELETE_DIALOG_TIMEOUT_MS, PROJECT_DELETE_FOLLOWUP_TIMEOUT_MS, + PROJECT_DELETE_WORKTREE_INSPECTION_TIMEOUT_MS, PROJECT_DELETE_WORKTREE_REMOVE_TIMEOUT_MS }; } diff --git a/public/sidebar.js b/public/sidebar.js index 05726ad91..61df54673 100644 --- a/public/sidebar.js +++ b/public/sidebar.js @@ -1184,7 +1184,10 @@ async function confirmAndDeleteProjectFolder(project, button) { setProjectDeletionWritesBlocked(project, true); await window.flushProjectDeletionWrites?.(); let result = await projectDeletionCall('deleteProject', { token: answers.plan.token, fingerprint: answers.plan.plan.fingerprint }); - const stateDeadline = Date.now() + PROJECT_DELETE_FOLLOWUP_TIMEOUT_MS; + const selectedWorktrees = request(answers).worktrees.length; + const worktreeTimeout = selectedWorktrees ? PROJECT_DELETE_WORKTREE_INSPECTION_TIMEOUT_MS + + selectedWorktrees * (PROJECT_DELETE_WORKTREE_INSPECTION_TIMEOUT_MS + PROJECT_DELETE_WORKTREE_REMOVE_TIMEOUT_MS) : 0; + const stateDeadline = Date.now() + PROJECT_DELETE_FOLLOWUP_TIMEOUT_MS + worktreeTimeout; while (result?.operationId && result.code === 'EXECUTION_PENDING') { const operationId = result.operationId; try { diff --git a/src/main/projects/project-delete-main.js b/src/main/projects/project-delete-main.js index 52a24c484..42bca4384 100644 --- a/src/main/projects/project-delete-main.js +++ b/src/main/projects/project-delete-main.js @@ -133,13 +133,7 @@ function createProjectDeleteRuntime(ports) { } const sessionsFor = id => [...ports.activeSessions].filter(([key, session]) => [key, session.sessionId, session.realSessionId].includes(id)); - async function readLiveness(row, budget) { - const scope = scopes.getStore(); - if (!scope) throw fail('DISCOVERY_UNAVAILABLE', 'Runtime operation scope unavailable.'); - const { members, pins } = scope; - if (members.size >= 50000 && !members.has(row.id)) throw fail('DISCOVERY_LIMIT', 'Runtime identity limit.'); - members.set(row.id, row); - if (row.alias !== null || row.runtime === 'codex' || row.jobId) return { state: 'unknown' }; + async function readEvidenceOptions(budget) { const early = processReads.get(budget.signal); let processTable = await early?.table; if (processTable?.expiresAt <= now() && now() < budget.deadline) { @@ -147,7 +141,16 @@ function createProjectDeleteRuntime(ports) { () => ports.cliSessionState.readProcessTableSnapshot(budget.deadline, { fresh: true, signal: budget.signal }), budget); processTable = await early.refreshed; } - const evidenceOptions = processTable === undefined ? {} : { processTable }; + return processTable === undefined ? {} : { processTable }; + } + async function readLiveness(row, budget) { + const scope = scopes.getStore(); + if (!scope) throw fail('DISCOVERY_UNAVAILABLE', 'Runtime operation scope unavailable.'); + const { members, pins } = scope; + if (members.size >= 50000 && !members.has(row.id)) throw fail('DISCOVERY_LIMIT', 'Runtime identity limit.'); + members.set(row.id, row); + if (row.alias !== null || row.runtime === 'codex' || row.jobId) return { state: 'unknown' }; + const evidenceOptions = await readEvidenceOptions(budget); const matches = sessionsFor(row.sessionId || row.id); if (matches.length > 1) return { state: 'unknown' }; const previous = pins.get(row.id); @@ -208,6 +211,10 @@ function createProjectDeleteRuntime(ports) { const runs = await bounded('cliSessionState.getScheduleRunSnapshot', () => ports.cliSessionState.getScheduleRunSnapshot(), budget); if (!Array.isArray(runs) || runs.length + rows.length > budget.limit) throw fail('DISCOVERY_LIMIT', 'Schedule inventory unavailable or oversized.'); const evidenceById = new Map(), dialogCandidates = new Map(); + const readEvidence = async id => { + const evidenceOptions = await readEvidenceOptions(budget); + return bounded('cliSessionState.readStatusEvidence', () => ports.cliSessionState.readStatusEvidence(id, budget.deadline, evidenceOptions), budget); + }; const descriptorRows = new Set(descriptors), scheduledRows = new Set(runs); let unlocatedActivity = false; const report = candidate => dialogCandidates.set(JSON.stringify([candidate.id, candidate.reason]), candidate); @@ -230,7 +237,7 @@ function createProjectDeleteRuntime(ports) { else if (descriptorRows.has(row)) { if (!id || row.runtime === 'codex') unlocatedActivity = true; else { - if (!evidenceById.has(id)) evidenceById.set(id, bounded('cliSessionState.readStatusEvidence', () => ports.cliSessionState.readStatusEvidence(id, budget.deadline), budget)); + if (!evidenceById.has(id)) evidenceById.set(id, readEvidence(id)); const evidence = await evidenceById.get(id); if (!evidence?.known || evidence.live || evidence.ambiguous) unlocatedActivity = true; } @@ -267,7 +274,7 @@ function createProjectDeleteRuntime(ports) { if (!id || row.runtime === 'codex') { candidates.push({ id, reason: 'Worktree runtime liveness unavailable.' }); continue; } if (seen.has(id)) continue; seen.add(id); - if (!evidenceById.has(id)) evidenceById.set(id, bounded('cliSessionState.readStatusEvidence', () => ports.cliSessionState.readStatusEvidence(id, budget.deadline), budget)); + if (!evidenceById.has(id)) evidenceById.set(id, readEvidence(id)); const evidence = await evidenceById.get(id); if (!evidence?.known || evidence.ambiguous) candidates.push({ id, reason: 'Worktree session liveness uncertain.' }); else if (evidence.live) sessions.push({ sessionId: id, cwd: row.cwd || row.projectPath }); @@ -337,7 +344,8 @@ function createProjectDeleteMain(deps) { let inventory; const runtime = createProjectDeleteRuntime({ ...deps, ...clock, readWorktreeSnapshot: budget => inventory.readSnapshot(budget) }); inventory = createProjectDeleteInventory({ ...deps, ...runtime, ...clock, writer }); - const worktrees = deps.worktreeGit ? createProjectDeleteWorktrees({ runGit: deps.worktreeGit, readActivity: runtime.readWorktreeActivity, now }) : null; + const worktrees = deps.worktreeGit ? createProjectDeleteWorktrees({ runGit: deps.worktreeGit, + readActivity: runtime.readWorktreeActivity, startProcessReads: runtime.startProcessReads, now }) : null; const planner = createProjectDeletePlanner({ ...inventory, ...clock, worktrees }); const stop = createProjectDeleteStop({ ...deps, ...runtime, ...clock }); const service = createProjectDeleteService({ ...clock, writer, inventory, planner, stop, worktrees, gate: deps.gate, log: deps.log, diff --git a/src/main/projects/project-delete-worktrees.js b/src/main/projects/project-delete-worktrees.js index 0dcb666f5..2b5f7e207 100644 --- a/src/main/projects/project-delete-worktrees.js +++ b/src/main/projects/project-delete-worktrees.js @@ -4,7 +4,7 @@ const path = require('node:path'); const deletion = require('../../../worktree-delete'); const { canonicalPath, fail } = require('./project-delete-identity'); -function createProjectDeleteWorktrees({ runGit, readActivity, now = Date.now }) { +function createProjectDeleteWorktrees({ runGit, readActivity, startProcessReads = () => {}, now = Date.now }) { const check = budget => { if (budget.signal.aborted || now() >= budget.deadline) throw fail('DISCOVERY_TIMEOUT', 'Worktree not inspected: inventory time budget exhausted. Reopen Delete to retry.'); }; @@ -86,6 +86,7 @@ function createProjectDeleteWorktrees({ runGit, readActivity, now = Date.now }) async function remove(project, selected, record) { const budget = { signal: new AbortController().signal, deadline: now() + 15000, limit: 20000 }; try { + startProcessReads(project, budget); const current = await preview(project, { ...budget, worktreePaths: selected.map(row => row.path), selectedWorktrees: selected.map(row => row.path) }); for (const row of selected) { const fresh = current.find(item => item.path === row.path); @@ -101,8 +102,10 @@ function createProjectDeleteWorktrees({ runGit, readActivity, now = Date.now }) let result, attempted = false; try { result = await deletion.removeWorktree(row.path, project.projectPath, row, async () => { - const current = await preview(project, { ...budget, signal: new AbortController().signal, deadline: now() + 15000, - worktreePaths: [row.path], selectedWorktrees: [row.path] }); + const removalBudget = { ...budget, signal: new AbortController().signal, deadline: now() + 15000, + worktreePaths: [row.path], selectedWorktrees: [row.path] }; + startProcessReads(project, removalBudget); + const current = await preview(project, removalBudget); const fresh = current.find(item => item.path === row.path); if (!fresh?.removable || fresh.main || fresh.projectDirectory) throw fail('WORKTREE_UNAVAILABLE', fresh?.reason || 'Worktree registration changed.'); return fresh; diff --git a/test/dom-project-delete.test.js b/test/dom-project-delete.test.js index 952f14bc2..066427c58 100644 --- a/test/dom-project-delete.test.js +++ b/test/dom-project-delete.test.js @@ -105,8 +105,12 @@ test('selected preview keeps its own watchdog and shows the failed port with an h.cancel(); await pending; }); -for (const settles of [true, false]) test(`pending execute follows beyond 130 seconds or stops at the shared ceiling, settles=${settles}`, async t => { - const h = setup(t), timers = new Map(), applied = []; +for (const selected of [0, 2]) for (const settles of [true, false]) test(`pending execute respects the ceiling, selected=${selected}, settles=${settles}`, async t => { + const worktrees = Array.from({ length: 2 }, (_, i) => ({ path: 'C:/linked-' + i, removable: true, fingerprint: 'stable', sessions: [], dirty: [] })); + const h = setup(t, { worktrees }), timers = new Map(), applied = []; + const base = 3 * 20000 + 2 * 10000 + 60000 + 60000 + 70000 + 10000 + 3 * 10000 + 15000; + const ceiling = base + (selected ? 15000 + selected * (15000 + 120000) : 0); + const settleAt = selected ? ceiling - 1000 : 130000; let time = 0, id = 0, finished = false; h.w.Date.now = () => time; h.w.setTimeout = (fn, ms) => { timers.set(++id, { fn, at: time + ms }); return id; }; @@ -118,14 +122,15 @@ for (const settles of [true, false]) test(`pending execute follows beyond 130 se }; h.w.api.projectDeleteState = request => { h.calls.state.push(request); - return new Promise(resolve => h.w.setTimeout(() => resolve(settles && time >= 130000 + return new Promise(resolve => h.w.setTimeout(() => resolve(settles && time >= settleAt ? { ok: true, state: 'committed', operationId: 'slow', invalidation: { sessionIds: [], restoreTargets: [] } } - : pendingReply), 10000)); + : pendingReply), 1000)); }; h.w.applyProjectDeletion = async result => applied.push(result); const pending = h.start().then(result => { finished = true; return result; }); - await flush(); h.confirm().click(); await flush(); - const ceiling = 3 * 20000 + 2 * 10000 + 60000 + 60000 + 70000 + 10000 + 3 * 10000 + 15000; + await flush(); + for (let i = 0; i < selected; i++) { h.document.querySelector(`[data-choice-id="worktree:${i}"]`).click(); await flush(); } + h.confirm().click(); await flush(); for (; time < ceiling && !finished;) { time += 1000; for (const [key, timer] of [...timers]) if (timer.at <= time) { timers.delete(key); timer.fn(); } @@ -137,7 +142,7 @@ for (const settles of [true, false]) test(`pending execute follows beyond 130 se assert.ok(h.calls.state.every(request => request.operationId === 'slow'), 'all reads must keep the accepted operation ID'); if (settles) { assert.equal(applied.length, 1, 'a pending execution settling after 130 seconds must apply its committed result'); - assert.equal(time, 130000); + assert.equal(time, settleAt); assert.equal(h.document.querySelector('.app-notice'), null); } else { assert.equal(time, ceiling, 'persistent pending must be followed until the shared ceiling'); @@ -146,7 +151,7 @@ for (const settles of [true, false]) test(`pending execute follows beyond 130 se assert.match(h.document.querySelector('.app-notice').textContent, /Check deletion state/); assert.equal(h.w.isProjectDeleting(h.p), true); } - assert.equal(require('../public/setting-defaults').PROJECT_DELETE_FOLLOWUP_TIMEOUT_MS, ceiling); + assert.equal(require('../public/setting-defaults').PROJECT_DELETE_FOLLOWUP_TIMEOUT_MS, base); }); test('pending follow-up rejects a changed operation identity', async t => { diff --git a/test/project-delete-main.test.js b/test/project-delete-main.test.js index 1ab920b74..4ecf6fc50 100644 --- a/test/project-delete-main.test.js +++ b/test/project-delete-main.test.js @@ -418,7 +418,15 @@ test('E main composition removes a selected folder before real writer completion h.main.dispose(); const linked = path.join(h.projectPath, 'linked'); fs.mkdirSync(linked); fs.writeFileSync(path.join(linked, 'draft'), 'discard only on consent'); - h.ports.cliSessionState.getSidebarDescriptors = () => []; + const activitySignals = []; + h.ports.cliSessionState.getSidebarDescriptors = () => [{ sessionId: 'linked-session', cwd: linked }]; + h.ports.cliSessionState.readProcessTableSnapshot = async (_deadline, opts) => ({ + signal: opts.signal, map: new Map(), expiresAt: h.time.now() + 3000, + }); + h.ports.cliSessionState.readStatusEvidence = async (id, _deadline, opts) => { + if (id === 'linked-session') activitySignals.push(opts?.processTable?.signal); + return { known: true, live: null }; + }; const removed = []; h.ports.worktreeGit = async args => { if (args.includes('list')) { @@ -430,6 +438,8 @@ test('E main composition removes a selected folder before real writer completion if (args.includes('ls-files')) return ''; if (args.includes('status')) return path.resolve(args[1]) === linked ? '?? draft\0' : ''; if (args.includes('remove')) { + assert.ok(activitySignals.slice(-2).every(Boolean), 'main composition must start isolated reads for both disk guards'); + assert.notEqual(activitySignals.at(-1), activitySignals.at(-2), 'each disk guard needs its own process table'); assert.equal(h.calls.includes('completeProjectDeletion'), false, 'disk must precede writer submission'); removed.push(args.at(-1)); fs.rmSync(linked, { recursive: true }); return ''; } diff --git a/test/project-delete-worktrees.test.js b/test/project-delete-worktrees.test.js index 727092595..638f40b4b 100644 --- a/test/project-delete-worktrees.test.js +++ b/test/project-delete-worktrees.test.js @@ -13,6 +13,79 @@ try { implementation = require('../src/main/projects/project-delete-worktrees'); catch (error) { if (error.code !== 'MODULE_NOT_FOUND') throw error; } const options = { sessions: false, settings: false, schedules: false, transcripts: false, stopBackgroundJobs: false }; +for (const located of [true, false]) for (const mode of ['fresh', 'stale', 'missing', 'mismatched']) { + test(`E activity consumes isolated ${mode} process evidence, located=${located}`, async t => { + const f = gitFixture(t), vm = require('node:vm'); + const filename = path.join(__dirname, '../cli-session-state.js'); + const context = vm.createContext({ require: require('node:module').createRequire(filename), module: { exports: {} }, + process, Buffer, Map, Set, setTimeout, clearTimeout, setInterval, clearInterval }); + vm.runInContext(fs.readFileSync(filename, 'utf8'), context, { filename }); + const state = context.module.exports, id = '01234567-89ab-cdef-0123-456789abcdef'; + const dir = path.join(f.root, 'status'); fs.mkdirSync(dir); + const start = '133000000000000000'; + fs.writeFileSync(path.join(dir, '42.json'), JSON.stringify({ pid: 42, sessionId: id, kind: 'interactive', + status: 'idle', pidDomain: 'win32:anchor', procStart: start })); + let time = Date.now(), reads = 0; + state.init({ dir, platform: 'win32', activeSessions: new Map(), now: () => time, isProcessAlive: () => true, + readProcessTable: async () => new Map(), readProcStartMany: async () => new Map([[42, start]]) }); + t.after(() => state.stop()); + const refresh = t.mock.method(context, 'refreshProcessTable'); + const tables = []; + const runtime = require('../src/main/projects/project-delete-main').createProjectDeleteRuntime({ + now: () => time, activeSessions: new Map(), jobsDir: path.join(f.root, 'jobs'), homeDir: f.root, + runClaude: async () => ({ code: 0, stdout: '[]' }), cliSessionState: { + getSidebarDescriptors: () => [{ sessionId: id, cwd: located ? f.target : null }], getScheduleRunSnapshot: () => [], + readProcessTableSnapshot: async (deadline, opts) => { + assert.equal(deadline, budget.deadline); assert.equal(opts.signal, budget.signal); assert.equal(opts.fresh, true); + reads++; + return { at: time, observedAt: time, expiresAt: time + 3000, + map: mode === 'missing' ? null : new Map([[42, { ppid: 1, created: mode === 'mismatched' ? '134000000000000000' : start }]]) }; + }, + readStatusEvidence: (id, deadline, opts) => { tables.push(opts?.processTable); return state.readStatusEvidence(id, deadline, opts); }, + }, + }); + const budget = { ...f.budget(), snapshot: { sessions: [] }, selectedWorktrees: [f.target] }; + runtime.startProcessReads({}, budget); + await new Promise(resolve => setImmediate(resolve)); + time += 4000; + let result = await runtime.readWorktreeActivity({ ...f.project, worktreePaths: [f.target] }, budget); + if (mode === 'stale') { + time += 4000; + result = await runtime.readWorktreeActivity({ ...f.project, worktreePaths: [f.target] }, budget); + } + assert.equal(refresh.mock.callCount(), 0, 'E must never fall back to refreshProcessTable'); + assert.equal(reads, 2, 'E shares one deadline-bounded refresh per inventory signal'); + assert.ok(tables.every(table => table?.expiresAt), 'every E evidence read receives the isolated table'); + const row = result.byPath[f.target]; + if (!located) assert.equal(row.ownershipUncertain, true, 'unlocated live or uncertain evidence blocks removal'); + else if (mode === 'fresh') assert.equal(row.sessions.length, 1); + else assert.equal(row.candidates.length, 1, 'stale, missing or mismatched table leaves activity uncertain'); + }); +} + +test('E removal starts isolated process reads for preflight and every final folder guard', async t => { + const f = gitFixture(t), started = [], activities = [], commands = []; + const adapter = implementation.createProjectDeleteWorktrees({ + startProcessReads: (_request, budget) => started.push(budget.signal), + readActivity: async (_project, budget) => { activities.push(budget.signal); return { complete: true, sessions: [], jobs: [], candidates: [] }; }, + runGit: async args => { + commands.push(args); + if (args.includes('list')) return [f.root, f.target, f.kept].map(dir => `worktree ${dir}\nHEAD abc\n\n`).join(''); + if (args.includes('rev-parse')) return path.join(f.root, 'absent-lock'); + return ''; + }, + }); + const budget = f.budget(); + const rows = (await adapter.preview(f.project, budget)).filter(row => !row.main); + activities.length = 0; + assert.equal(await adapter.remove(f.project, rows, () => {}), true); + assert.equal(started.length, 3, 'preflight and two final guards must each start process reads'); + assert.equal(new Set(started).size, 3, 'removal budgets must not share process-table snapshots'); + assert.ok(started.every(signal => signal !== budget.signal)); + assert.deepEqual(activities, started, 'activity checks consume the signal whose reads were started'); + assert.equal(commands.filter(args => args.includes('remove')).length, 2); +}); + test('slow unselected status leaves a metadata plan with uninspected rows', async t => { const f = gitFixture(t), p = planning([]); p.deps.readSnapshot = async () => ({ complete: true, initialScanComplete: true, revision: '1', From 1d4935443115475db416b4bd767515242b59e8d5 Mon Sep 17 00:00:00 2001 From: Jean-Baptiste Date: Fri, 13 Nov 2026 15:54:18 +0100 Subject: [PATCH 8/8] (projects): abort worktree removal's process reads and share its bounds with main (#474) Each preflight and final per-folder check aborts its own process reads when it ends. Main and the renderer now share the worktree status, removal and directory-scan bounds, and the follow-up ceiling counts the scan and the post-failure inspection. --- .ai/contexts/project-delete.md | 13 ++-- eslint.config.js | 2 +- main.js | 5 +- public/setting-defaults.js | 3 +- public/sidebar.js | 2 +- src/main/projects/project-delete-worktrees.js | 26 ++++---- test/dom-project-delete.test.js | 2 +- test/project-action-harness.js | 1 + test/project-delete-worktrees.test.js | 59 ++++++++++++++++++- test/session-index-sequences.test.js | 1 + test/worktree-delete-safety.test.js | 1 + test/worktree-delete.test.js | 8 ++- worktree-delete.js | 2 +- 13 files changed, 101 insertions(+), 24 deletions(-) diff --git a/.ai/contexts/project-delete.md b/.ai/contexts/project-delete.md index 29801a268..111cc78b1 100644 --- a/.ai/contexts/project-delete.md +++ b/.ai/contexts/project-delete.md @@ -90,7 +90,10 @@ removal warning. Unselected dirty content does not invalidate project consent. Execution drains holds, revalidates, stops/verifies parent targets, preflights all selected rows, then removes sequentially through the shared path with fresh per-removal activity/status checks. Confirm inventories inspect only selected -folders; the final metadata preview skips physical inventory. A failed removal +folders; each inspection starts process reads only after Git identifies eligible +rows. Preflight and each final check (including a post-failure re-read) own an +AbortController and abort it in finally, so refusal and error exits cancel the +Claude roster and process-table reads. The final metadata preview skips physical inventory. A failed removal stops the sequence. Only after removal does it reread writer scope and revalidate parent membership/death, omitting already-consumed physical selections from this final preview. The @@ -99,9 +102,11 @@ holds until Git settles, even after an early IPC unknown reply. Renderer follow-up keeps the same operation ID and only reads state. With no folders selected its ceiling stays 325 seconds. Otherwise it adds the 15-second preflight and, per selected folder, the 15-second final inspection from -`project-delete-worktrees.js` plus the 120-second Git removal timeout from -`main.js`'s `worktreeGit`. The two named worktree constants beside the base -renderer timeout encode these bounds; two selections allow 610 seconds. +`project-delete-worktrees.js`, the 5-second directory-link scan, the 120-second +Git removal timeout from `main.js`'s `worktreeGit`, and one additional 15-second +inspection after a Git failure. Main and renderer import the inspection, removal, +and `DIRECTORY_SCAN_MS` constants from `public/setting-defaults.js`; two selections +allow 650 seconds. This bounds automatic following, not filesystem completion. `worktrees` on operation views records removed/failed/refused/remaining paths. A refusal before Git removal has no disk effect and does not make the operation diff --git a/eslint.config.js b/eslint.config.js index 0d3af5f16..05132a074 100644 --- a/eslint.config.js +++ b/eslint.config.js @@ -798,7 +798,7 @@ module.exports = [ { files: ['public/sidebar.js'], languageOptions: { globals: { PROJECT_DELETE_DIALOG_TIMEOUT_MS: 'readonly', PROJECT_DELETE_FOLLOWUP_TIMEOUT_MS: 'readonly', - PROJECT_DELETE_WORKTREE_INSPECTION_TIMEOUT_MS: 'readonly', PROJECT_DELETE_WORKTREE_REMOVE_TIMEOUT_MS: 'readonly' } }, + PROJECT_DELETE_WORKTREE_INSPECTION_TIMEOUT_MS: 'readonly', PROJECT_DELETE_WORKTREE_REMOVE_TIMEOUT_MS: 'readonly', DIRECTORY_SCAN_MS: 'readonly' } }, }, // CodeMirror setup file uses ESM-style imports/closure that don't lint well diff --git a/main.js b/main.js index ccaaadd60..023b0cbc0 100644 --- a/main.js +++ b/main.js @@ -91,7 +91,8 @@ const { startScheduler, scheduleLaunchRefusal, resolveScheduleSandbox, initialSc const { buildScheduleList } = require('./src/main/schedules/schedule-list'); const { archivePlanForGroups, validArchiveGroups } = require('./archived-projects'); const { encodeProjectPath } = require('./encode-project-path'); -const { SETTING_DEFAULTS, normalizeBrowserSettings } = require('./public/setting-defaults'); +const { SETTING_DEFAULTS, normalizeBrowserSettings, + PROJECT_DELETE_WORKTREE_INSPECTION_TIMEOUT_MS, PROJECT_DELETE_WORKTREE_REMOVE_TIMEOUT_MS } = require('./public/setting-defaults'); const { isSensitivePath, isSensitivePathAsync, isAllowedMemoryPath: _isAllowedMemoryPath, resolveAllowedMemoryPath: _resolveAllowedMemoryPath, isKnownProjectRoot: _isKnownProjectRoot } = require('./src/main/shared/ipc-path-validator'); const { validatePreLaunchCmd } = require('./src/main/terminals/pre-launch-cmd-guard'); const { normalizePtySize } = require('./src/main/terminals/pty-size'); @@ -1154,7 +1155,7 @@ function worktreeGit(args, consume) { while (args[command] === '-C' || args[command] === '-c') command += 2; const removing = args[command] === 'worktree' && args[command + 1] === 'remove'; return new Promise((resolve, reject) => { - execFile('git', args, { env: localGitEnv(), timeout: removing ? 120000 : 15000, maxBuffer: 16 * 1024 * 1024 }, (err, stdout, stderr) => { + execFile('git', args, { env: localGitEnv(), timeout: removing ? PROJECT_DELETE_WORKTREE_REMOVE_TIMEOUT_MS : PROJECT_DELETE_WORKTREE_INSPECTION_TIMEOUT_MS, maxBuffer: 16 * 1024 * 1024 }, (err, stdout, stderr) => { if (err) reject(Object.assign(new Error((stderr || err.message || String(err)).trim()), { code: err.code, killed: err.killed, signal: err.signal })); else resolve(stdout); }); diff --git a/public/setting-defaults.js b/public/setting-defaults.js index faf8a150b..b09e2172f 100644 --- a/public/setting-defaults.js +++ b/public/setting-defaults.js @@ -42,6 +42,7 @@ const PROJECT_DELETE_DIALOG_TIMEOUT_MS = PROJECT_DELETE_PREVIEW_TIMEOUT_MS + 100 const PROJECT_DELETE_FOLLOWUP_TIMEOUT_MS = 3 * PROJECT_DELETE_PREVIEW_TIMEOUT_MS + 2 * 10000 + 60000 + 60000 + 70000 + 10000 + 3 * 10000 + 15000; const PROJECT_DELETE_WORKTREE_INSPECTION_TIMEOUT_MS = 15000; const PROJECT_DELETE_WORKTREE_REMOVE_TIMEOUT_MS = 120000; +const DIRECTORY_SCAN_MS = 5000; const BROWSER_MODES = Object.freeze([ Object.freeze({ value: 'off', label: 'Off' }), @@ -66,5 +67,5 @@ function normalizeBrowserSettings(settings, diagnostic = message => console.warn if (typeof module !== 'undefined' && module.exports) { module.exports = { SETTING_DEFAULTS, BROWSER_MODES, normalizeBrowserSettings, PROJECT_DELETE_PREVIEW_TIMEOUT_MS, PROJECT_DELETE_DIALOG_TIMEOUT_MS, PROJECT_DELETE_FOLLOWUP_TIMEOUT_MS, - PROJECT_DELETE_WORKTREE_INSPECTION_TIMEOUT_MS, PROJECT_DELETE_WORKTREE_REMOVE_TIMEOUT_MS }; + PROJECT_DELETE_WORKTREE_INSPECTION_TIMEOUT_MS, PROJECT_DELETE_WORKTREE_REMOVE_TIMEOUT_MS, DIRECTORY_SCAN_MS }; } diff --git a/public/sidebar.js b/public/sidebar.js index 61df54673..964229857 100644 --- a/public/sidebar.js +++ b/public/sidebar.js @@ -1186,7 +1186,7 @@ async function confirmAndDeleteProjectFolder(project, button) { let result = await projectDeletionCall('deleteProject', { token: answers.plan.token, fingerprint: answers.plan.plan.fingerprint }); const selectedWorktrees = request(answers).worktrees.length; const worktreeTimeout = selectedWorktrees ? PROJECT_DELETE_WORKTREE_INSPECTION_TIMEOUT_MS - + selectedWorktrees * (PROJECT_DELETE_WORKTREE_INSPECTION_TIMEOUT_MS + PROJECT_DELETE_WORKTREE_REMOVE_TIMEOUT_MS) : 0; + + selectedWorktrees * (2 * PROJECT_DELETE_WORKTREE_INSPECTION_TIMEOUT_MS + DIRECTORY_SCAN_MS + PROJECT_DELETE_WORKTREE_REMOVE_TIMEOUT_MS) : 0; const stateDeadline = Date.now() + PROJECT_DELETE_FOLLOWUP_TIMEOUT_MS + worktreeTimeout; while (result?.operationId && result.code === 'EXECUTION_PENDING') { const operationId = result.operationId; diff --git a/src/main/projects/project-delete-worktrees.js b/src/main/projects/project-delete-worktrees.js index 2b5f7e207..78401b94c 100644 --- a/src/main/projects/project-delete-worktrees.js +++ b/src/main/projects/project-delete-worktrees.js @@ -2,6 +2,7 @@ const path = require('node:path'); const deletion = require('../../../worktree-delete'); +const { PROJECT_DELETE_WORKTREE_INSPECTION_TIMEOUT_MS } = require('../../../public/setting-defaults'); const { canonicalPath, fail } = require('./project-delete-identity'); function createProjectDeleteWorktrees({ runGit, readActivity, startProcessReads = () => {}, now = Date.now }) { @@ -20,7 +21,7 @@ function createProjectDeleteWorktrees({ runGit, readActivity, startProcessReads return result; } finally { clearTimeout(timer); } } - async function preview(project, budget) { + async function preview(project, budget, prepareProcessReads = () => {}) { if (project.alias !== null) throw fail('WORKTREE_UNAVAILABLE', 'Remote worktree removal is unavailable.'); check(budget); if (budget.worktreePaths?.length === 0) return []; @@ -51,6 +52,7 @@ function createProjectDeleteWorktrees({ runGit, readActivity, startProcessReads let activities, activityError; if (group.length) { try { + prepareProcessReads(project, inspectionBudget); activities = await bounded(() => readActivity({ ...project, worktreePaths: group.map(row => row.path) }, inspectionBudget), inspectionBudget); for (const candidate of activities.candidates || []) budget.reportCandidate?.(candidate); } @@ -84,10 +86,10 @@ function createProjectDeleteWorktrees({ runGit, readActivity, startProcessReads return rows; } async function remove(project, selected, record) { - const budget = { signal: new AbortController().signal, deadline: now() + 15000, limit: 20000 }; + const controller = new AbortController(); + const budget = { signal: controller.signal, deadline: now() + PROJECT_DELETE_WORKTREE_INSPECTION_TIMEOUT_MS, limit: 20000 }; try { - startProcessReads(project, budget); - const current = await preview(project, { ...budget, worktreePaths: selected.map(row => row.path), selectedWorktrees: selected.map(row => row.path) }); + const current = await preview(project, { ...budget, worktreePaths: selected.map(row => row.path), selectedWorktrees: selected.map(row => row.path) }, startProcessReads); for (const row of selected) { const fresh = current.find(item => item.path === row.path); if (!fresh?.removable || fresh.main || fresh.projectDirectory || fresh.fingerprint !== row.fingerprint) { @@ -97,18 +99,20 @@ function createProjectDeleteWorktrees({ runGit, readActivity, startProcessReads } } catch (error) { record({ state: 'refused', error: error.message }); return false; - } + } finally { controller.abort(); } for (const row of selected) { let result, attempted = false; try { result = await deletion.removeWorktree(row.path, project.projectPath, row, async () => { - const removalBudget = { ...budget, signal: new AbortController().signal, deadline: now() + 15000, + const removalController = new AbortController(); + const removalBudget = { ...budget, signal: removalController.signal, deadline: now() + PROJECT_DELETE_WORKTREE_INSPECTION_TIMEOUT_MS, worktreePaths: [row.path], selectedWorktrees: [row.path] }; - startProcessReads(project, removalBudget); - const current = await preview(project, removalBudget); - const fresh = current.find(item => item.path === row.path); - if (!fresh?.removable || fresh.main || fresh.projectDirectory) throw fail('WORKTREE_UNAVAILABLE', fresh?.reason || 'Worktree registration changed.'); - return fresh; + try { + const current = await preview(project, removalBudget, startProcessReads); + const fresh = current.find(item => item.path === row.path); + if (!fresh?.removable || fresh.main || fresh.projectDirectory) throw fail('WORKTREE_UNAVAILABLE', fresh?.reason || 'Worktree registration changed.'); + return fresh; + } finally { removalController.abort(); } }, async args => { attempted = true; return runGit(args); }); } catch (error) { result = { ok: false, error: error.message }; } record({ path: row.path, state: result.ok ? 'removed' : attempted ? 'failed' : 'refused', error: result.error }); diff --git a/test/dom-project-delete.test.js b/test/dom-project-delete.test.js index 066427c58..45f64519d 100644 --- a/test/dom-project-delete.test.js +++ b/test/dom-project-delete.test.js @@ -109,7 +109,7 @@ for (const selected of [0, 2]) for (const settles of [true, false]) test(`pendin const worktrees = Array.from({ length: 2 }, (_, i) => ({ path: 'C:/linked-' + i, removable: true, fingerprint: 'stable', sessions: [], dirty: [] })); const h = setup(t, { worktrees }), timers = new Map(), applied = []; const base = 3 * 20000 + 2 * 10000 + 60000 + 60000 + 70000 + 10000 + 3 * 10000 + 15000; - const ceiling = base + (selected ? 15000 + selected * (15000 + 120000) : 0); + const ceiling = base + (selected ? 15000 + selected * (15000 + 5000 + 120000 + 15000) : 0); const settleAt = selected ? ceiling - 1000 : 130000; let time = 0, id = 0, finished = false; h.w.Date.now = () => time; diff --git a/test/project-action-harness.js b/test/project-action-harness.js index ca4a5145a..8ba4fcde8 100644 --- a/test/project-action-harness.js +++ b/test/project-action-harness.js @@ -25,6 +25,7 @@ function loadProjectActionHandlers(overrides = {}) { const start = source.indexOf('// --- IPC: remap-project ---'); const end = source.indexOf('// --- IPC: get-projects ---', start); const context = vm.createContext({ + ...require('../public/setting-defaults'), fs, path, encodeProjectPath, isPanelShellSession, require: require('node:module').createRequire(path.join(__dirname, '../main.js')), ipcMain: { handle: (name, handler) => handlers.set(name, handler) }, diff --git a/test/project-delete-worktrees.test.js b/test/project-delete-worktrees.test.js index 638f40b4b..51847efaf 100644 --- a/test/project-delete-worktrees.test.js +++ b/test/project-delete-worktrees.test.js @@ -489,7 +489,64 @@ function gitFixture(t) { const project = { alias: null, projectPath: root.replaceAll('\\', '/').toLowerCase() }; if (process.platform !== 'win32') project.projectPath = root; const budget = () => ({ signal: new AbortController().signal, deadline: Date.now() + 15000, limit: 20000 }); - return { root, target, kept, state, commands, adapter, project, budget }; + return { root, target, kept, state, commands, adapter, project, budget, runGit }; +} + +for (const stage of ['preflight', 'final', 'reread']) { + test(`E ${stage} inspection aborts both process reads before returning`, async t => { + const f = gitFixture(t); + const selected = (await f.adapter.preview(f.project, f.budget())).find(row => path.resolve(row.path) === f.target); + const signals = [], pending = new Set(); + const hold = signal => new Promise(resolve => { + pending.add(resolve); + signal.addEventListener('abort', () => { pending.delete(resolve); resolve({ code: 0, stdout: '[]', map: null }); }, { once: true }); + }); + const runtime = require('../src/main/projects/project-delete-main').createProjectDeleteRuntime({ + homeDir: f.root, runClaude: (_args, opts) => hold(opts.signal), + cliSessionState: { readProcessTableSnapshot: (_deadline, opts) => hold(opts.signal) }, + }); + let inspections = 0; + const adapter = implementation.createProjectDeleteWorktrees({ + runGit: async args => { + if (stage === 'reread' && args.includes('remove')) throw new Error('Git refused'); + return f.runGit(args); + }, + startProcessReads: (project, budget) => { + signals.push(budget.signal); + runtime.startProcessReads(project, budget); + }, + readActivity: async () => ({ complete: ++inspections < ({ preflight: 1, final: 2, reread: 3 })[stage], ...f.state }), + }); + t.after(() => { + for (const resolve of pending) resolve({ code: 0, stdout: '[]', map: null }); + }); + assert.equal(await adapter.remove(f.project, [selected], () => {}), false); + assert.equal(signals.length, ({ preflight: 1, final: 2, reread: 3 })[stage]); + assert.ok(signals.every(signal => signal.aborted), 'every completed inspection must abort its process-read signal'); + assert.equal(pending.size, 0, 'neither Claude nor process-table reads may remain pending'); + }); +} + +for (const stage of ['preflight', 'final']) for (const reason of ['list error', 'ineligible']) { + test(`E ${stage} ${reason} does not start unnecessary process reads`, async t => { + const f = gitFixture(t); + const selected = (await f.adapter.preview(f.project, f.budget())).find(row => path.resolve(row.path) === f.target); + let lists = 0, reads = 0; + const adapter = implementation.createProjectDeleteWorktrees({ + runGit: async args => { + if (args.includes('list') && ++lists === (stage === 'preflight' ? 1 : 2)) { + if (reason === 'list error') throw new Error('Git list unavailable'); + return `worktree ${selected.path}\nHEAD abc\n\n`; + } + return f.runGit(args); + }, + startProcessReads: () => { reads++; }, + readActivity: async () => ({ complete: true, ...f.state }), + }); + assert.equal(await adapter.remove(f.project, [selected], () => {}), false); + assert.equal(reads, stage === 'preflight' ? 0 : 1, 'ineligible or unreadable registration must not start Claude or table reads'); + assert.equal(f.commands.some(args => args.includes('remove')), false); + }); } test('E shared removal with a controlled Git port discovery lists main, branch, dirty/untracked bytes; removes exactly the reviewed linked directory', async t => { diff --git a/test/session-index-sequences.test.js b/test/session-index-sequences.test.js index ad32e4ca7..d7b4039db 100644 --- a/test/session-index-sequences.test.js +++ b/test/session-index-sequences.test.js @@ -23,6 +23,7 @@ function handler(name, deps) { assert.ok(registration, name); let captured; const context = vm.createContext({ ...deps, writer: memoryWriter(deps), + ...require('../public/setting-defaults'), spawnChild: require('./project-action-harness').spawnFromExec(deps.execFile), worktreeDelete: require('../worktree-delete'), activeSessions: new Map(), cliSessionState: { getSidebarDescriptors: () => [] }, diff --git a/test/worktree-delete-safety.test.js b/test/worktree-delete-safety.test.js index e293a9271..98c53bf94 100644 --- a/test/worktree-delete-safety.test.js +++ b/test/worktree-delete-safety.test.js @@ -106,6 +106,7 @@ test('worktree removal has a longer timeout than preview Git calls', async () => const source = fs.readFileSync(path.join(__dirname, '../main.js'), 'utf8'); const options = []; const context = vm.createContext({ localGitEnv: () => ({}), + ...require('../public/setting-defaults'), execFile: (_exe, _args, opts, callback) => { options.push(opts); callback(null, '', ''); } }); vm.runInContext(source.slice(source.indexOf('function worktreeGit('), source.indexOf('async function worktreeDeletionStatus(')), context, { filename: path.join(__dirname, '../main.js') }); diff --git a/test/worktree-delete.test.js b/test/worktree-delete.test.js index 3558381e6..8b73306a8 100644 --- a/test/worktree-delete.test.js +++ b/test/worktree-delete.test.js @@ -14,7 +14,8 @@ test('Git removal timeout follows the subcommand after leading options, never a const filename = path.join(__dirname, '../main.js'); const source = fs.readFileSync(filename, 'utf8'); const timeouts = []; - const context = vm.createContext({ localGitEnv: () => ({}), execFile: (_exe, _args, options, cb) => { + const defaults = require('../public/setting-defaults'); + const context = vm.createContext({ ...defaults, localGitEnv: () => ({}), execFile: (_exe, _args, options, cb) => { timeouts.push(options.timeout); cb(null, '', ''); } }); vm.runInContext(require('./app-source').extractFunction(source, 'worktreeGit'), context, { filename }); @@ -22,6 +23,11 @@ test('Git removal timeout follows the subcommand after leading options, never a await context.worktreeGit(['-c', 'x=y', '-C', '/repo', 'worktree', 'remove', '--', '/linked']); await context.worktreeGit(['-C', '/repo', 'worktree', 'list', 'remove']); assert.deepEqual(timeouts, [15000, 120000, 15000]); + context.PROJECT_DELETE_WORKTREE_INSPECTION_TIMEOUT_MS = 17000; + context.PROJECT_DELETE_WORKTREE_REMOVE_TIMEOUT_MS = 125000; + await context.worktreeGit(['worktree', 'list', '--porcelain']); + await context.worktreeGit(['worktree', 'remove', '--', '/linked']); + assert.deepEqual(timeouts.slice(3), [17000, 125000], 'Git must use the shared timeout bindings'); }); function fixture() { diff --git a/worktree-delete.js b/worktree-delete.js index 3f3e4e28d..baaf9b1e2 100644 --- a/worktree-delete.js +++ b/worktree-delete.js @@ -5,10 +5,10 @@ const path = require('node:path'); const fs = require('node:fs'); const { StringDecoder } = require('node:string_decoder'); const { resolveOnDisk } = require('./src/main/shared/resolve-path-on-disk'); +const { DIRECTORY_SCAN_MS } = require('./public/setting-defaults'); const HASH_LIMIT = 512 * 1024 * 1024; const DIRECTORY_LIMIT = 200000; -const DIRECTORY_SCAN_MS = 5000; function within(root, candidate) { const relative = path.relative(root, candidate);