Skip to content

The ultimate harness for coding agents and beyond. All your agents. All your machines. One command center. Start with code, then follow your curiosity and build across disciplines: CAD, circuits, robots, games and music.

Choose session and worktree data in the Monitor Delete dialog (#603)

Dee604e06fbdfc3
diff --git a/cli/src/backendSocket.spec.ts b/cli/src/backendSocket.spec.ts
index 783ca6ad2..c3cd46ae5 100644
--- a/cli/src/backendSocket.spec.ts
+++ b/cli/src/backendSocket.spec.ts
@@ -171,6 +171,14 @@ describe('reviewed permanent deletion RPCs', () => {
expect(frames.filter(f => f.payload.error === 'INVALID_DELETE_REQUEST')).toHaveLength(3)
await internals.dispatchDown({ type, payload: { ...payload, mode: 'delete', reviewId: 'review', path: '/reviewed', discardChanges: true } }, 'local:purge', 'local')
expect(request).toHaveBeenCalledWith(expect.objectContaining({ reviewId: 'review', path: '/reviewed', discardChanges: true }))
+ request.mockClear()
+ await internals.dispatchDown({ type, payload: { ...payload, mode: 'describe' } }, 'local:purge', 'local')
+ expect(request).toHaveBeenCalledTimes(type === 'agent_worktree_delete' ? 1 : 0)
+ request.mockClear()
+ await internals.dispatchDown({ type, payload: { ...payload, mode: 'delete', reviewId: 'review', choices: { sessionData: false, worktreeData: 'yes' } } }, 'local:purge', 'local')
+ expect(request).not.toHaveBeenCalled()
+ await internals.dispatchDown({ type, payload: { ...payload, includeWorktree: true, choices: { sessionData: false, worktreeData: true } } }, 'local:purge', 'local')
+ expect(request).toHaveBeenCalledWith(expect.objectContaining({ includeWorktree: true, choices: { sessionData: false, worktreeData: true } }))
await socket.stop()
})
})
diff --git a/cli/src/backendSocket.ts b/cli/src/backendSocket.ts
index 25216908d..c934b0c52 100644
--- a/cli/src/backendSocket.ts
+++ b/cli/src/backendSocket.ts
@@ -3106,19 +3106,27 @@ export class BackendSocket {
case 'agent_purge': {
if (!local && this.e2ee.sessionRole(connId) !== 'web') { reply(type, requestId, { error: 'OWNER_REQUIRED' }); return }
if (!this.purgeAgentService) { reply(type, requestId, { error: 'UNSUPPORTED' }); return }
- const { agentId, sessionId, createdAt, mode, reviewId, path, discardChanges } = payload
+ const { agentId, sessionId, createdAt, mode, reviewId, path, discardChanges, choices, includeWorktree } = payload
+ const selected = choices && typeof choices === 'object' ? choices as Record<string, unknown> : null
if (typeof agentId !== 'string' || !(sessionId === null || typeof sessionId === 'string')
|| typeof createdAt !== 'number' || !Number.isFinite(createdAt)
- || (mode !== 'inspect' && mode !== 'delete') || (mode === 'delete' && typeof reviewId !== 'string')) {
+ || (mode !== 'inspect' && mode !== 'delete' && !(type === 'agent_worktree_delete' && mode === 'describe'))
+ || (mode === 'delete' && typeof reviewId !== 'string')
+ || (choices !== undefined && (!selected
+ || typeof selected.sessionData !== 'boolean' || typeof selected.worktreeData !== 'boolean'))) {
reply(type, requestId, { error: 'INVALID_DELETE_REQUEST' }); return
}
- const operation = type === 'agent_worktree_delete' ? this.purgeAgentService.worktreeRequest.bind(this.purgeAgentService) : this.purgeAgentService.request.bind(this.purgeAgentService)
const deletion = { agentId, sessionId, createdAt, mode: mode as 'inspect' | 'delete',
...(typeof reviewId === 'string' ? { reviewId } : {}),
- ...(typeof path === 'string' ? { path } : {}), discardChanges: discardChanges === true }
- void operation(deletion)
+ ...(typeof path === 'string' ? { path } : {}), discardChanges: discardChanges === true,
+ includeWorktree: includeWorktree === true,
+ ...(selected ? { choices: { sessionData: selected.sessionData as boolean, worktreeData: selected.worktreeData as boolean } } : {}) }
+ const operation = type === 'agent_worktree_delete'
+ ? this.purgeAgentService.worktreeRequest({ ...deletion, mode: mode as 'describe' | 'inspect' | 'delete' })
+ : this.purgeAgentService.request(deletion)
+ void operation
.then(result => {
- if (result.deleted === true) void this.harnessStorageReader([], true)
+ if (result.deleted === true || result.worktreeDeleted === true) void this.harnessStorageReader([], true)
reply(type, requestId, result)
}, () => reply(type, requestId, { error: 'DELETE_FAILED' }))
return
diff --git a/cli/src/lib/purgeAgentService.spec.ts b/cli/src/lib/purgeAgentService.spec.ts
index cc2501662..b956d05ac 100644
--- a/cli/src/lib/purgeAgentService.spec.ts
+++ b/cli/src/lib/purgeAgentService.spec.ts
@@ -1,5 +1,6 @@
-import { existsSync, linkSync, mkdirSync, mkdtempSync, renameSync, rmSync, symlinkSync, writeFileSync } from 'node:fs'
+import { existsSync, linkSync, mkdirSync, mkdtempSync, realpathSync, renameSync, rmSync, symlinkSync, writeFileSync } from 'node:fs'
import { tmpdir } from 'node:os'
+import { execFileSync } from 'node:child_process'
import { join } from 'node:path'
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import { registry, type RegisteredSession } from './registry.js'
@@ -39,6 +40,95 @@ afterEach(() => { for (const row of registry.list()) registry.removeAgent(row.ag
const review = () => service.request({ ...target, mode: 'inspect' })
const remove = (reviewId: unknown) => service.request({ ...target, mode: 'delete', reviewId: String(reviewId) })
+it('workspace inspection is read-only and binds the selected session identity', async () => {
+ expect(await service.worktreeRequest({ ...target, mode: 'describe' })).toMatchObject({ workspace: { kind: 'folder', path: realpathSync(session.cwd!), canDelete: false } })
+ expect(await service.worktreeRequest({ ...target, sessionId: 'different', mode: 'describe' })).toHaveProperty('error')
+ expect(stop).not.toHaveBeenCalled(); expect(deleted).not.toHaveBeenCalled()
+ expect(existsSync(session.transcriptPath!)).toBe(true)
+})
+
+describe('selected session and worktree cleanup', () => {
+ const choices = (sessionData: boolean, worktreeData: boolean) => ({ sessionData, worktreeData })
+ const treeReview = () => ({ path: join(root, 'temporary'), main: session.cwd!, branch: 'feature', head: 'commit',
+ bytes: 1e9, dirty: false, changes: [], signature: 'tree-review', dev: 1, ino: 2 })
+ it('deletes both real selected stores while keeping the main checkout and committed branch', async () => {
+ const main = session.cwd!, tree = join(root, 'real-worktree')
+ const git = (...args: string[]) => execFileSync('git', ['-C', main, '-c', 'user.name=Test', '-c', '[email protected]',
+ '-c', 'commit.gpgsign=false', '-c', 'core.hooksPath=/dev/null', ...args], { encoding: 'utf8' })
+ git('init', '--quiet', '-b', 'main'); git('add', '.'); git('commit', '--quiet', '-m', 'main project')
+ git('worktree', 'add', '--quiet', '-b', 'feature', tree)
+ session.cwd = tree
+ const plan = await service.request({ ...target, mode: 'inspect', includeWorktree: true })
+ expect(plan).toMatchObject({ choices: { sessionData: { available: true }, worktreeData: { available: true, path: realpathSync(tree) } } })
+ expect(await service.request({ ...target, mode: 'delete', reviewId: String(plan.reviewId), choices: choices(true, true), path: realpathSync(tree) })).toMatchObject({ deleted: true, worktreeDeleted: true, sessionDeleted: true })
+ expect(existsSync(tree)).toBe(false); expect(existsSync(session.transcriptPath!)).toBe(false)
+ expect(existsSync(join(main, 'project.txt'))).toBe(true)
+ expect(git('show', 'feature:project.txt')).toBe('project files stay')
+ })
+ it.each([[true, false], [false, true], [true, true]])('only deletes the selected data: session %s, worktree %s', async (sessionData, worktreeData) => {
+ const tree = treeReview()
+ vi.spyOn(worktrees, 'inspectWorktree').mockResolvedValue(tree)
+ const eraseTree = vi.spyOn(worktrees, 'removeReviewedWorktree').mockImplementation(async () => {
+ expect(service.busy(session.agentId)).toBe(true)
+ expect(service.blocksFolder(tree.path)).toBe(true)
+ expect(stopped.beginResume(session.agentId)).toBeNull()
+ })
+ const plan = await service.request({ ...target, mode: 'inspect', includeWorktree: true })
+ expect(plan).toMatchObject({ choices: { sessionData: { available: true, paths: [realpathSync(session.transcriptPath!)] }, worktreeData: { available: true, path: tree.path } } })
+ expect(stop).not.toHaveBeenCalled(); expect(eraseTree).not.toHaveBeenCalled()
+ const result = await service.request({ ...target, mode: 'delete', reviewId: String(plan.reviewId), choices: choices(sessionData, worktreeData), path: tree.path })
+ expect(result).toMatchObject({ deleted: true, sessionDeleted: sessionData, worktreeDeleted: worktreeData, historyKept: !sessionData })
+ expect(stop).toHaveBeenCalledOnce()
+ expect(eraseTree).toHaveBeenCalledTimes(worktreeData ? 1 : 0)
+ expect(existsSync(session.transcriptPath!)).toBe(!sessionData)
+ expect(existsSync(join(session.cwd!, 'project.txt'))).toBe(true)
+ expect(stopped.get(session.agentId) !== null).toBe(!sessionData)
+ })
+ it('refuses unreviewed, protected, empty or dirty selections before stopping', async () => {
+ for (const scenario of ['legacy', 'protected', 'empty', 'dirty', 'path']) {
+ vi.restoreAllMocks()
+ const tree = { ...treeReview(), dirty: scenario === 'dirty', changes: ['?? draft'] }
+ vi.spyOn(worktrees, 'inspectWorktree').mockImplementation(async () => {
+ if (scenario === 'protected') throw new Error('Main project folder is protected.')
+ return tree
+ })
+ const eraseTree = vi.spyOn(worktrees, 'removeReviewedWorktree')
+ const plan = await service.request({ ...target, mode: 'inspect', includeWorktree: scenario !== 'legacy' })
+ const result = await service.request({ ...target, mode: 'delete', reviewId: String(plan.reviewId), choices: choices(false, scenario !== 'empty'), path: scenario === 'path' ? '/wrong' : tree.path })
+ expect(result).toHaveProperty('error')
+ expect(stop).not.toHaveBeenCalled(); expect(eraseTree).not.toHaveBeenCalled()
+ expect(existsSync(session.transcriptPath!)).toBe(true)
+ }
+ })
+ it('can clean a worktree while unavailable conversation data is kept', async () => {
+ const tree = treeReview()
+ vi.spyOn(worktrees, 'inspectWorktree').mockResolvedValue(tree)
+ vi.spyOn(worktrees, 'removeReviewedWorktree').mockResolvedValue()
+ const originalPath = session.transcriptPath!
+ session.transcriptPath = join(root, 'unverified-history')
+ const plan = await service.request({ ...target, mode: 'inspect', includeWorktree: true })
+ expect(plan).toMatchObject({ choices: { sessionData: { available: false }, worktreeData: { available: true } } })
+ expect(await service.request({ ...target, mode: 'delete', reviewId: String(plan.reviewId), choices: choices(false, true), path: tree.path })).toMatchObject({ deleted: true, historyKept: true })
+ expect(existsSync(originalPath)).toBe(true)
+ })
+ it('reports completed worktree deletion when subsequent history deletion fails, without retrying', async () => {
+ const tree = treeReview()
+ vi.spyOn(worktrees, 'inspectWorktree').mockResolvedValue(tree)
+ const eraseTree = vi.spyOn(worktrees, 'removeReviewedWorktree').mockImplementation(async () => {
+ renameSync(session.transcriptPath!, session.transcriptPath! + '.old')
+ writeFileSync(session.transcriptPath!, 'replacement must stay')
+ })
+ const plan = await service.request({ ...target, mode: 'inspect', includeWorktree: true })
+ const request = { ...target, mode: 'delete' as const, reviewId: String(plan.reviewId), choices: choices(true, true), path: tree.path }
+ const result = await service.request(request)
+ expect(result).toMatchObject({ error: 'DELETE_REFUSED', worktreeDeleted: true })
+ expect(result.detail).toContain('worktree was deleted')
+ expect(existsSync(session.transcriptPath!)).toBe(true)
+ expect(await service.request(request)).toHaveProperty('error')
+ expect(eraseTree).toHaveBeenCalledOnce()
+ })
+})
+
it('previews without stopping, then deletes only reviewed history and checkpoints', async () => {
await checkpoints.save(session, { screen: 'saved terminal' })
const files = checkpoints.deletionFiles(session)
diff --git a/cli/src/lib/purgeAgentService.ts b/cli/src/lib/purgeAgentService.ts
index c1d36a21d..a40ca03bc 100644
--- a/cli/src/lib/purgeAgentService.ts
+++ b/cli/src/lib/purgeAgentService.ts
@@ -11,7 +11,7 @@ import { builtinSqlite, sqliteReadAll } from './sqliteRead.js'
import type { StoppedAgentStore } from './stoppedAgents.js'
import type { SessionCheckpointStore } from './sessionCheckpoint.js'
import type { StopAgentOptions } from './stopAgentService.js'
-import { inspectWorktree, removeReviewedWorktree, type WorktreeReview } from './worktreeDeletion.js'
+import { inspectWorkspace, inspectWorktree, removeReviewedWorktree, type WorktreeReview } from './worktreeDeletion.js'
const exec = promisify(execFile)
const identity = (s: RegisteredSession) => JSON.stringify([s.agentId, s.engine, s.sessionId,
@@ -150,7 +150,11 @@ export async function sessionDataBytes(s: RegisteredSession, checkpoints: Sessio
} catch { return null }
}
-export interface PurgeRequest { agentId: string; sessionId: string | null; createdAt: number; mode: 'inspect' | 'delete'; reviewId?: string }
+export interface PurgeRequest {
+ agentId: string; sessionId: string | null; createdAt: number; mode: 'inspect' | 'delete'; reviewId?: string
+ includeWorktree?: boolean; choices?: { sessionData: boolean; worktreeData: boolean }; path?: string; discardChanges?: boolean
+}
+export type WorktreeRequest = Omit<PurgeRequest, 'mode'> & { mode: 'describe' | 'inspect' | 'delete'; path?: string; discardChanges?: boolean }
export interface PurgeDeps {
live(id: string): RegisteredSession | undefined
sessions(): RegisteredSession[]
@@ -165,7 +169,8 @@ export interface PurgeDeps {
}
export class PurgeAgentService {
- private readonly reviews = new Map<string, { session: RegisteredSession; signature: string; expires: number; history: History }>()
+ private readonly reviews = new Map<string, { session: RegisteredSession; signature: string; expires: number;
+ history: History | null; worktree?: WorktreeReview; includesWorktree: boolean }>()
private readonly jobs = new Set<string>()
private readonly worktreeJobs = new Map<string, string>()
private readonly worktreeReviews = new Map<string, { session: RegisteredSession; signature: string; expires: number; worktree: WorktreeReview }>()
@@ -178,13 +183,18 @@ export class PurgeAgentService {
return [...this.worktreeJobs.values()].some(root => path === root || path.startsWith(root + sep) || root.startsWith(path + sep))
}
- async worktreeRequest(request: PurgeRequest & { path?: string; discardChanges?: boolean }): Promise<Record<string, unknown>> {
+ async worktreeRequest(request: WorktreeRequest): Promise<Record<string, unknown>> {
let stopped = false
try {
if (this.busy(request.agentId)) throw new Error('Wait for the current harness operation to finish.')
const now = this.deps.now?.() ?? Date.now()
for (const [id, review] of this.worktreeReviews) if (review.expires <= now) this.worktreeReviews.delete(id)
const current = this.current(request, false)
+ if (request.mode === 'describe') {
+ const signature = identity(current), workspace = await inspectWorkspace(current, this.deps.sessions())
+ if (identity(this.current(request, false)) !== signature) throw new Error('The harness changed. Reopen Inspect to check its workspace again.')
+ return { workspace }
+ }
if (request.mode === 'inspect') {
const signature = identity(current), worktree = await inspectWorktree(current, this.deps.sessions())
if (identity(this.current(request, false)) !== signature) throw new Error('The harness changed. Review its worktree again.')
@@ -220,7 +230,7 @@ export class PurgeAgentService {
}
}
- private current(request: PurgeRequest, deletingHistory = true): RegisteredSession {
+ private current(request: Pick<PurgeRequest, 'agentId' | 'sessionId' | 'createdAt'>, deletingHistory = true): RegisteredSession {
const s = this.deps.live(request.agentId) ?? this.deps.stopped.get(request.agentId)
if (!s || (s.sessionId || null) !== request.sessionId || s.registeredAt !== request.createdAt) return fail('This harness changed. Refresh and review deletion again.')
if (s.dsh === 'autonomous/harness-monitor' || s.launch?.state === 'starting') return fail('This harness cannot be deleted from this monitor.')
@@ -232,27 +242,56 @@ export class PurgeAgentService {
}
async request(request: PurgeRequest): Promise<Record<string, unknown>> {
- let stopped = false
+ let stopped = false, worktreeDeleted = false, sessionDeleted = false
+ const sessionData = request.choices ? request.choices.sessionData === true : true
+ const worktreeData = request.choices?.worktreeData === true
try {
if (this.busy(request.agentId)) return { error: 'DELETE_IN_PROGRESS', detail: 'This harness is already being deleted.' }
const now = this.deps.now?.() ?? Date.now()
for (const [id, review] of this.reviews) if (review.expires <= now) this.reviews.delete(id)
- const current = this.current(request)
+ const current = this.current(request, request.mode === 'inspect' ? !request.includeWorktree : sessionData)
if (request.mode === 'inspect') {
const signature = identity(current)
- const history = await (this.deps.inspect ?? inspectNativeHistory)(current)
- if (identity(this.current(request)) !== signature) return fail('The harness changed while checking its data. Try again.')
- const checkpointBytes = this.deps.checkpoints.deletionFiles(current).reduce((n, path) => n + file(path).bytes, 0)
+ let history: History | null = null, checkpointFiles: File[] = [], historyReason = ''
+ try {
+ this.current(request)
+ history = await (this.deps.inspect ?? inspectNativeHistory)(current)
+ checkpointFiles = this.deps.checkpoints.deletionFiles(current).map(file)
+ } catch (error) {
+ if (!request.includeWorktree) throw error
+ history = null
+ historyReason = error instanceof Error ? error.message : 'Session data could not be verified.'
+ }
+ let worktree: WorktreeReview | undefined, worktreeReason = ''
+ if (request.includeWorktree) {
+ try { worktree = await inspectWorktree(current, this.deps.sessions()) }
+ catch (error) { worktreeReason = error instanceof Error ? error.message : 'The worktree could not be verified.' }
+ }
+ if (identity(this.current(request, !request.includeWorktree)) !== signature) return fail('The harness changed while checking its data. Try again.')
+ const sessionBytes = history?.bytes == null ? null : history.bytes + checkpointFiles.reduce((n, f) => n + f.bytes, 0)
+ const paths = history ? [history.file?.path ?? history.missingFile ?? history.database, ...checkpointFiles.map(f => f.path)].filter(Boolean) : []
const reviewId = randomUUID()
if (this.reviews.size >= 64) this.reviews.delete(this.reviews.keys().next().value!)
- this.reviews.set(reviewId, { session: { ...current }, signature, history, expires: now + 120_000 })
- return { reviewId, sessionBytes: history.bytes == null ? null : history.bytes + checkpointBytes,
- sharedStore: !!history.database, workspaceKept: true, workspacePath: current.cwd }
+ this.reviews.set(reviewId, { session: { ...current }, signature, history, worktree, includesWorktree: request.includeWorktree === true, expires: now + 120_000 })
+ return { reviewId, sessionBytes, sessionPaths: paths,
+ sharedStore: !!history?.database, workspaceKept: true, workspacePath: current.cwd,
+ ...(request.includeWorktree ? { choices: {
+ sessionData: { available: history !== null, bytes: sessionBytes, paths, sharedStore: !!history?.database, reason: historyReason },
+ worktreeData: { available: !!worktree, path: worktree?.path ?? current.cwd, bytes: worktree?.bytes ?? null,
+ mainPath: worktree?.main, branch: worktree?.branch, dirty: worktree?.dirty ?? false, changes: worktree?.changes ?? [], reason: worktreeReason },
+ } } : {}) }
}
const review = this.reviews.get(request.reviewId ?? '')
this.reviews.delete(request.reviewId ?? '')
if (!review || review.signature !== identity(current)) return fail('The deletion review expired or changed. Review this harness again.')
+ if (!sessionData && !worktreeData) return fail('Select session data, worktree data, or both.')
+ if (sessionData && !review.history) return fail('Session data was not verified. Review this harness again.')
+ if (worktreeData && (!review.includesWorktree || !review.worktree || request.path !== review.worktree.path)) {
+ return fail('Only the reviewed worktree folder can be deleted. Review it again.')
+ }
+ if (worktreeData && review.worktree?.dirty && !request.discardChanges) return fail('Confirm discarding the listed uncommitted files before deleting this worktree.')
this.jobs.add(request.agentId)
+ if (worktreeData) this.worktreeJobs.set(request.agentId, review.worktree!.path)
try {
if (this.deps.live(request.agentId)) {
await this.deps.stop(request.agentId, { current: () => {
@@ -262,29 +301,40 @@ export class PurgeAgentService {
}
if (this.deps.live(request.agentId)) return fail('The harness did not stop. No session data was deleted.')
stopped = true
- const saved = this.current(request)
- if (conversation(saved) !== conversation(review.session) || saved.transcriptPath !== review.session.transcriptPath) {
+ const saved = this.current(request, sessionData)
+ if (sessionData && (conversation(saved) !== conversation(review.session) || saved.transcriptPath !== review.session.transcriptPath)) {
return fail('The saved conversation changed while stopping. Review it before deleting.')
}
// Stop has saved its final archive. Reserve it while asynchronous native DB deletion runs.
const reservation = this.deps.stopped.beginResume(request.agentId)
if (!reservation) return fail('Another operation is using this saved harness. Nothing was deleted.')
try {
- const files = this.deps.checkpoints.deletionFiles(saved).map(file)
- let freedBytes = await (this.deps.erase ?? eraseNativeHistory)(review.history)
- for (const target of files) {
- const current = file(target.path)
- if (current.dev !== target.dev || current.ino !== target.ino) return fail('Saved session data changed. Some data may already have been deleted; refresh to check.')
- unlinkSync(target.path); freedBytes += current.bytes
+ const files = sessionData ? this.deps.checkpoints.deletionFiles(saved).map(file) : []
+ if (worktreeData) {
+ await removeReviewedWorktree(review.worktree!, saved, this.deps.sessions(), request.discardChanges === true)
+ worktreeDeleted = true
}
- this.deps.deleted(saved)
- this.deps.stopped.remove(request.agentId)
- return { deleted: true, freedBytes, sharedStore: !!review.history.database, workspaceKept: true }
+ let freedBytes = 0
+ if (sessionData) {
+ freedBytes = await (this.deps.erase ?? eraseNativeHistory)(review.history!)
+ for (const target of files) {
+ const current = file(target.path)
+ if (current.dev !== target.dev || current.ino !== target.ino) return fail('Saved session data changed. Some data may already have been deleted; refresh to check.')
+ unlinkSync(target.path); freedBytes += current.bytes
+ }
+ this.deps.deleted(saved)
+ this.deps.stopped.remove(request.agentId)
+ sessionDeleted = true
+ }
+ return { deleted: true, sessionDeleted, worktreeDeleted, freedBytes,
+ sharedStore: sessionData && !!review.history?.database, workspaceKept: !worktreeDeleted, historyKept: !sessionData, branchKept: true }
} finally { this.deps.stopped.finishResume(request.agentId, reservation) }
- } finally { this.jobs.delete(request.agentId) }
+ } finally { this.jobs.delete(request.agentId); this.worktreeJobs.delete(request.agentId) }
} catch (error) {
- return { error: 'DELETE_REFUSED', stopped,
+ return { error: 'DELETE_REFUSED', stopped, worktreeDeleted, sessionDeleted,
detail: (error instanceof Error ? error.message : 'Could not delete this harness.')
+ + (worktreeDeleted ? ' The worktree was deleted.' : '')
+ + (sessionDeleted ? ' Session data was deleted.' : worktreeDeleted && sessionData ? ' Session data deletion did not finish.' : '')
+ (stopped ? ' The harness is stopped; refresh before trying again.' : '') }
}
}
diff --git a/cli/src/lib/worktreeDeletion.spec.ts b/cli/src/lib/worktreeDeletion.spec.ts
index ca45918e4..c9d7e6714 100644
--- a/cli/src/lib/worktreeDeletion.spec.ts
+++ b/cli/src/lib/worktreeDeletion.spec.ts
@@ -5,7 +5,7 @@ import { join } from 'node:path'
import { promisify } from 'node:util'
import { afterEach, beforeEach, describe, expect, it } from 'vitest'
import type { RegisteredSession } from './registry.js'
-import { inspectWorktree, removeReviewedWorktree } from './worktreeDeletion.js'
+import { inspectWorkspace, inspectWorktree, removeReviewedWorktree } from './worktreeDeletion.js'
const exec = promisify(execFile)
describe('explicit worktree deletion', { timeout: 30_000 }, () => {
@@ -27,6 +27,21 @@ describe('explicit worktree deletion', { timeout: 30_000 }, () => {
})
afterEach(() => rm(root, { recursive: true, force: true }))
+ it('describes full working, worktree and main paths without changing files, including subfolders', async () => {
+ await mkdir(join(tree, 'src'))
+ expect(await inspectWorkspace({ ...session, cwd: join(tree, 'src') }, [session])).toMatchObject({
+ kind: 'worktree', path: join(tree, 'src'), worktreePath: tree, mainPath: repo, canDelete: true,
+ })
+ expect(await inspectWorkspace({ ...session, cwd: repo }, [])).toMatchObject({ kind: 'main', path: repo, mainPath: repo, canDelete: false })
+ expect(await inspectWorkspace({ ...session, cwd: root }, [])).toMatchObject({ kind: 'folder', path: root, canDelete: false })
+ expect(await inspectWorkspace({ ...session, cwd: join(root, 'missing') }, [])).toMatchObject({ kind: 'unavailable', canDelete: false })
+ const shared = await inspectWorkspace(session, [session, { ...session, agentId: 'other' }])
+ expect(shared).toMatchObject({ kind: 'worktree', worktreePath: tree, mainPath: repo, canDelete: false })
+ expect(shared.reason).toContain('Another harness')
+ expect(await exists(tree)).toBe(true)
+ expect(await git(repo, 'show', 'feature:source')).toBe('keep main')
+ })
+
it('removes the reviewed linked checkout and ignored output, retaining main and its branch', async () => {
await mkdir(join(tree, 'node_modules'))
await writeFile(join(tree, 'node_modules', 'package'), 'temporary dependencies')
diff --git a/cli/src/lib/worktreeDeletion.ts b/cli/src/lib/worktreeDeletion.ts
index 106020697..5eb3db38a 100644
--- a/cli/src/lib/worktreeDeletion.ts
+++ b/cli/src/lib/worktreeDeletion.ts
@@ -10,7 +10,7 @@ import type { RegisteredSession } from './registry.js'
const exec = promisify(execFile)
const within = (parent: string, path: string) => parent === path || path.startsWith(parent + sep)
async function git(cwd: string, args: string[]): Promise<string> {
- const env: NodeJS.ProcessEnv = { ...process.env, GIT_TERMINAL_PROMPT: '0', GIT_OPTIONAL_LOCKS: '0' }
+ const env: NodeJS.ProcessEnv = { ...process.env, GIT_TERMINAL_PROMPT: '0', GIT_OPTIONAL_LOCKS: '0', LC_ALL: 'C' }
for (const key of ['GIT_DIR', 'GIT_WORK_TREE', 'GIT_COMMON_DIR', 'GIT_INDEX_FILE', 'GIT_NAMESPACE', 'GIT_PREFIX']) delete env[key]
return (await exec('git', ['-c', 'core.fsmonitor=false', '-c', 'core.hooksPath=/dev/null', '-C', cwd, ...args],
{ env, timeout: 30_000, killSignal: 'SIGKILL', maxBuffer: 1024 * 1024 })).stdout.replace(/\r?\n$/, '')
@@ -20,6 +20,45 @@ export type WorktreeReview = {
dirty: boolean; changes: string[]; signature: string; dev: number; ino: number
}
+export type WorkspaceInspection = {
+ kind: 'main' | 'worktree' | 'folder' | 'unavailable'
+ path: string | null; worktreePath?: string; mainPath?: string
+ canDelete: boolean; reason: string
+}
+
+/** Read-only location and cleanup eligibility. No review token or deletion is created by Inspect. */
+export async function inspectWorkspace(s: RegisteredSession, sessions: readonly RegisteredSession[]): Promise<WorkspaceInspection> {
+ let path: string | null = s.cwd ?? null
+ try {
+ if (!path) throw new Error('No working folder')
+ path = await realpath(path)
+ let root: string
+ try { root = await realpath(await git(path, ['rev-parse', '--show-toplevel'])) }
+ catch (error) {
+ if (/not a git repository/i.test(String((error as { stderr?: string }).stderr))) {
+ return { kind: 'folder', path, canDelete: false, reason: 'This folder is not a Git worktree. Its files are kept.' }
+ }
+ throw error
+ }
+ const gitDir = await realpath(resolve(root, await git(root, ['rev-parse', '--git-dir'])))
+ const common = await realpath(resolve(root, await git(root, ['rev-parse', '--git-common-dir'])))
+ if (gitDir === common) {
+ return { kind: 'main', path, mainPath: root, canDelete: false, reason: 'This is the main project checkout. It cannot be deleted here.' }
+ }
+ const location = { kind: 'worktree' as const, path, worktreePath: root,
+ ...(basename(common) === '.git' ? { mainPath: dirname(common) } : {}) }
+ try {
+ const review = await inspectWorktree(s, sessions)
+ return { ...location, worktreePath: review.path, mainPath: review.main, canDelete: true,
+ reason: 'Selecting Worktree data in Delete removes this entire worktree folder after confirmation. The main project and branch are kept. Leave Session data unchecked to keep the conversation.' }
+ } catch (error) {
+ return { ...location, canDelete: false, reason: error instanceof Error ? error.message : 'Worktree cleanup is unavailable.' }
+ }
+ } catch {
+ return { kind: 'unavailable', path, canDelete: false, reason: 'The working folder could not be verified. Reopen Inspect to try again.' }
+ }
+}
+
export async function inspectWorktree(s: RegisteredSession, sessions: readonly RegisteredSession[]): Promise<WorktreeReview> {
if (!s.cwd) throw new Error('This harness has no working folder.')
const root = await realpath(await git(s.cwd, ['rev-parse', '--show-toplevel']))
@@ -27,7 +66,7 @@ export async function inspectWorktree(s: RegisteredSession, sessions: readonly R
const gitDir = await realpath(resolve(root, await git(root, ['rev-parse', '--git-dir'])))
const common = await realpath(resolve(root, await git(root, ['rev-parse', '--git-common-dir'])))
if (!folder.isDirectory() || !marker.isFile() || gitDir === common || basename(common) !== '.git') {
- throw new Error('This is the main project folder, not a temporary Git worktree. It cannot be deleted here.')
+ throw new Error('No separate worktree. This is the main project folder; it cannot be deleted here.')
}
const main = dirname(common)
if (within(root, main)) throw new Error('The main project is inside this folder. It cannot be deleted here.')
diff --git a/store/agents/harness-monitor/AGENTS.md b/store/agents/harness-monitor/AGENTS.md
index 18a95e9ee..4eb2e0854 100644
--- a/store/agents/harness-monitor/AGENTS.md
+++ b/store/agents/harness-monitor/AGENTS.md
@@ -39,9 +39,10 @@ that ID. Never silently switch to a paid model. The viewer includes an Assistant
OpenCode's `/models` command.
Never start another viewer: Harness already manages this one. For permanent deletion, direct the
-person to the table's Delete Harness confirmation (session data only) or Inspect → Delete Worktree
-(path, branch, size and uncommitted-change review). Do not use shell deletion to bypass these reviews.
-Never delete a main project folder, branch or another harness's files. Worktree cleanup keeps the
-conversation and branch; Delete Harness keeps workspace files. Shared database deletion may reuse
-space without shrinking the database file. Never imply all Workspace bytes are session data.
-Report actual tool results, including refusals and uncertain outcomes, without inventing activity.
+person to the table's Delete dialog. It offers separate Session data and Worktree data checkboxes,
+with sizes and full paths. The person can select either or both. Main folders and shared worktrees
+are protected; dirty worktrees require explicit consent to discard changes. Never use shell deletion
+to bypass these reviews. Inspect also shows the full working folder, worktree and main project paths.
+Unchecked session data, worktree files, and every main project and branch are kept. Shared database
+deletion may reuse space without shrinking the database file. Never imply all Workspace bytes are
+session data. Report actual tool results, including refusals and partial or uncertain outcomes.
diff --git a/store/agents/harness-monitor/README.md b/store/agents/harness-monitor/README.md
index 5ac97452f..3a871b438 100644
--- a/store/agents/harness-monitor/README.md
+++ b/store/agents/harness-monitor/README.md
@@ -17,20 +17,25 @@ opens Inspect. Freeze updates disables actions until live readings return.
Each row has **Stop Harness** and **Delete Harness** buttons:
-- Stop Harness ends running work and closes its panes, keeping history, configuration and files.
-- Delete Harness first previews the selected conversation's native history and Harness checkpoints
- on the owning daemon. Confirmation stops it, then permanently removes those files or supported
- database rows, search history, saved metadata and the retained harness. Project/worktree files
- stay. Some native stores have unsupported schemas or dependent conversations; deletion is refused
- rather than affecting other history. Shared database space becomes reusable but its file may not
- shrink immediately. Engine-wide caches and older conversations from `/clear` are not removed.
-- **Inspect → Delete Worktree…** is separate. Its review shows the exact checkout path, branch, full
- worktree size and uncommitted changes. Type the full path to confirm; dirty worktrees also require
- explicit consent to discard all uncommitted and untracked files. Ignored dependencies/build output
- are removed too. The owning daemon stops the selected harness, revalidates the checkout and uses
- `git worktree remove`. It keeps the main checkout, branch, commits and conversation history.
- Recreate the checkout to resume later. Main folders, locked worktrees, nested worktrees, checkouts
- used by other live or saved harnesses, and detached commits without a saved branch are protected.
+- **Stop** ends running work and closes its panes, keeping history, configuration and files.
+- **Delete** opens one confirmation directly from the row or Inspect. It shows two independent
+ checkboxes, each with its size and full path: **Session data** and **Worktree data**. Available
+ options start checked. Nothing is removed until the person confirms; neither option selected
+ disables Delete. Main project folders and worktrees used by another harness cannot be selected.
+- **Session data** removes only this conversation's verified native history and Harness checkpoints,
+ search history, saved metadata and retained harness. Unchecked worktree files stay. Some native
+ stores have unsupported schemas or dependent conversations; their session option is unavailable.
+ Shared database space becomes reusable but its file may not shrink immediately. Engine-wide
+ caches and older conversations from `/clear` are not removed.
+- **Worktree data** removes the exact reviewed checkout folder, including ignored dependencies and
+ build output. Dirty worktrees require explicit consent to discard uncommitted and untracked files.
+ The owning daemon stops the harness, revalidates the checkout and uses `git worktree remove`.
+ The main checkout, branch and commits stay. Unchecked session data remains as a stopped harness;
+ recreate the checkout to resume later. Locked or nested worktrees and detached commits without
+ a saved branch are protected. Selecting both removes the worktree first, then the session data;
+ if only part succeeds, the result says what was already removed and is never retried automatically.
+- **Inspect** prominently shows the full working folder, worktree path and main project path, with
+ copy buttons and an explanation of cleanup eligibility. Opening Inspect only reads these facts.
Deletion is one harness at a time, never automatic. Reviews expire after two minutes and are bound
to the machine, harness and conversation. Changed identities, paths or worktree status require a new
@@ -44,7 +49,7 @@ review. Cancel is the default. A lost response is uncertain and is never automat
| RAM | Process-tree resident memory, in rounded MB/GB. Shared pages can overlap. Nested harness roots are excluded from their parent. Shared Codex servers appear separately and count once. |
| GPU % | GPU use of the harness process tree. macOS reads IOAccelerator clients owned by each PID: Apple Silicon AppUsage and Intel/AMD accumulatedGPUTime counters. GPU nanoseconds divided by the sample interval give percent. Linux reads NVIDIA process utilization. Summed use can exceed 100% across contexts/devices. Initial samples, context changes, resets and unavailable drivers show —. Cloud inference is not local GPU use. |
| GPU memory | NVIDIA compute allocations on supported Linux drivers. macOS and unsupported counters show —. |
-| Workspace | Allocated disk space of the entire working folder (project, linked worktree or subfolder), from bounded `du` reads cached for one minute. Shared and nested canonical folders count once per machine in totals. Inspect reviews the full worktree root before deletion. |
+| Workspace | Allocated disk space of the entire working folder (project, linked worktree or subfolder), from bounded `du` reads cached for one minute. Shared and nested canonical folders count once per machine in totals. Delete reviews the full worktree root before deletion. |
| Session data | Allocated conversation-file and checkpoint bytes, or estimated conversation content within a shared native database plus checkpoints. Excludes project/worktree files. Cached for one minute; unsupported or unreadable stores show —. |
| Disk read/s / write/s | Physical process-tree I/O deltas from Linux /proc/<pid>/io. Restricted counters, resets and macOS show —. |
| Transcript | Individual conversation-file size when reported. Shared databases show —. |
diff --git a/store/agents/harness-monitor/lib/actions.mjs b/store/agents/harness-monitor/lib/actions.mjs
index e3e25c9ae..0d54ec671 100644
--- a/store/agents/harness-monitor/lib/actions.mjs
+++ b/store/agents/harness-monitor/lib/actions.mjs
@@ -95,23 +95,41 @@ export async function previewDelete(row, { list = listAgents, rpc = request } =
const current = await fresh(row, list)
if (!current.canDelete) return receipt(row, 'delete-review', current.unavailable || 'This harness cannot be deleted yet.')
const result = await rpc(row.machineId, 'agent_purge', {
- agentId: row.agentId, sessionId: row.sessionId, createdAt: row.createdAt, mode: 'inspect',
+ agentId: row.agentId, sessionId: row.sessionId, createdAt: row.createdAt, mode: 'inspect', includeWorktree: true,
})
if (!result.reviewId) return receipt(row, 'delete-review', 'The daemon did not confirm which session data would be deleted.')
+ if (!result.choices) return receipt(row, 'delete-review', 'Update Harness on the owning machine to choose session and worktree data separately.')
return { ...receipt(row, 'delete-review', 'Review permanent deletion.'), ...result, ok: true, refused: false }
} catch (error) { return receipt(row, 'delete-review', error.code === 'UNSUPPORTED' ? 'Update Harness on the owning machine to enable deletion.' : error.message) }
}
-export async function deleteHarness(row, { reviewId, rpc = request } = {}) {
+export async function deleteHarness(row, { reviewId, choices, path, discardChanges = false, rpc = request } = {}) {
try {
if (typeof reviewId !== 'string' || !reviewId) return receipt(row, 'delete', 'Review this harness before deleting it.')
+ if (!choices || typeof choices.sessionData !== 'boolean' || typeof choices.worktreeData !== 'boolean'
+ || (!choices.sessionData && !choices.worktreeData)) return receipt(row, 'delete', 'Select the data to delete first.')
const result = await rpc(row.machineId, 'agent_purge', {
- agentId: row.agentId, sessionId: row.sessionId, createdAt: row.createdAt, mode: 'delete', reviewId,
+ agentId: row.agentId, sessionId: row.sessionId, createdAt: row.createdAt, mode: 'delete', reviewId, choices,
+ ...(choices.worktreeData ? { path, discardChanges } : {}),
})
if (result.deleted !== true) return receipt(row, 'delete', 'Deletion was not confirmed. Refresh before trying again.')
- return { ...receipt(row, 'delete', 'Session data deleted. Project files kept.'), ...result, ok: true, refused: false }
+ return { ...receipt(row, 'delete', 'Selected data deleted.'), ...result, ok: true, refused: false }
} catch (error) { return receipt(row, 'delete', error.message + ' Refresh to check; deletion is never retried automatically.') }
}
+export async function inspectWorkspace(row, { rpc = request } = {}) {
+ try {
+ if (!row.machineId || !row.agentId || row.online === false) throw new Error('Reconnect this machine to check its workspace.')
+ const result = await rpc(row.machineId, 'agent_worktree_delete', {
+ agentId: row.agentId, sessionId: row.sessionId, createdAt: row.createdAt, mode: 'describe',
+ })
+ if (!result.workspace) throw new Error('The machine did not report workspace details.')
+ return { ...receipt(row, 'workspace-inspect', ''), ok: true, refused: false, workspace: result.workspace }
+ } catch (error) {
+ return receipt(row, 'workspace-inspect', ['UNSUPPORTED', 'INVALID_DELETE_REQUEST'].includes(error.code)
+ ? 'Update Harness on this machine to show worktree details.' : error.message)
+ }
+}
+
export async function worktreeAction(row, { reviewId, path, discardChanges = false, rpc = request } = {}) {
const inspect = !reviewId
try {
diff --git a/store/agents/harness-monitor/test/actions.test.mjs b/store/agents/harness-monitor/test/actions.test.mjs
index fccfb369f..43f855106 100644
--- a/store/agents/harness-monitor/test/actions.test.mjs
+++ b/store/agents/harness-monitor/test/actions.test.mjs
@@ -1,6 +1,6 @@
import assert from 'node:assert/strict'
import { test } from 'node:test'
-import { stop, open, previewDelete, deleteHarness, worktreeAction } from '../lib/actions.mjs'
+import { stop, open, previewDelete, deleteHarness, worktreeAction, inspectWorkspace } from '../lib/actions.mjs'
import { mergeRows } from '../lib/inventory.mjs'
import { frame } from './fixtures.mjs'
const observed = Date.now()
@@ -11,13 +11,13 @@ const clearIntent = async () => {}
test('deletion binds the review to the owning daemon and never retries a lost response', async () => {
const selected = row(), calls = []
- const rpc = async (...args) => { calls.push(args); return { reviewId: 'reviewed', sessionBytes: 4096 } }
+ const rpc = async (...args) => { calls.push(args); return { reviewId: 'reviewed', sessionBytes: 4096, choices: { sessionData: { available: true }, worktreeData: { available: false } } } }
assert.equal((await previewDelete(selected, { list: async () => [agent()], rpc })).reviewId, 'reviewed')
- assert.deepEqual(calls[0], ['remote', 'agent_purge', { agentId: selected.agentId, sessionId: selected.sessionId, createdAt: selected.createdAt, mode: 'inspect' }])
+ assert.deepEqual(calls[0], ['remote', 'agent_purge', { agentId: selected.agentId, sessionId: selected.sessionId, createdAt: selected.createdAt, mode: 'inspect', includeWorktree: true }])
const lost = async (...args) => { calls.push(args); throw new Error('connection lost') }
assert.equal((await deleteHarness(selected, { rpc: lost })).ok, false)
assert.equal(calls.length, 1)
- const result = await deleteHarness(selected, { reviewId: 'reviewed', rpc: lost })
+ const result = await deleteHarness(selected, { reviewId: 'reviewed', choices: { sessionData: true, worktreeData: false }, rpc: lost })
assert.equal(result.ok, false); assert.match(result.detail, /never retried/)
assert.equal(calls.length, 2)
assert.equal(calls[1][2].reviewId, 'reviewed')
@@ -98,3 +98,26 @@ test('concurrent open calls share one operation; running sessions need no launch
assert.equal(a.ok, true); assert.equal(b.ok, true); assert.equal(writes, 1)
assert.equal((await open(row(), { list: async () => [agent()], rpc: async () => { throw Error('Must not send') } })).ok, true)
})
+
+
+test('workspace inspection targets the owner in read-only mode and handles older daemons', async () => {
+ const selected = row(), calls = []
+ const workspace = { kind: 'main', path: '/project', mainPath: '/project', canDelete: false }
+ assert.deepEqual((await inspectWorkspace(selected, { rpc: async (...args) => { calls.push(args); return { workspace } } })).workspace, workspace)
+ assert.deepEqual(calls, [['remote', 'agent_worktree_delete', { agentId: selected.agentId, sessionId: selected.sessionId, createdAt: selected.createdAt, mode: 'describe' }]])
+ const old = await inspectWorkspace(selected, { rpc: async () => { throw Object.assign(new Error('Invalid'), { code: 'INVALID_DELETE_REQUEST' }) } })
+ assert.match(old.detail, /Update Harness/)
+ const legacy = await previewDelete(selected, { list: async () => [agent()], rpc: async () => ({ reviewId: 'legacy' }) })
+ assert.equal(legacy.ok, false)
+ assert.match(legacy.detail, /Update Harness/)
+})
+
+test('worktree-only deletion forwards explicit choices and exact reviewed path', async () => {
+ const selected = row(), calls = []
+ const options = { reviewId: 'combined', choices: { sessionData: false, worktreeData: true }, path: '/full/worktree', discardChanges: true,
+ rpc: async (...args) => { calls.push(args); return { deleted: true, sessionDeleted: false, worktreeDeleted: true } } }
+ assert.equal((await deleteHarness(selected, options)).sessionDeleted, false)
+ assert.deepEqual(calls[0][2], { agentId: selected.agentId, sessionId: selected.sessionId, createdAt: selected.createdAt, mode: 'delete', reviewId: 'combined', choices: options.choices, path: options.path, discardChanges: true })
+ assert.equal((await deleteHarness(selected, { ...options, choices: { sessionData: false, worktreeData: false } })).ok, false)
+ assert.equal(calls.length, 1)
+})
diff --git a/store/agents/harness-monitor/test/preview.mjs b/store/agents/harness-monitor/test/preview.mjs
index 9e7c27007..641acd05f 100644
--- a/store/agents/harness-monitor/test/preview.mjs
+++ b/store/agents/harness-monitor/test/preview.mjs
@@ -14,7 +14,7 @@ const rows = Array.from({ length: Number(process.env.PREVIEW_ROWS || 24) }, (_,
id: 'session-' + i, sessionId: 'conversation-' + i, name: names[i % names.length] + (i > 7 ? ' ' + (i + 1) : ''),
engine: engines[i % engines.length], status: i % 7 === 6 ? 'stopped' : 'active',
terminal: { available: true }, resumeMode: 'conversation', launch: { state: 'ready' },
- project: { name: i % 2 ? 'openharness' : 'autonomous-harness', cwd: '/home/demo/code/openharness', branch: i % 3 ? 'fix/session-recovery' : 'main' },
+ project: { name: i % 2 ? 'openharness' : 'autonomous-harness', cwd: i === 0 ? '/home/demo/code/openharness' : '/home/demo/worktrees/feature-' + i, branch: i % 3 ? 'fix/session-recovery' : 'main' },
selectedModel: ['gpt-6', 'claude-sonnet-4-6', 'muse-spark-1.3-contributor-free', 'auto'][i % 4],
createdAt: new Date(Date.now() - 86400000 * 3).toISOString(), updatedAt: new Date(Date.now() - i * 85000).toISOString(),
tokenUsage: { totalTokens: i % 3 ? 578000 : 3500000, inputTokens: i % 3 ? 420000 : 3200000, outputTokens: i % 3 ? 158000 : 300000, cachedTokens: i % 3 ? 190000 : 2100000, updatedAt: new Date().toISOString() },
@@ -25,8 +25,22 @@ const viewer = createViewer({ workspace, port: Number(process.env.PREVIEW_PORT |
verbs: { stop: async row => {
Object.assign(row, { state: 'stopped', live: false, activity: 'stopped', canStop: false, cpu: 0, rssBytes: 0 })
return { ok: true, action: 'stop', id: row.id, name: row.name }
- }, previewDelete: async row => ({ ok: true, id: row.id, reviewId: 'synthetic-delete', sessionBytes: row.sessionBytes, sharedStore: row.engine === 'opencode' }),
- deleteHarness: async row => { rows.splice(rows.indexOf(row), 1); return { ok: true, id: row.id, deleted: true } },
+ }, previewDelete: async row => ({ ok: true, id: row.id, reviewId: 'synthetic-delete', choices: {
+ sessionData: { available: true, bytes: row.sessionBytes, paths: ['/home/demo/.codex/sessions/' + row.sessionId + '.jsonl'], sharedStore: row.engine === 'opencode' },
+ worktreeData: { available: row.agentId !== 'session-0', bytes: row.agentId === 'session-0' ? null : 3200000000,
+ path: row.cwd, mainPath: '/home/demo/code/openharness',
+ branch: 'feature/storage', dirty: row.agentId === 'session-1', changes: [' M src/app.ts', '?? draft.txt'],
+ reason: row.agentId === 'session-0' ? 'No separate worktree. Main project folder — protected.' : '' },
+ } }),
+ deleteHarness: async (row, { choices }) => {
+ if (choices.sessionData) rows.splice(rows.indexOf(row), 1)
+ else Object.assign(row, { state: 'stopped', live: false, activity: 'stopped', canStop: false, workspaceBytes: null })
+ return { ok: true, id: row.id, deleted: true, sessionDeleted: choices.sessionData, worktreeDeleted: choices.worktreeData }
+ },
+ inspectWorkspace: async row => ({ ok: true, id: row.id, workspace: { kind: row.agentId === 'session-0' ? 'main' : 'worktree',
+ path: row.cwd, ...(row.agentId === 'session-0' ? {} : { worktreePath: row.cwd }),
+ mainPath: '/home/demo/code/openharness', canDelete: row.agentId !== 'session-0',
+ reason: row.agentId === 'session-0' ? 'No separate worktree. Main project folder — protected.' : 'Choose Worktree data in Delete to review cleanup.' } }),
worktreeAction: async (row, options) => options?.reviewId
? { ok: true, id: row.id, deleted: true }
: { ok: true, id: row.id, reviewId: 'synthetic-worktree', worktree: { path: '/home/demo/worktrees/feature', main: '/home/demo/code/openharness', branch: 'feature/storage', bytes: 3200000000, dirty: true, changes: [' M src/app.ts', '?? draft.txt'] } },
diff --git a/store/agents/harness-monitor/test/server.test.mjs b/store/agents/harness-monitor/test/server.test.mjs
index 149a7f334..9decc0253 100644
--- a/store/agents/harness-monitor/test/server.test.mjs
+++ b/store/agents/harness-monitor/test/server.test.mjs
@@ -204,6 +204,34 @@ test('the pane header verdict is written from the same plan the page draws', asy
assert.ok(verdict.findings.length)
})
+test('workspace inspection binds identity and does not refresh the fleet or write an action receipt', async t => {
+ let reads = 0, inspections = 0
+ const target = row({ id: 'a1', createdAt: 1234 })
+ const { viewer, base } = await serve([target], {
+ collect: async () => { reads++; return { rows: [target], machines: [], problems: [] } },
+ verbs: { inspectWorkspace: async () => { inspections++; return { ok: true, workspace: { kind: 'main', path: '/project' } } } },
+ })
+ t.after(() => viewer.close())
+ const request = payload => post(base, viewer.token, '/api/act', payload)
+ const payload = { verb: 'workspace-inspect', ids: ['a1'], manual: true, expected: [target] }
+ assert.equal((await request({ ...payload, expected: [{ ...target, createdAt: 5678 }] })).results[0].ok, false)
+ assert.equal(inspections, 0)
+ assert.equal((await request(payload)).results[0].workspace.path, '/project')
+ assert.equal(inspections, 1); assert.equal(reads, 1)
+ assert.deepEqual(viewer.snapshot().log, [])
+})
+
+test('selected deletion carries the checkboxes, full path and dirty consent to the owning operation', async t => {
+ const target = row({ id: 'a1', createdAt: 1234 }), received = []
+ const { viewer, base } = await serve([target], { verbs: { deleteHarness: async (row, options) => {
+ received.push(options); return { ok: true, id: row.id, deleted: true, sessionDeleted: false, worktreeDeleted: true }
+ } } })
+ t.after(() => viewer.close())
+ const selection = { reviewId: 'reviewed', choices: { sessionData: false, worktreeData: true }, path: '/full/worktree', discardChanges: true }
+ assert.equal((await post(base, viewer.token, '/api/act', { verb: 'delete', ids: ['a1'], manual: true, expected: [target], ...selection })).results[0].worktreeDeleted, true)
+ assert.deepEqual(received, [selection])
+})
+
test('the stream opens with the current snapshot', async (t) => {
const { viewer, base } = await serve()
t.after(() => viewer.close())
diff --git a/store/agents/harness-monitor/viewer.mjs b/store/agents/harness-monitor/viewer.mjs
index 27db6af26..fcb81893a 100644
--- a/store/agents/harness-monitor/viewer.mjs
+++ b/store/agents/harness-monitor/viewer.mjs
@@ -6,7 +6,7 @@ import { readFile } from 'node:fs/promises'
import { homedir } from 'node:os'
import { dirname, join, resolve } from 'node:path'
import { fileURLToPath, pathToFileURL } from 'node:url'
-import { stop, open, previewDelete, deleteHarness, worktreeAction } from './lib/actions.mjs'
+import { stop, open, previewDelete, deleteHarness, worktreeAction, inspectWorkspace } from './lib/actions.mjs'
import { cleanupReviews } from './lib/cleanup.mjs'
import { closeBridges } from './lib/bridge.mjs'
import { collect as collectFleet, summarize, tilde } from './lib/inventory.mjs'
@@ -14,9 +14,9 @@ import { DEFAULT_POLICY, decide, normalizePolicy } from './lib/policy.mjs'
import { pin, readLog, readState, record, savePolicyValues, writeState, writeVerdict } from './lib/state.mjs'
const PACKAGE = dirname(fileURLToPath(import.meta.url))
-const VERBS = new Set(['stop', 'open', 'pin', 'unpin', 'delete-review', 'delete', 'worktree-review', 'worktree-delete'])
+const VERBS = new Set(['stop', 'open', 'pin', 'unpin', 'delete-review', 'delete', 'worktree-review', 'worktree-delete', 'workspace-inspect'])
-export function createViewer({ workspace, port = 0, intervalMs = 4000, remoteIntervalMs = 15_000, now = () => Date.now(), collect = collectFleet, verbs = { stop, open, previewDelete, deleteHarness, worktreeAction }, cleanup = cleanupReviews() }) {
+export function createViewer({ workspace, port = 0, intervalMs = 4000, remoteIntervalMs = 15_000, now = () => Date.now(), collect = collectFleet, verbs = { stop, open, previewDelete, deleteHarness, worktreeAction, inspectWorkspace }, cleanup = cleanupReviews() }) {
const token = randomBytes(24).toString('base64url')
const clients = new Set()
const cache = new Map()
@@ -112,12 +112,12 @@ export function createViewer({ workspace, port = 0, intervalMs = 4000, remoteInt
return result
}
const act = payload => write(() => actOnce(payload))
- async function actOnce({ verb, ids, manual = false, expected, reviewId, path, discardChanges }) {
+ async function actOnce({ verb, ids, manual = false, expected, reviewId, path, discardChanges, choices }) {
if (!VERBS.has(verb)) return { error: `Not a verb Harness Monitor has: ${verb}` }
const targets = [...new Set((Array.isArray(ids) ? ids : []).filter((id) => typeof id === 'string'))].slice(0, 64)
if (!targets.length) return { error: 'Name at least one harness.' }
const explicit = manual === true && targets.length === 1
- const deleting = ['delete', 'delete-review', 'worktree-review', 'worktree-delete'].includes(verb)
+ const deleting = ['delete', 'delete-review', 'worktree-review', 'worktree-delete', 'workspace-inspect'].includes(verb)
if (deleting && (!explicit || !Array.isArray(expected) || expected.length !== 1)) return { error: 'Review one harness at a time before deleting.' }
if (['delete', 'worktree-delete'].includes(verb) && (typeof reviewId !== 'string' || !reviewId)) return { error: 'Review this harness before deleting it.' }
const reviewed = new Map((Array.isArray(expected) ? expected : snapshot.rows).filter(row => row && typeof row.id === 'string').map(({ id, sessionId, lastActivity, createdAt }) => [id, { sessionId, lastActivity, createdAt }]))
@@ -144,6 +144,10 @@ export function createViewer({ workspace, port = 0, intervalMs = 4000, remoteInt
results.push({ id: row.id, name: row.name, action: verb, ok: false, refused: true, detail: 'This session is no longer eligible for cleanup. Review the new plan.' })
continue
}
+ if (verb === 'workspace-inspect') {
+ results.push(await verbs.inspectWorkspace(row))
+ continue
+ }
if (verb === 'pin' || verb === 'unpin') {
next = pin(next, row.id, verb === 'pin')
results.push({ ok: true, action: verb, id: row.id, name: row.name, detail: verb === 'pin' ? 'never stopped by the policy' : 'the policy may stop it again' })
@@ -151,11 +155,12 @@ export function createViewer({ workspace, port = 0, intervalMs = 4000, remoteInt
}
const result = verb === 'stop' ? await verbs.stop(row, { policy, force: explicit })
: verb === 'delete-review' ? await verbs.previewDelete(row)
- : verb === 'delete' ? await verbs.deleteHarness(row, { reviewId })
+ : verb === 'delete' ? await verbs.deleteHarness(row, { reviewId, choices, path, discardChanges })
: verb === 'worktree-review' ? await verbs.worktreeAction(row)
: verb === 'worktree-delete' ? await verbs.worktreeAction(row, { reviewId, path, discardChanges }) : await verbs.open(row)
results.push(result)
}
+ if (verb === 'workspace-inspect') return { results }
if (verb === 'pin' || verb === 'unpin') await writeState(workspace, next)
for (const result of results) await record(workspace, { ...result, by: 'pane' })
await polling
diff --git a/store/agents/harness-monitor/viewer/app.css b/store/agents/harness-monitor/viewer/app.css
index 080e93ef4..07d5bdeb9 100644
--- a/store/agents/harness-monitor/viewer/app.css
+++ b/store/agents/harness-monitor/viewer/app.css
@@ -101,6 +101,12 @@ p { line-height:1.5; }
.inspect-section dl { display:grid; grid-template-columns:minmax(90px,auto) 1fr; gap:8px 20px; font-size:12px; margin:0; }
.inspect-section dt { color:var(--muted); }
.inspect-section dd { margin:0; overflow-wrap:anywhere; text-align:right; font-variant-numeric:tabular-nums; }
+.workspace-location { grid-column:1/-1; }
+.workspace-location dd { display:flex; gap:12px; align-items:flex-start; text-align:left; }
+.workspace-location dd > :first-child { flex:1; min-width:0; }
+.workspace-location code { font:12px/1.6 ui-monospace,SFMono-Regular,monospace; white-space:pre-wrap; overflow-wrap:anywhere; user-select:all; }
+.workspace-location button { flex:none; border-color:var(--line); min-height:26px; padding:3px 9px; }
+.workspace-note { margin:12px 0 0; font-size:12px; }
.processes { overflow:auto; max-height:300px; }
.processes p { color:var(--muted); font-size:12px; }
.processes table { font-size:12px; text-align:right; }
@@ -109,12 +115,14 @@ p { line-height:1.5; }
.metric-note { grid-column:1/-1; font-size:12px; margin:0; }
#stop-result { color:var(--yellow); }
#stop-storage { overflow-wrap:anywhere; }
-.worktree-details { display:grid; grid-template-columns:auto minmax(0,1fr); gap:10px 16px; font-size:12px; }
-.worktree-details dt { color:var(--muted); }
-.worktree-details dd { margin:0; overflow-wrap:anywhere; }
-#worktree-review label { display:block; margin:16px 0 8px; line-height:1.5; }
-#worktree-review [hidden] { display:none; }
-#worktree-path { width:100%; padding:9px; border:1px solid var(--line); border-radius:8px; background:var(--row); color:var(--text); font:inherit; }
+.delete-choice { border:1px solid var(--line); border-radius:12px; padding:14px; margin:12px 0; }
+.delete-choice label { display:flex; gap:8px; align-items:center; cursor:pointer; }
+.delete-choice label span { margin-left:auto; font-variant-numeric:tabular-nums; }
+.delete-choice input { accent-color:var(--accent); }
+.delete-choice p { font-size:12px; margin:8px 0 0; overflow-wrap:anywhere; }
+.delete-paths { margin:10px 0 0 24px; max-height:140px; overflow:auto; }
+.delete-paths code { display:block; font:12px/1.6 ui-monospace,SFMono-Regular,monospace; white-space:pre-wrap; overflow-wrap:anywhere; user-select:all; }
+#worktree-discard-label { display:block; margin:12px 0; line-height:1.5; }
#worktree-changes { max-height:140px; overflow:auto; padding:10px; background:var(--row); white-space:pre-wrap; overflow-wrap:anywhere; font-size:12px; }
.sr-only { position:absolute; width:1px; height:1px; padding:0; margin:-1px; overflow:hidden; clip:rect(0,0,0,0); white-space:nowrap; border:0; }
@media (max-width:800px) { nav { gap:5px; } .spacer { display:none; } .summary-scope { width:100%; margin:0; } #summary { gap:12px 22px; } }
diff --git a/store/agents/harness-monitor/viewer/app.js b/store/agents/harness-monitor/viewer/app.js
index 0cae9d880..1dc7a7daa 100644
--- a/store/agents/harness-monitor/viewer/app.js
+++ b/store/agents/harness-monitor/viewer/app.js
@@ -10,8 +10,11 @@ const dom = {
inspectContent: el('inspect-content'), inspectClose: el('inspect-close'), inspectStop: el('inspect-stop'), inspectDelete: el('inspect-delete'),
stopDialog: el('stop-dialog'), stopTitle: el('stop-title'), stopContext: el('stop-context'), stopResult: el('stop-result'),
stopCancel: el('stop-cancel'), stopConfirm: el('stop-confirm'), stopDescription: el('stop-description'), stopStorage: el('stop-storage'),
- inspectWorktree: el('inspect-worktree'), worktreeReview: el('worktree-review'), worktreeDetails: el('worktree-details'),
- worktreeChanges: el('worktree-changes'), worktreeDiscardLabel: el('worktree-discard-label'), worktreeDiscard: el('worktree-discard'), worktreePath: el('worktree-path'),
+ deleteChoices: el('delete-choices'), deleteSession: el('delete-session'), deleteSessionSize: el('delete-session-size'),
+ deleteSessionPaths: el('delete-session-paths'), deleteSessionNote: el('delete-session-note'),
+ deleteWorktree: el('delete-worktree'), deleteWorktreeSize: el('delete-worktree-size'),
+ deleteWorktreePath: el('delete-worktree-path'), deleteWorktreeNote: el('delete-worktree-note'),
+ worktreeChanges: el('worktree-changes'), worktreeDiscardLabel: el('worktree-discard-label'), worktreeDiscard: el('worktree-discard'),
}
const token = document.querySelector('meta[name="hps-token"]').content
const STORAGE_KEY = 'harness-monitor.process-table.v5'
@@ -23,7 +26,7 @@ const state = {
preset: Object.hasOwn(PRESETS, saved.preset) ? saved.preset : 'overview',
visible: new Set(Array.isArray(saved.visible) ? saved.visible : PRESETS.overview), widths: {},
selected: null, inspecting: null, busy: new Set(), nodes: new Map(), shown: [],
- frozen: false, pending: null, connected: false, receivedAt: 0, review: null,
+ frozen: false, pending: null, connected: false, receivedAt: 0, review: null, workspaceInspection: null,
}
for (const col of COLUMNS) state.widths[col.key] = Math.max(64, Math.min(600, Number(saved.widths?.[col.key]) || col.width))
const text = (node, value) => { if (node.textContent !== String(value)) node.textContent = value }
@@ -43,7 +46,7 @@ async function post(path, payload) {
if (!response.ok || result.error) throw new Error(result.error || 'Request failed. Refresh and try again.')
return result
}
-const actionWidth = () => innerWidth <= 620 ? 156 : 274
+const actionWidth = () => innerWidth <= 620 ? 100 : 154
window.addEventListener('resize', resizeColumns)
const activeColumns = () => {
const ordered = PRESETS[state.preset]
@@ -131,8 +134,8 @@ function createRow(row) {
tr.append(td)
}
const actions = element('td', null, 'row-actions')
- for (const [verb, label] of [['stop', 'Stop Harness'], ['delete', 'Delete Harness']]) {
- const button = element('button', label, verb === 'delete' ? 'delete-harness danger' : 'stop-harness')
+ for (const [verb, label] of [['stop', 'Stop'], ['delete', 'Delete']]) {
+ const button = element('button', label, verb === 'stop' ? 'stop-harness' : 'danger')
button.type = 'button'; button.dataset.action = verb
button.onclick = event => { event.stopPropagation(); state.selected = row.id; select(); reviewAction(row.id, verb) }
actions.append(button)
@@ -147,10 +150,10 @@ function updateRow(tr, row) {
for (const button of td.children) {
const deleting = button.dataset.action === 'delete'
button.disabled = !(deleting ? canDelete(row) : canStop(row))
- button.setAttribute('aria-label', (deleting ? 'Delete Harness: ' : 'Stop Harness: ') + row.name)
+ button.setAttribute('aria-label', (deleting ? 'Delete: ' : 'Stop: ') + row.name)
button.title = state.busy.has(row.id) ? 'Please wait…' : state.frozen ? 'Turn on live updates before acting.'
: !state.connected || !currentSnapshot() ? 'Reconnect before acting.'
- : row.unavailable || (deleting ? 'Review permanent deletion of session data. Project files are kept.' : 'Stop running work. History and files are kept.')
+ : row.unavailable || (deleting ? 'Choose session data, worktree data, or both. Review sizes and full paths before deletion.' : 'Stop running work. History and files are kept.')
button.setAttribute('aria-busy', String(state.busy.has(row.id)))
}
} else if (key === 'name') {
@@ -189,7 +192,7 @@ function summary() {
const resources = [...rows, ...shared]
dom.summary.replaceChildren()
for (const [label, total, format, hint] of [
- ['Workspace', storageTotal(rows), bytes, 'Disk space used by working folders. Shared and nested folders count once per machine. Inspect a harness to review worktree cleanup.'],
+ ['Workspace', storageTotal(rows), bytes, 'Disk space used by working folders. Shared and nested folders count once per machine. Delete lets you review worktree cleanup separately from session data.'],
['Session data', sumReading(rows, 'sessionBytes'), bytes, 'Conversation history and checkpoints. Shared database content is approximate; project and worktree files are excluded.'],
['RAM', sumReading(resources, 'rssBytes'), memory, 'Resident memory including child processes and shared servers once. Shared memory pages can overlap.'],
['CPU', sumReading(resources, 'cpu'), n => Math.round(n) + '%', '100% is one core. Shared servers count once.'],
@@ -244,20 +247,65 @@ function render() {
}
function inspect(id) {
const row = state.rows.find(r => r.id === id); if (!row) return
- state.inspecting = id; renderInspector(); dom.inspector.showModal()
+ state.inspecting = id
+ const inspection = { identity: workspaceIdentity(row), loading: true }
+ state.workspaceInspection = inspection
+ renderInspector(); dom.inspector.showModal()
+ void loadWorkspace(row, inspection)
+}
+const workspaceIdentity = row => JSON.stringify([row?.id, row?.sessionId, row?.createdAt, row?.cwd])
+async function loadWorkspace(row, inspection) {
+ try {
+ const reply = await post('/api/act', { verb: 'workspace-inspect', ids: [row.id], manual: true, expected: [row] })
+ const result = reply.results?.find(r => r.id === row.id)
+ if (!result?.ok || !result.workspace) throw new Error(result?.detail || 'Workspace details are unavailable.')
+ inspection.workspace = result.workspace
+ } catch (error) { inspection.error = error.message }
+ finally {
+ inspection.loading = false
+ if (state.workspaceInspection === inspection && dom.inspector.open) renderInspector()
+ }
+}
+function workspaceSection(row, inspection) {
+ const workspace = inspection?.workspace
+ const section = element('section', null, 'inspect-section workspace-location')
+ section.append(element('h3', 'Workspace'))
+ const dl = element('dl')
+ const add = (label, value, path = false) => {
+ const dd = element('dd'), content = element(path ? 'code' : 'span', value || 'Unavailable')
+ dd.append(content)
+ if (path && value) {
+ const copy = element('button', 'Copy'); copy.type = 'button'; copy.setAttribute('aria-label', 'Copy ' + label.toLowerCase())
+ copy.onclick = async () => {
+ try { await navigator.clipboard.writeText(value); text(copy, 'Copied') }
+ catch { text(copy, 'Select path to copy') }
+ }
+ dd.append(copy)
+ }
+ dl.append(element('dt', label), dd)
+ }
+ add('Type', inspection?.loading ? 'Checking…' : ({ main: 'Main checkout', worktree: 'Git worktree', folder: 'Folder', unavailable: 'Unverified' }[workspace?.kind] || 'Unverified'))
+ add('Working folder', workspace?.path || row.cwd || row.workspacePath, true)
+ if (workspace?.worktreePath) add('Worktree path', workspace.worktreePath, true)
+ if (workspace?.mainPath) add('Main project', workspace.mainPath, true)
+ if (workspace?.kind === 'main') add('Worktree', 'None — this harness uses the main project directly.')
+ section.append(dl, element('p', inspection?.loading ? 'Checking the folder on ' + row.machine + '…'
+ : workspace?.reason || inspection?.error || 'The workspace changed. Reopen Inspect to check it again.', 'muted workspace-note'))
+ return section
}
function renderInspector() {
const row = state.rows.find(r => r.id === state.inspecting)
+ const inspection = state.workspaceInspection?.identity === workspaceIdentity(row) ? state.workspaceInspection : null
dom.inspectStop.disabled = !canStop(row)
dom.inspectDelete.disabled = !canDelete(row)
- dom.inspectWorktree.disabled = !canDelete(row)
if (!row) { text(dom.inspectContext, 'This harness is no longer open.'); return }
text(dom.inspectTitle, row.name)
text(dom.inspectContext, [engineNames[row.engine] || row.engine, row.machine, ACTIVITY[row.activity]?.[1]].filter(Boolean).join(' · '))
dom.inspectContent.replaceChildren()
+ dom.inspectContent.append(workspaceSection(row, inspection))
for (const group of ['Resources', 'AI usage', 'Session']) {
const section = element('section', null, 'inspect-section'); section.append(element('h3', group)); const dl = element('dl')
- for (const col of COLUMNS.filter(c => c.group === group && !['name', 'activity', 'engine', 'machine'].includes(c.key))) {
+ for (const col of COLUMNS.filter(c => c.group === group && !['name', 'activity', 'engine', 'machine', 'home'].includes(c.key))) {
const label = element('dt', col.label), value = element('dd', formatValue(col.key, row[col.key])); label.title = col.help || col.label
dl.append(label, value)
}
@@ -279,84 +327,96 @@ function renderInspector() {
if (row.processCount > row.processes.length) processes.append(element('p', `Showing ${row.processes.length} of ${row.processCount} processes.`, 'muted'))
}
dom.inspectContent.append(processes)
- const notes = element('p', 'Session data is conversation history and checkpoints. Workspace is the project or worktree folder. Delete Harness keeps workspace files. Delete Worktree separately reviews the checkout path, branch and uncommitted changes; the main project folder is protected. Missing readings are unavailable, not zero.', 'muted metric-note')
+ const notes = element('p', 'Session data is conversation history and checkpoints. Workspace is the project or worktree folder. Delete lets you choose session data, worktree data, or both, with a size and path review. The main project folder is protected. Missing readings are unavailable, not zero.', 'muted metric-note')
dom.inspectContent.append(notes)
}
async function reviewAction(id, verb = 'stop') {
- const row = state.rows.find(r => r.id === id), deleting = verb === 'delete', worktree = verb === 'worktree-delete'
- if (!(deleting || worktree ? canDelete(row) : canStop(row))) return
+ const row = state.rows.find(r => r.id === id), deleting = verb === 'delete'
+ if (!(deleting ? canDelete(row) : canStop(row))) return
const review = { id: row.id, sessionId: row.sessionId, createdAt: row.createdAt, lastActivity: row.lastActivity, name: row.name, verb }
state.review = review
- text(dom.stopTitle, worktree ? 'Delete worktree for “' + row.name + '”?' : (deleting ? 'Delete' : 'Stop') + ' “' + row.name + '”?')
+ text(dom.stopTitle, (deleting ? 'Delete' : 'Stop') + ' “' + row.name + '”?')
text(dom.stopContext, `${row.machine} · ${ACTIVITY[row.activity]?.[1] || 'Unknown'}`)
- text(dom.stopDescription, worktree ? 'Permanently remove this Git worktree and everything inside it, including ignored files such as dependencies and build output. This harness will stop. Its branch, commits and conversation history are kept.'
- : deleting ? 'Are you sure you want to permanently delete this harness and its saved conversation? Running work will stop. This cannot be undone.'
+ text(dom.stopDescription, deleting ? 'Choose the data to permanently delete. Running work will stop. This cannot be undone.'
: 'Its running work will end and its panes will close. Conversation history and project files are kept.')
- text(dom.stopStorage, deleting ? `Project and worktree files are kept. Workspace: ${row.workspacePath || row.home || 'unavailable'} (${bytes(row.workspaceBytes)}).` : '')
- text(dom.stopConfirm, worktree ? 'Delete Worktree' : deleting ? 'Delete Harness' : 'Stop Harness')
- text(dom.stopResult, worktree ? 'Checking the worktree and other harnesses…' : deleting ? 'Checking saved session data…' : '')
- dom.worktreeReview.hidden = true; dom.worktreePath.value = ''; dom.worktreeDiscard.checked = false
- dom.stopConfirm.disabled = deleting || worktree; dom.stopCancel.disabled = false
+ text(dom.stopStorage, '')
+ text(dom.stopConfirm, deleting ? 'Delete' : 'Stop')
+ text(dom.stopResult, deleting ? 'Checking data sizes, paths and worktree protection…' : '')
+ dom.deleteChoices.hidden = true; dom.worktreeDiscard.checked = false; dom.worktreeDiscard.disabled = false
+ for (const check of [dom.deleteSession, dom.deleteWorktree]) { check.checked = false; check.disabled = true }
+ dom.worktreeChanges.hidden = true; dom.worktreeDiscardLabel.hidden = true
+ dom.stopConfirm.disabled = deleting; dom.stopCancel.disabled = false
dom.stopDialog.showModal()
- if (!deleting && !worktree) return
+ if (!deleting) return
try {
- const reply = await post('/api/act', { verb: worktree ? 'worktree-review' : 'delete-review', ids: [review.id], manual: true, expected: [review] })
+ const reply = await post('/api/act', { verb: 'delete-review', ids: [review.id], manual: true, expected: [review] })
if (state.review !== review || !dom.stopDialog.open) return
const result = reply.results?.find(r => r.id === review.id)
- if (!result?.ok || !result.reviewId) throw new Error(result?.detail || 'Could not check session data. Refresh and try again.')
- review.reviewId = result.reviewId
- if (worktree) {
- if (!result.worktree?.path) throw new Error('The worktree path could not be verified.')
- review.worktree = result.worktree
- dom.worktreeDetails.replaceChildren()
- for (const [label, value] of [['Delete folder', review.worktree.path], ['Disk space', bytes(review.worktree.bytes)], ['Branch kept', review.worktree.branch || 'Detached; commits are saved on a branch'], ['Main project kept', review.worktree.main]]) {
- dom.worktreeDetails.append(element('dt', label), element('dd', value))
- }
- text(dom.worktreeChanges, review.worktree.changes.join('\n'))
- dom.worktreeChanges.hidden = !review.worktree.dirty
- dom.worktreeDiscardLabel.hidden = !review.worktree.dirty
- dom.worktreeReview.hidden = false
- text(dom.stopResult, review.worktree.dirty ? 'Uncommitted changes are present (up to 12 entries shown). They cannot be recovered from Git after deletion.' : 'The worktree has no uncommitted changes. Recreate its checkout to resume work later.')
- return
- }
- text(dom.stopResult, result.sharedStore ? `Approximately ${bytes(result.sessionBytes)} of session data will be removed. Shared database space can be reused; its file may not shrink immediately.`
- : `Session files to delete: approximately ${bytes(result.sessionBytes)}. The final size may change as running work stops.`)
- dom.stopConfirm.disabled = false
+ if (!result?.ok || !result.reviewId || !result.choices) throw new Error(result?.detail || 'Could not check the data. Update Harness on the owning machine and try again.')
+ review.reviewId = result.reviewId; review.choices = result.choices
+ const session = review.choices.sessionData, worktree = review.choices.worktreeData
+ dom.deleteSession.disabled = !session.available; dom.deleteSession.checked = session.available
+ dom.deleteWorktree.disabled = !worktree.available; dom.deleteWorktree.checked = worktree.available
+ text(dom.deleteSessionSize, bytes(session.bytes)); text(dom.deleteWorktreeSize, bytes(worktree.bytes))
+ dom.deleteSessionPaths.replaceChildren(...(session.paths || []).map(path => element('code', path)))
+ if (!session.paths?.length) dom.deleteSessionPaths.append(element('span', session.available ? 'No saved session files.' : 'Path unavailable.'))
+ dom.deleteWorktreePath.replaceChildren(element('code', worktree.path || 'Path unavailable.'))
+ text(dom.deleteSessionNote, session.reason || (session.sharedStore
+ ? 'Only this conversation and its checkpoints are deleted. Shared database space can be reused; the file may not shrink immediately.'
+ : 'Conversation history and saved checkpoints. Project files are kept.'))
+ text(dom.deleteWorktreeNote, worktree.reason || `Removes this entire folder, including dependencies and build output. Main project kept: ${worktree.mainPath}. Branch kept: ${worktree.branch || 'commits saved on a branch'}.`)
+ text(dom.worktreeChanges, (worktree.changes || []).join('\n'))
+ dom.deleteChoices.hidden = false
+ text(dom.stopResult, 'Sizes are approximate and may change as running work stops.')
+ validateDeleteConfirmation()
} catch (error) { if (state.review === review && dom.stopDialog.open) text(dom.stopResult, error.message) }
}
dom.inspect.onclick = () => inspect(state.selected)
dom.inspectStop.onclick = () => reviewAction(state.inspecting)
dom.inspectDelete.onclick = () => reviewAction(state.inspecting, 'delete')
-dom.inspectWorktree.onclick = () => reviewAction(state.inspecting, 'worktree-delete')
-function validateWorktreeConfirmation() {
+function selectedChoices() {
+ return { sessionData: !dom.deleteSession.disabled && dom.deleteSession.checked,
+ worktreeData: !dom.deleteWorktree.disabled && dom.deleteWorktree.checked }
+}
+function validateDeleteConfirmation() {
const review = state.review
- if (review?.verb === 'worktree-delete') dom.stopConfirm.disabled = !review.worktree || !review.reviewId
- || state.busy.has(review.id) || dom.worktreePath.value !== review.worktree.path || (review.worktree.dirty && !dom.worktreeDiscard.checked)
+ if (review?.verb !== 'delete') return
+ const choices = selectedChoices(), dirty = choices.worktreeData && review.choices?.worktreeData?.dirty
+ dom.worktreeChanges.hidden = !dirty; dom.worktreeDiscardLabel.hidden = !dirty
+ dom.stopConfirm.disabled = !review.reviewId || review.consumed || state.busy.has(review.id)
+ || (!choices.sessionData && !choices.worktreeData) || (dirty && !dom.worktreeDiscard.checked)
}
-dom.worktreePath.oninput = validateWorktreeConfirmation
-dom.worktreeDiscard.onchange = validateWorktreeConfirmation
+dom.deleteSession.onchange = dom.deleteWorktree.onchange = dom.worktreeDiscard.onchange = validateDeleteConfirmation
dom.inspectClose.onclick = () => dom.inspector.close()
dom.stopCancel.onclick = () => { state.review = null; dom.stopDialog.close() }
dom.stopDialog.addEventListener('cancel', event => { if (state.busy.has(state.review?.id)) event.preventDefault(); else state.review = null })
dom.stopConfirm.onclick = async () => {
const review = state.review
- if (!review || state.busy.has(review.id)) return
- const deleting = review.verb === 'delete', worktree = review.verb === 'worktree-delete', row = state.rows.find(r => r.id === review.id)
- if (worktree && (!review.worktree || dom.worktreePath.value !== review.worktree.path || (review.worktree.dirty && !dom.worktreeDiscard.checked))) return
- if (!(deleting || worktree ? canDelete(row) : canStop(row)) || row.sessionId !== review.sessionId || row.createdAt !== review.createdAt || ((deleting || worktree) && !review.reviewId)) {
+ if (!review || review.consumed || state.busy.has(review.id)) return
+ const deleting = review.verb === 'delete', row = state.rows.find(r => r.id === review.id), choices = selectedChoices()
+ if (deleting) { validateDeleteConfirmation(); if (dom.stopConfirm.disabled) return }
+ if (!(deleting ? canDelete(row) : canStop(row)) || row.sessionId !== review.sessionId || row.createdAt !== review.createdAt || (deleting && !review.reviewId)) {
text(dom.stopResult, 'This session or connection changed. Cancel, refresh and review it again.')
dom.stopConfirm.disabled = true; return
}
+ review.consumed = true
state.busy.add(review.id); dom.stopConfirm.disabled = true; dom.stopCancel.disabled = true
- text(dom.stopResult, worktree ? 'Stopping and deleting the worktree…' : deleting ? 'Deleting session data…' : 'Stopping…'); render()
+ for (const check of [dom.deleteSession, dom.deleteWorktree, dom.worktreeDiscard]) check.disabled = true
+ text(dom.stopResult, deleting ? 'Stopping and deleting the selected data…' : 'Stopping…'); render()
try {
const reply = await post('/api/act', { verb: review.verb, ids: [review.id], manual: true, expected: [review], reviewId: review.reviewId,
- ...(worktree ? { path: dom.worktreePath.value, discardChanges: dom.worktreeDiscard.checked } : {}) })
+ ...(deleting ? { choices, ...(choices.worktreeData ? { path: review.choices.worktreeData.path, discardChanges: dom.worktreeDiscard.checked } : {}) } : {}) })
const result = reply.results?.find(r => r.id === review.id)
if (!result?.ok) { text(dom.stopResult, result?.detail || 'The action was not confirmed. Refresh to check.'); return }
- if (deleting) state.rows = state.rows.filter(r => r.id !== review.id || r.sessionId !== review.sessionId)
- else { const stopped = state.rows.find(r => r.id === review.id); if (stopped) Object.assign(stopped, { state: 'stopped', activity: 'stopped', live: false, canStop: false, ...(worktree ? { workspaceBytes: null } : {}) }) }
- message(worktree ? 'Worktree deleted. Branch and conversation history kept.' : deleting ? 'Deleted ' + review.name + '. Project files kept.' : 'Stopped ' + review.name + '. History and files kept.')
+ if (deleting && result.sessionDeleted) state.rows = state.rows.filter(r => r.id !== review.id || r.sessionId !== review.sessionId)
+ else {
+ const stopped = state.rows.find(r => r.id === review.id)
+ if (stopped) Object.assign(stopped, { state: 'stopped', activity: 'stopped', live: false, canStop: false, ...(result.worktreeDeleted ? { workspaceBytes: null } : {}) })
+ }
+ message(!deleting ? 'Stopped ' + review.name + '. History and files kept.'
+ : result.sessionDeleted && result.worktreeDeleted ? 'Session and worktree data deleted. Main project and branch kept.'
+ : result.worktreeDeleted ? 'Worktree data deleted. Conversation, main project and branch kept.'
+ : 'Session data deleted. Project and worktree files kept.')
state.review = null; dom.stopDialog.close()
if (dom.inspector.open && state.inspecting === review.id) dom.inspector.close()
dom.grid.focus({ preventScroll: true })
diff --git a/store/agents/harness-monitor/viewer/index.html b/store/agents/harness-monitor/viewer/index.html
index 8852af446..2f6f960fc 100644
--- a/store/agents/harness-monitor/viewer/index.html
+++ b/store/agents/harness-monitor/viewer/index.html
@@ -39,19 +39,24 @@
<dialog id="inspector" aria-labelledby="inspect-title">
<div class="dialog-heading"><h2 id="inspect-title">Harness details</h2><button id="inspect-close" aria-label="Close details">Close</button></div>
<p id="inspect-context" class="muted"></p><div id="inspect-content"></div>
- <div class="dialog-actions"><button id="inspect-worktree" class="danger">Delete Worktree…</button><button id="inspect-stop">Stop Harness</button><button id="inspect-delete" class="danger">Delete Harness</button></div>
+ <div class="dialog-actions"><button id="inspect-stop">Stop</button><button id="inspect-delete" class="danger">Delete</button></div>
</dialog>
<dialog id="stop-dialog" aria-labelledby="stop-title">
<h2 id="stop-title">Stop harness?</h2><p id="stop-context"></p><p id="stop-description"></p><p id="stop-storage" class="muted"></p>
- <div id="worktree-review" hidden>
- <dl id="worktree-details" class="worktree-details"></dl>
+ <div id="delete-choices" hidden>
+ <section class="delete-choice">
+ <label><input id="delete-session" type="checkbox" disabled> <strong>Session data</strong> <span id="delete-session-size"></span></label>
+ <div id="delete-session-paths" class="delete-paths"></div><p id="delete-session-note" class="muted"></p>
+ </section>
+ <section class="delete-choice">
+ <label><input id="delete-worktree" type="checkbox" disabled> <strong>Worktree data</strong> <span id="delete-worktree-size"></span></label>
+ <div id="delete-worktree-path" class="delete-paths"></div><p id="delete-worktree-note" class="muted"></p>
+ </section>
<pre id="worktree-changes" hidden></pre>
<label id="worktree-discard-label" hidden><input id="worktree-discard" type="checkbox"> Permanently discard all uncommitted changes and untracked files.</label>
- <label for="worktree-path">Type the full worktree path to confirm</label>
- <input id="worktree-path" type="text" autocomplete="off" spellcheck="false">
</div>
<p id="stop-result" role="status" aria-live="polite"></p>
- <div class="dialog-actions"><button id="stop-cancel" autofocus>Cancel</button><button id="stop-confirm" class="danger filled">Stop Harness</button></div>
+ <div class="dialog-actions"><button id="stop-cancel" autofocus>Cancel</button><button id="stop-confirm" class="danger filled">Stop</button></div>
</dialog>
<script type="module" src="app.js"></script>
</body>
diff --git a/store/agents/harness-monitor/viewer/table.js b/store/agents/harness-monitor/viewer/table.js
index de5906e1e..c8a12ca98 100644
--- a/store/agents/harness-monitor/viewer/table.js
+++ b/store/agents/harness-monitor/viewer/table.js
@@ -8,8 +8,8 @@ export const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧',
export const COLUMNS = [
{ key: 'name', label: 'Harness', width: 230, required: true, group: 'Session' },
{ key: 'activity', label: 'Status', width: 112, group: 'Session' },
- { key: 'workspaceBytes', label: 'Workspace', width: 120, numeric: true, group: 'Resources', help: 'Disk space used by the entire working folder: a project, worktree or subfolder. Shared folders repeat per row. Inspect to review separate Git worktree cleanup. Delete Harness keeps these files.' },
- { key: 'sessionBytes', label: 'Session data', width: 130, numeric: true, group: 'Resources', help: 'Conversation history and Harness checkpoints stored on disk. Database sizes estimate conversation content, not the whole shared database. Deletion keeps project files. — means not measured.' },
+ { key: 'workspaceBytes', label: 'Workspace', width: 120, numeric: true, group: 'Resources', help: 'Disk space used by the entire working folder: a project, worktree or subfolder. Shared folders repeat per row. Delete lets you review worktree cleanup separately from session data. Main project folders are protected.' },
+ { key: 'sessionBytes', label: 'Session data', width: 130, numeric: true, group: 'Resources', help: 'Conversation history and Harness checkpoints stored on disk. Database sizes estimate conversation content, not the whole shared database. Deleting only session data keeps workspace files. — means not measured.' },
{ key: 'rssBytes', label: 'RAM', width: 88, numeric: true, group: 'Resources', help: 'Resident memory, including child processes. Shared memory pages can overlap. Shared servers appear separately.' },
{ key: 'cpu', label: 'CPU %', width: 80, numeric: true, group: 'Resources', help: 'Interval CPU of this process tree. 100% is one core; multiple cores can exceed 100%.' },
{ key: 'gpuPercent', label: 'GPU %', width: 80, numeric: true, group: 'Resources', help: 'GPU use of this process tree: GPU time per interval on supported macOS drivers, utilization on Linux NVIDIA. Can exceed 100% across processes or devices. First samples and unavailable counters show —. Cloud model GPU usage is not reported.' },