diff --git a/.gitignore b/.gitignore
index 91ebcd26..34db38f4 100644
--- a/.gitignore
+++ b/.gitignore
@@ -32,6 +32,7 @@ artifacts/coverage/
 desktop/dist/
 desktop/build-artifacts/
 desktop/binaries/
+desktop/.bun-cache/
 desktop/.electron-cache/
 desktop/electron-dist/
 desktop/electron-release/
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5ffc9df3..11f88ab5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -16,6 +16,8 @@ All notable changes to DreamCoder will be documented in this file.
 
 ### Fixed
 
+- Building the desktop sidecar while Vite is running no longer crashes the Windows file watcher on Bun compiler temporary files, and concurrent dev launches no longer reuse an unrelated Vite instance.
+- Project boards now keep distinct storage for project paths that sanitize to the same name, recover new events after a partial JSONL write, resolve cancellation dependencies atomically with optional dependent and subtask cascading, and keep delivered file links readable after the author session is deleted.
 - Permission prompts that ask every time, such as starting a session or editing files under `.git/`, no longer offer "Allow for this session", which could not take effect (#242).
 - Tools sent to providers through the OpenAI Responses API are no longer in strict mode, so their optional parameters stay optional (#242).
 - Confirmation dialogs keep long workspace paths inside their bounds, so Cancel and Enable remain visible when enabling bypass permissions (#226). Thanks @imshah-id.
diff --git a/desktop/scripts/electron-dev-server.test.ts b/desktop/scripts/electron-dev-server.test.ts
new file mode 100644
index 00000000..611819d0
--- /dev/null
+++ b/desktop/scripts/electron-dev-server.test.ts
@@ -0,0 +1,18 @@
+import { describe, expect, it, vi } from 'vitest'
+import { assertDevServerAvailable, waitForDevServer } from './electron-dev-server'
+
+describe('electron dev server startup', () => {
+  it('refuses a port that already has an HTTP server', async () => {
+    await expect(assertDevServerAvailable('http://localhost:1420', vi.fn().mockResolvedValue({ ok: false }))).rejects.toThrow('already in use')
+  })
+
+  it('fails when the Vite child exits before it becomes ready', async () => {
+    await expect(waitForDevServer('http://localhost:1420', { exitCode: 1 }, { fetcher: vi.fn() })).rejects.toThrow('exited before startup with code 1')
+  })
+
+  it('accepts a stable response from the Vite child', async () => {
+    const sleep = vi.fn().mockResolvedValue(undefined)
+    await waitForDevServer('http://localhost:1420', { exitCode: null }, { fetcher: vi.fn().mockResolvedValue({ ok: true }), sleep })
+    expect(sleep).toHaveBeenCalledWith(500)
+  })
+})
diff --git a/desktop/scripts/electron-dev-server.ts b/desktop/scripts/electron-dev-server.ts
new file mode 100644
index 00000000..7a0d334f
--- /dev/null
+++ b/desktop/scripts/electron-dev-server.ts
@@ -0,0 +1,47 @@
+type DevServerProcess = { readonly exitCode: number | null }
+
+type FetchDevServer = (url: string) => Promise<{ ok: boolean }>
+
+type WaitOptions = {
+  timeoutMs?: number
+  stabilizationMs?: number
+  fetcher?: FetchDevServer
+  sleep?: (milliseconds: number) => Promise<void>
+}
+
+const delay = (milliseconds: number) => new Promise<void>((resolve) => setTimeout(resolve, milliseconds))
+
+export async function assertDevServerAvailable(url: string, fetcher: FetchDevServer = fetch): Promise<void> {
+  let occupied = false
+  try {
+    await fetcher(url)
+    occupied = true
+  } catch {
+    occupied = false
+  }
+  if (occupied) throw new Error(`[electron-dev] ${url} is already in use. Stop the other dev server and try again.`)
+}
+
+export async function waitForDevServer(
+  url: string,
+  process: DevServerProcess,
+  { timeoutMs = 60_000, stabilizationMs = 500, fetcher = fetch, sleep = delay }: WaitOptions = {},
+): Promise<void> {
+  const deadline = Date.now() + timeoutMs
+  while (Date.now() < deadline) {
+    if (process.exitCode !== null) throw new Error(`[electron-dev] Vite exited before startup with code ${process.exitCode}.`)
+    let ready = false
+    try {
+      ready = (await fetcher(url)).ok
+    } catch {
+      ready = false
+    }
+    if (ready) {
+      await sleep(stabilizationMs)
+      if (process.exitCode !== null) throw new Error(`[electron-dev] Vite exited during startup with code ${process.exitCode}.`)
+      return
+    }
+    await sleep(250)
+  }
+  throw new Error(`[electron-dev] Vite did not answer on ${url} within ${timeoutMs / 1000} seconds`)
+}
diff --git a/desktop/scripts/electron-dev.ts b/desktop/scripts/electron-dev.ts
index 18e4d364..7b09a460 100644
--- a/desktop/scripts/electron-dev.ts
+++ b/desktop/scripts/electron-dev.ts
@@ -1,10 +1,10 @@
 import path from 'node:path'
 import electronPath from 'electron'
 import type { Subprocess } from 'bun'
+import { assertDevServerAvailable, waitForDevServer } from './electron-dev-server'
 
 const desktopRoot = path.resolve(import.meta.dir, '..')
 const devUrl = 'http://localhost:1420'
-const startupTimeoutMs = 60_000
 const children: Subprocess[] = []
 
 function spawn(cmd: string[], env?: Record<string, string | undefined>) {
@@ -19,24 +19,13 @@ function stopAll() {
   }
 }
 
-async function waitForDevServer() {
-  const deadline = Date.now() + startupTimeoutMs
-  while (Date.now() < deadline) {
-    try {
-      if ((await fetch(devUrl)).ok) return
-    } catch {
-      await Bun.sleep(250)
-    }
-  }
-  throw new Error(`[electron-dev] Vite did not answer on ${devUrl} within ${startupTimeoutMs / 1000} seconds`)
-}
-
 process.on('SIGINT', stopAll)
 process.on('SIGTERM', stopAll)
 
 try {
-  spawn(['bun', 'run', 'dev'])
-  await waitForDevServer()
+  await assertDevServerAvailable(devUrl)
+  const devServer = spawn(['bun', 'run', 'dev'])
+  await waitForDevServer(devUrl, devServer)
   if (await spawn(['bun', 'run', './scripts/build-electron.ts']).exited !== 0) {
     throw new Error('[electron-dev] building the main process failed')
   }
diff --git a/desktop/src/api/kanban.ts b/desktop/src/api/kanban.ts
index a3dc8e94..dd410c6f 100644
--- a/desktop/src/api/kanban.ts
+++ b/desktop/src/api/kanban.ts
@@ -1,5 +1,6 @@
 import type { BoardListing, BoardView, KanbanCommand, KanbanEvent } from '@protocol'
 import { api } from './client'
+import type { WorkspaceReadFileResult } from './sessions'
 
 export type BoardPoll = { changed: true; view: BoardView } | { changed: false; etag: string }
 
@@ -29,4 +30,8 @@ export const kanbanApi = {
   history(key: string, card: number) {
     return api.get<{ events: KanbanEvent[] }>(`${boardPath(key)}/cards/${card}/history`)
   },
+
+  file(key: string, path: string) {
+    return api.get<WorkspaceReadFileResult>(`${boardPath(key)}/files?path=${encodeURIComponent(path)}`)
+  },
 }
diff --git a/desktop/src/components/kanban/CardLinks.tsx b/desktop/src/components/kanban/CardLinks.tsx
index 0f365614..9edcab33 100644
--- a/desktop/src/components/kanban/CardLinks.tsx
+++ b/desktop/src/components/kanban/CardLinks.tsx
@@ -2,16 +2,16 @@ import type { KanbanActor } from '@protocol'
 import { useWorkspacePanelStore } from '../../stores/workspacePanelStore'
 import { linkTarget, type LinkTarget } from './board'
 
-function openLink(panelId: string, target: LinkTarget, projectRoot: string) {
+function openLink(panelId: string, board: string, target: LinkTarget, projectRoot: string) {
   const panel = useWorkspacePanelStore.getState()
   if (target.kind === 'file') {
-    panel.openTab(panelId, { kind: 'file', path: target.path, sessionId: target.sessionId })
+    panel.openTab(panelId, { kind: 'file', path: target.path, board })
     return
   }
   void panel.openUrl(panelId, target.url, projectRoot)
 }
 
-export function CardLinks({ panelId, projectRoot, links, author }: { panelId: string; projectRoot: string; links: readonly string[]; author: KanbanActor }) {
+export function CardLinks({ panelId, board, projectRoot, links, author }: { panelId: string; board: string; projectRoot: string; links: readonly string[]; author: KanbanActor }) {
   if (!links.length) return null
   return (
     <span className="flex flex-col gap-0.5">
@@ -21,7 +21,7 @@ export function CardLinks({ panelId, projectRoot, links, author }: { panelId: st
           <button
             key={link}
             type="button"
-            onClick={() => openLink(panelId, target, projectRoot)}
+            onClick={() => openLink(panelId, board, target, projectRoot)}
             className="truncate text-left font-mono text-[12px] text-[var(--color-brand)] hover:underline"
           >
             {link}
diff --git a/desktop/src/components/kanban/KanbanViews.test.tsx b/desktop/src/components/kanban/KanbanViews.test.tsx
index af204229..af28b290 100644
--- a/desktop/src/components/kanban/KanbanViews.test.tsx
+++ b/desktop/src/components/kanban/KanbanViews.test.tsx
@@ -76,19 +76,21 @@ function MoveButton({ card, to }: { card: number; to: CardStatus }) {
 }
 
 describe('cancelling a task', () => {
-  it('lists the open tasks that wait on it and its unfinished subtasks before the person confirms', async () => {
+  it('lets the person choose whether to cancel dependents and unfinished subtasks', async () => {
     kanbanApiMock.command.mockResolvedValue({ view: hierarchy(), warnings: [] })
     render(<MoveButton card={3} to="cancelled" />)
     fireEvent.click(screen.getByRole('button', { name: 'Move it' }))
     const dialog = await screen.findByRole('alertdialog')
-    expect(within(dialog).getAllByRole('note').map((note) => note.textContent)).toEqual(['kanban.prompt.cancelDependents #2'])
+    const dependents = within(dialog).getByRole('checkbox', { name: 'kanban.prompt.cancelDependents #2' })
+    expect(dependents).not.toBeChecked()
+    fireEvent.click(dependents)
     fireEvent.click(within(dialog).getByRole('button', { name: 'kanban.action.cancelTask' }))
-    await waitFor(() => expect(kanbanApiMock.command).toHaveBeenCalledWith(FIXTURE_BOARD, { type: 'cancel', card: 3 }))
+    await waitFor(() => expect(kanbanApiMock.command).toHaveBeenCalledWith(FIXTURE_BOARD, { type: 'cancel', card: 3, cancelDependents: true, cancelChildren: false }))
 
     cleanup()
     render(<MoveButton card={1} to="cancelled" />)
     fireEvent.click(screen.getByRole('button', { name: 'Move it' }))
-    expect(within(await screen.findByRole('alertdialog')).getAllByRole('note').map((note) => note.textContent)).toEqual(['kanban.prompt.cancelChildren #2'])
+    expect(within(await screen.findByRole('alertdialog')).getByRole('checkbox', { name: 'kanban.prompt.cancelChildren #2' })).not.toBeChecked()
   })
 })
 
@@ -424,7 +426,7 @@ describe('TaskDetail', () => {
     expect(within(delivery).getByText('Token store').tagName).toBe('STRONG')
   })
 
-  it('opens a delivered report file in the panel through the session that wrote it', () => {
+  it('opens a delivered report file in the panel through the board', () => {
     const view = hierarchy()
     const reviewed = { ...view.cards[2]!, deliveries: [{ id: 'd', summary: 'See the report', links: ['/repo/review.md', 'feat/tokens'], actor: { kind: 'session' as const, sessionId: 'worker' }, at: '' }] }
     useKanbanStore.setState({ views: { [FIXTURE_BOARD]: { ...view, cards: [view.cards[0]!, view.cards[1]!, reviewed] } } })
@@ -433,7 +435,7 @@ describe('TaskDetail', () => {
     expect(screen.queryByRole('button', { name: 'feat/tokens' })).not.toBeInTheDocument()
     fireEvent.click(screen.getByRole('button', { name: '/repo/review.md' }))
 
-    expect(useWorkspacePanelStore.getState().getActiveTab('board-tab')).toMatchObject({ kind: 'file', path: '/repo/review.md', sessionId: 'worker' })
+    expect(useWorkspacePanelStore.getState().getActiveTab('board-tab')).toMatchObject({ kind: 'file', path: '/repo/review.md', board: FIXTURE_BOARD })
   })
 
   it('opens a related task as another tab in the same panel', () => {
diff --git a/desktop/src/components/kanban/TaskDetail.tsx b/desktop/src/components/kanban/TaskDetail.tsx
index da209d83..ea6d65c1 100644
--- a/desktop/src/components/kanban/TaskDetail.tsx
+++ b/desktop/src/components/kanban/TaskDetail.tsx
@@ -286,7 +286,7 @@ function TaskDetailBody({ panelId, board, view, card }: { panelId: string; board
               {card.deliveries.map((delivery) => (
                 <div key={delivery.id} className="flex flex-col gap-1 text-[13px]">
                   <ClampedMarkdown content={delivery.summary} />
-                  <CardLinks panelId={panelId} projectRoot={view.project} links={delivery.links} author={delivery.actor} />
+                  <CardLinks panelId={panelId} board={board} projectRoot={view.project} links={delivery.links} author={delivery.actor} />
                 </div>
               ))}
               {card.status === 'review' && (
diff --git a/desktop/src/components/kanban/TaskTimeline.tsx b/desktop/src/components/kanban/TaskTimeline.tsx
index 088e6924..8de4dac7 100644
--- a/desktop/src/components/kanban/TaskTimeline.tsx
+++ b/desktop/src/components/kanban/TaskTimeline.tsx
@@ -141,7 +141,7 @@ export function TaskTimeline({ panelId, board, view, card }: { panelId: string;
               <MarkdownRenderer content={line.detail} variant="compact" className="break-words" />
             </div>
           )}
-          {line.links && <CardLinks panelId={panelId} projectRoot={view.project} links={line.links} author={event.actor} />}
+          {line.links && <CardLinks panelId={panelId} board={board} projectRoot={view.project} links={line.links} author={event.actor} />}
           {line.resend !== undefined && (
             <Button variant="outline" size="sm" className="self-start" onClick={() => void run({ type: 'resend_notification', notification: line.resend! })}>
               {t('kanban.action.resend')}
diff --git a/desktop/src/components/kanban/board.test.ts b/desktop/src/components/kanban/board.test.ts
index 8322c2d9..35bcb847 100644
--- a/desktop/src/components/kanban/board.test.ts
+++ b/desktop/src/components/kanban/board.test.ts
@@ -69,9 +69,9 @@ describe('actorName', () => {
 describe('linkTarget', () => {
   const author = { kind: 'session', sessionId: 'reviewer' } as const
 
-  it('opens web addresses in the browser and absolute files through the session that wrote them', () => {
+  it('opens web addresses in the browser and absolute files through the board', () => {
     expect(linkTarget('https://example.test/pr/1', author)).toEqual({ kind: 'url', url: 'https://example.test/pr/1' })
-    expect(linkTarget('/repo/docs/review.md', author)).toEqual({ kind: 'file', path: '/repo/docs/review.md', sessionId: 'reviewer' })
+    expect(linkTarget('/repo/docs/review.md', author)).toEqual({ kind: 'file', path: '/repo/docs/review.md' })
   })
 
   it('leaves branch names, relative paths and files from a person as plain text', () => {
diff --git a/desktop/src/components/kanban/board.ts b/desktop/src/components/kanban/board.ts
index 8ea07e8f..4ad42a46 100644
--- a/desktop/src/components/kanban/board.ts
+++ b/desktop/src/components/kanban/board.ts
@@ -176,10 +176,10 @@ export function cardTreeRows(cards: readonly CardView[], collapsed: ReadonlySet<
   return rows
 }
 
-export type LinkTarget = { kind: 'url'; url: string } | { kind: 'file'; path: string; sessionId: string }
+export type LinkTarget = { kind: 'url'; url: string } | { kind: 'file'; path: string }
 
 export function linkTarget(link: string, author: KanbanActor): LinkTarget | null {
   if (/^https?:\/\//i.test(link)) return { kind: 'url', url: link }
   const absolute = link.startsWith('/') || /^[A-Za-z]:[\\/]/.test(link)
-  return absolute && author.kind === 'session' ? { kind: 'file', path: link, sessionId: author.sessionId } : null
+  return absolute && author.kind === 'session' ? { kind: 'file', path: link } : null
 }
diff --git a/desktop/src/components/kanban/useReasonPrompt.tsx b/desktop/src/components/kanban/useReasonPrompt.tsx
index 6683e2b0..04ff3d29 100644
--- a/desktop/src/components/kanban/useReasonPrompt.tsx
+++ b/desktop/src/components/kanban/useReasonPrompt.tsx
@@ -3,6 +3,7 @@ import { toast } from 'sonner'
 import type { CardStatus, CardView, KanbanCommand } from '@protocol'
 import { useTranslation, type TranslationKey } from '../../i18n'
 import { ConfirmDialog } from '../shared/ConfirmDialog'
+import { Checkbox } from '../shared/ui/checkbox'
 import { Textarea } from '../shared/ui/textarea'
 import { STATUS_LABEL, cancelImpact, moveIntent } from './board'
 import { useKanbanStore } from '../../stores/kanbanStore'
@@ -14,27 +15,33 @@ type Prompt = {
   confirmLabel: string
   required: boolean
   destructive?: boolean
-  notes?: string[]
-  command: (text: string) => KanbanCommand
+  cancel?: { dependents: number[]; children: number[] }
+  command: (text: string, choices: CancelChoices) => KanbanCommand
 }
 
+type CancelChoices = { dependents: boolean; children: boolean }
+
 function useReasonPrompt(board: string): { ask: (prompt: Prompt) => void; dialog: ReactNode } {
   const t = useTranslation()
   const run = useKanbanCommand(board)
   const fieldId = useId()
+  const dependentsId = useId()
+  const childrenId = useId()
   const [prompt, setPrompt] = useState<Prompt | null>(null)
   const [text, setText] = useState('')
+  const [choices, setChoices] = useState<CancelChoices>({ dependents: false, children: false })
   const [busy, setBusy] = useState(false)
 
   const ask = useCallback((next: Prompt) => {
     setText('')
+    setChoices({ dependents: false, children: false })
     setPrompt(next)
   }, [])
 
   const confirm = async () => {
     if (!prompt) return
     setBusy(true)
-    const ok = await run(prompt.command(text.trim()))
+    const ok = await run(prompt.command(text.trim(), choices))
     setBusy(false)
     if (ok) setPrompt(null)
   }
@@ -47,9 +54,18 @@ function useReasonPrompt(board: string): { ask: (prompt: Prompt) => void; dialog
       title={prompt?.title ?? ''}
       body={(
         <div className="flex flex-col gap-2 pt-1">
-          {prompt?.notes?.map((note) => (
-            <p key={note} role="note" className="rounded-lg bg-[var(--color-warning-container)] px-3 py-2 text-[12px] text-[var(--color-text-primary)]">{note}</p>
-          ))}
+          {prompt?.cancel?.dependents.length ? (
+            <div className="flex items-start gap-2 rounded-lg bg-[var(--color-warning-container)] px-3 py-2 text-[12px] text-[var(--color-text-primary)]">
+              <Checkbox id={dependentsId} checked={choices.dependents} onCheckedChange={(checked) => setChoices((current) => ({ ...current, dependents: checked === true }))} />
+              <label htmlFor={dependentsId}>{t('kanban.prompt.cancelDependents', { cards: prompt.cancel.dependents.map((id) => `#${id}`).join(' ') })}</label>
+            </div>
+          ) : null}
+          {prompt?.cancel?.children.length ? (
+            <div className="flex items-start gap-2 rounded-lg bg-[var(--color-warning-container)] px-3 py-2 text-[12px] text-[var(--color-text-primary)]">
+              <Checkbox id={childrenId} checked={choices.children} onCheckedChange={(checked) => setChoices((current) => ({ ...current, children: checked === true }))} />
+              <label htmlFor={childrenId}>{t('kanban.prompt.cancelChildren', { cards: prompt.cancel.children.map((id) => `#${id}`).join(' ') })}</label>
+            </div>
+          ) : null}
           <label htmlFor={fieldId} className="text-[12px] text-[var(--color-text-secondary)]">{prompt?.label}</label>
           <Textarea id={fieldId} value={text} onChange={(event) => setText(event.target.value)} rows={3} />
         </div>
@@ -105,19 +121,17 @@ export function useMoveCard(board: string) {
     const copy = REASON_PROMPTS[intent.type]
     const view = useKanbanStore.getState().views[board]
     const impact = intent.type === 'cancel' && view ? cancelImpact(view, card) : null
-    const cards = (ids: number[]) => ids.map((id) => `#${id}`).join(' ')
     ask({
-      notes: impact ? [
-        ...(impact.dependents.length ? [t('kanban.prompt.cancelDependents', { cards: cards(impact.dependents) })] : []),
-        ...(impact.children.length ? [t('kanban.prompt.cancelChildren', { cards: cards(impact.children) })] : []),
-      ] : undefined,
+      cancel: impact ?? undefined,
       title: t(copy.title, { card: `#${card.id}` }),
       label: t(copy.label),
       confirmLabel: t(copy.confirm),
       required: intent.required,
       destructive: intent.type === 'cancel',
-      command: (reason) => intent.type === 'cancel' || intent.type === 'reopen'
-        ? { type: intent.type, card: card.id, ...(reason ? { reason } : {}) }
+      command: (reason, choices) => intent.type === 'cancel'
+        ? { type: 'cancel', card: card.id, cancelDependents: choices.dependents, cancelChildren: choices.children, ...(reason ? { reason } : {}) }
+        : intent.type === 'reopen'
+          ? { type: intent.type, card: card.id, ...(reason ? { reason } : {}) }
         : { type: intent.type, card: card.id, reason },
     })
   }, [ask, board, run, t])
diff --git a/desktop/src/components/workspace/WorkspacePanel.tsx b/desktop/src/components/workspace/WorkspacePanel.tsx
index 8a80e450..4ceccb12 100644
--- a/desktop/src/components/workspace/WorkspacePanel.tsx
+++ b/desktop/src/components/workspace/WorkspacePanel.tsx
@@ -889,11 +889,11 @@ function FilesView({ sessionId }: { sessionId: string }) {
   )
 }
 
-function FileTabView({ sessionId, path }: { sessionId: string; path: string }) {
+function FileTabView({ sessionId, path, board }: { sessionId: string; path: string; board?: string }) {
   const ensurePreview = useWorkspacePanelStore((state) => state.ensurePreview)
   useEffect(() => {
-    void ensurePreview(sessionId, path, 'file')
-  }, [ensurePreview, path, sessionId])
+    void ensurePreview(sessionId, path, 'file', board)
+  }, [board, ensurePreview, path, sessionId])
   return <PreviewBody sessionId={sessionId} path={path} kind="file" fill />
 }
 
@@ -1129,7 +1129,7 @@ function OpenWorkspacePanel({ panelId: sessionId, sessionTitle, titleRowStyle, t
       case 'artifacts':
         return <ArtifactsView sessionId={sessionId} />
       case 'file':
-        return <FileTabView sessionId={tab.sessionId ?? sessionId} path={tab.path} />
+        return <FileTabView sessionId={tab.sessionId ?? sessionId} path={tab.path} board={tab.board} />
       case 'browser':
         return <BrowserView sessionId={sessionId} tab={tab} projectRoot={projectRoot} />
       case 'uiPage':
diff --git a/desktop/src/i18n/locales/en.ts b/desktop/src/i18n/locales/en.ts
index aeb98073..bd1e2ffb 100644
--- a/desktop/src/i18n/locales/en.ts
+++ b/desktop/src/i18n/locales/en.ts
@@ -1169,8 +1169,8 @@ export const en = {
   'kanban.prompt.blockLabel': 'What is it waiting for?',
   'kanban.prompt.cancelTitle': 'Cancel {card}',
   'kanban.prompt.reopenTitle': 'Reopen {card}',
-  'kanban.prompt.cancelDependents': '{cards} wait on this task and cannot start until it is done. Remove that dependency from them, or cancel them too.',
-  'kanban.prompt.cancelChildren': 'Its subtasks {cards} are not finished. Cancel them too if they are no longer needed.',
+  'kanban.prompt.cancelDependents': 'Also cancel the dependent task chains starting at {cards}. Otherwise, their dependencies on cancelled tasks are removed.',
+  'kanban.prompt.cancelChildren': 'Also cancel the unfinished subtask trees starting at {cards}.',
   'kanban.prompt.optionalReason': 'Reason (optional)',
   'kanban.prompt.requestChangesTitle': 'Send {card} back',
   'kanban.prompt.requestChangesLabel': 'What needs to change?',
diff --git a/desktop/src/i18n/locales/zh.ts b/desktop/src/i18n/locales/zh.ts
index 2f51587a..3b09e39f 100644
--- a/desktop/src/i18n/locales/zh.ts
+++ b/desktop/src/i18n/locales/zh.ts
@@ -1171,8 +1171,8 @@ export const zh: Record<TranslationKey, string> = {
   'kanban.prompt.blockLabel': '在等什么？',
   'kanban.prompt.cancelTitle': '取消 {card}',
   'kanban.prompt.reopenTitle': '重新打开 {card}',
-  'kanban.prompt.cancelDependents': '{cards} 在等这个任务完成，取消后它们开不了工。请删掉它们的这条依赖，或者一起取消。',
-  'kanban.prompt.cancelChildren': '它的子任务 {cards} 还没完成，不需要的话请一起取消。',
+  'kanban.prompt.cancelDependents': '同时递归取消从 {cards} 开始的依赖任务链；不勾选则自动移除指向已取消任务的依赖。',
+  'kanban.prompt.cancelChildren': '同时递归取消从 {cards} 开始的未完成子任务树。',
   'kanban.prompt.optionalReason': '原因（可不填）',
   'kanban.prompt.requestChangesTitle': '退回 {card}',
   'kanban.prompt.requestChangesLabel': '需要改什么？',
diff --git a/desktop/src/stores/workspacePanelStore.test.ts b/desktop/src/stores/workspacePanelStore.test.ts
index 8d1e5812..0fde7f4c 100644
--- a/desktop/src/stores/workspacePanelStore.test.ts
+++ b/desktop/src/stores/workspacePanelStore.test.ts
@@ -16,6 +16,7 @@ const mocks = vi.hoisted(() => ({
   getWorkspaceTreeMock: vi.fn(),
   getWorkspaceFileMock: vi.fn(),
   getWorkspaceDiffMock: vi.fn(),
+  getBoardFileMock: vi.fn(),
   openArtifactMock: vi.fn(),
   previewTemplateMock: vi.fn(),
 }))
@@ -29,6 +30,10 @@ vi.mock('../api/sessions', () => ({
   },
 }))
 
+vi.mock('../api/kanban', () => ({
+  kanbanApi: { file: mocks.getBoardFileMock },
+}))
+
 vi.mock('../api/artifacts', () => ({
   artifactsApi: { open: mocks.openArtifactMock },
 }))
@@ -434,6 +439,28 @@ describe('workspacePanelStore', () => {
     expect(setItemSpy).not.toHaveBeenCalled()
   })
 
+  it('loads a board file without using its author session', async () => {
+    mocks.getBoardFileMock.mockResolvedValue({
+      state: 'ok',
+      path: '/repo/review.md',
+      content: '# verified',
+      language: 'markdown',
+      size: 10,
+    })
+    const store = useWorkspacePanelStore.getState()
+
+    store.openTab('board-tab', { kind: 'file', path: '/repo/review.md', board: 'board-key' })
+    await store.ensurePreview('board-tab', '/repo/review.md', 'file', 'board-key')
+
+    expect(mocks.getBoardFileMock).toHaveBeenCalledWith('board-key', '/repo/review.md')
+    expect(mocks.getWorkspaceFileMock).not.toHaveBeenCalled()
+    expect(useWorkspacePanelStore.getState().previewsBySession['board-tab']?.['file:/repo/review.md']).toMatchObject({
+      board: 'board-key',
+      content: '# verified',
+      state: 'ok',
+    })
+  })
+
   it('keeps the cache when collapsing and allows several files open at once', async () => {
     mocks.getWorkspaceDiffMock.mockImplementation(async (_sessionId: string, path: string) => ({
       state: 'ok',
diff --git a/desktop/src/stores/workspacePanelStore.ts b/desktop/src/stores/workspacePanelStore.ts
index 3cc6116f..37d759b7 100644
--- a/desktop/src/stores/workspacePanelStore.ts
+++ b/desktop/src/stores/workspacePanelStore.ts
@@ -6,6 +6,7 @@ import {
   type WorkspaceStatusResult,
   type WorkspaceTreeResult,
 } from '../api/sessions'
+import { kanbanApi } from '../api/kanban'
 import { artifactsApi } from '../api/artifacts'
 import { designApi } from '../api/design'
 import { closeBrowser, submitBrowserInput } from '../lib/browserGuests'
@@ -38,6 +39,7 @@ export type WorkspacePreviewEntry = {
   state?: WorkspacePreviewState
   error?: string
   size?: number
+  board?: string
 }
 
 export type BrowserTabArtifact = { id: string; name: string; mtimeMs: number; canvas?: true; board?: string }
@@ -49,7 +51,7 @@ export type WorkspaceTab =
   | { id: string; kind: 'changes' }
   | { id: string; kind: 'files' }
   | { id: string; kind: 'artifacts' }
-  | { id: string; kind: 'file'; path: string; sessionId?: string }
+  | { id: string; kind: 'file'; path: string; sessionId?: string; board?: string }
   | { id: string; kind: 'browser'; url: string; title: string; root?: string; artifact?: BrowserTabArtifact; template?: BrowserTabTemplate }
   | { id: string; kind: 'terminal'; index: number; shell?: string }
   | { id: string; kind: 'uiPage'; pageId: string; revision: number; title: string }
@@ -60,7 +62,7 @@ export type WorkspaceTabKind = WorkspaceTab['kind']
 
 export type WorkspaceTabTarget =
   | { kind: 'launcher' | 'changes' | 'files' | 'artifacts' | 'terminal' }
-  | { kind: 'file'; path: string; sessionId?: string }
+  | { kind: 'file'; path: string; sessionId?: string; board?: string }
   | { kind: 'browser'; url: string; root?: string; artifact?: BrowserTabArtifact; template?: BrowserTabTemplate }
   | { kind: 'uiPage'; pageId: string; revision: number; title: string }
   | { kind: 'task'; board: string; card: number }
@@ -118,7 +120,7 @@ type WorkspacePanelStore = {
   expandPreview: (sessionId: string, path: string, kind: WorkspacePreviewKind) => Promise<void>
   collapsePreview: (sessionId: string, path: string, kind: WorkspacePreviewKind) => void
   togglePreview: (sessionId: string, path: string, kind: WorkspacePreviewKind) => Promise<void>
-  ensurePreview: (sessionId: string, path: string, kind: WorkspacePreviewKind) => Promise<void>
+  ensurePreview: (sessionId: string, path: string, kind: WorkspacePreviewKind, board?: string) => Promise<void>
   refreshPreviews: (sessionId: string) => Promise<void>
   releaseSession: (sessionId: string) => void
   clearSession: (sessionId: string) => void
@@ -233,7 +235,7 @@ function isSameTarget(tab: WorkspaceTab, target: WorkspaceTabTarget) {
     case 'artifacts':
       return tab.kind === target.kind
     case 'file':
-      return tab.kind === 'file' && tab.path === target.path && tab.sessionId === target.sessionId
+      return tab.kind === 'file' && tab.path === target.path && tab.sessionId === target.sessionId && tab.board === target.board
     case 'uiPage':
       return tab.kind === 'uiPage' && tab.pageId === target.pageId && tab.revision === target.revision
     case 'task':
@@ -252,7 +254,7 @@ function createTab(target: WorkspaceTabTarget, tabs: WorkspaceTab[]): WorkspaceT
   const id = newTabId()
   switch (target.kind) {
     case 'file':
-      return { id, kind: 'file', path: target.path, ...(target.sessionId ? { sessionId: target.sessionId } : {}) }
+      return { id, kind: 'file', path: target.path, ...(target.sessionId ? { sessionId: target.sessionId } : {}), ...(target.board ? { board: target.board } : {}) }
     case 'browser':
       return {
         id,
@@ -319,7 +321,9 @@ function isStoredTab(value: unknown): value is WorkspaceTab {
     case 'artifacts':
       return true
     case 'file':
-      return typeof tab.path === 'string' && (tab.sessionId === undefined || typeof tab.sessionId === 'string')
+      return typeof tab.path === 'string'
+        && (tab.sessionId === undefined || typeof tab.sessionId === 'string')
+        && (tab.board === undefined || typeof tab.board === 'string')
     case 'browser':
       return typeof tab.url === 'string' && typeof tab.title === 'string'
         && (tab.root === undefined || typeof tab.root === 'string')
@@ -740,10 +744,10 @@ export const useWorkspacePanelStore = create<WorkspacePanelStore>((set, get) =>
     await get().expandPreview(sessionId, path, kind)
   },
 
-  ensurePreview: async (sessionId, path, kind) => {
+  ensurePreview: async (sessionId, path, kind, board) => {
     const existing = get().previewsBySession[sessionId]?.[getWorkspacePreviewId(path, kind)]
     if (existing && existing.state !== 'error') return
-    await loadPreview(sessionId, path, kind)
+    await loadPreview(sessionId, path, kind, { board })
   },
 
   refreshPreviews: async (sessionId) => {
@@ -772,7 +776,7 @@ export const useWorkspacePanelStore = create<WorkspacePanelStore>((set, get) =>
       },
     }))
     await Promise.all(
-      Object.values(kept).map((entry) => loadPreview(sessionId, entry.path, entry.kind, { background: true })),
+      Object.values(kept).map((entry) => loadPreview(sessionId, entry.path, entry.kind, { background: true, board: entry.board })),
     )
   },
 
@@ -850,7 +854,7 @@ async function loadPreview(
   sessionId: string,
   path: string,
   kind: WorkspacePreviewKind,
-  { background = false }: { background?: boolean } = {},
+  { background = false, board }: { background?: boolean; board?: string } = {},
 ) {
   const previewId = getWorkspacePreviewId(path, kind)
   const requestKey = makePreviewKey(sessionId, previewId)
@@ -861,6 +865,7 @@ async function loadPreview(
     kind,
     title: getPathTitle(path),
     state: 'loading',
+    ...(board ? { board } : {}),
   }
   const existing = useWorkspacePanelStore.getState().previewsBySession[sessionId]?.[previewId]
   if (!background || !existing || existing.state === 'loading') {
@@ -880,7 +885,7 @@ async function loadPreview(
       return
     }
 
-    const result = await sessionsApi.getWorkspaceFile(sessionId, path)
+    const result = board ? await kanbanApi.file(board, path) : await sessionsApi.getWorkspaceFile(sessionId, path)
     if (!isLatestRequest(previewRequestIds, requestKey, requestId)) return
     setPreviewEntry(sessionId, previewId, {
       ...baseEntry,
diff --git a/desktop/vite-config.test.ts b/desktop/vite-config.test.ts
index fed9dcd5..1d253236 100644
--- a/desktop/vite-config.test.ts
+++ b/desktop/vite-config.test.ts
@@ -2,6 +2,7 @@ import { readFileSync } from 'node:fs'
 import { dirname, join } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { describe, expect, it } from 'vitest'
+import { viteWatchIgnored } from './vite.config'
 
 const desktopRoot = dirname(fileURLToPath(import.meta.url))
 
@@ -19,4 +20,13 @@ describe('desktop build compatibility', () => {
     expect(css).toContain('--color-text-secondary-a72')
     expect(css).toContain('--color-outline-a92')
   })
+
+  it('ignores sidecar build files on every platform', () => {
+    const ignored = (file: string) => viteWatchIgnored.some((pattern) => pattern.test(file))
+    expect(ignored('C:\\repo\\desktop\\.3e6f056dc3c033e1-00000001.bun-build')).toBe(true)
+    expect(ignored('/repo/desktop/.bun-cache/bun-linux-x64')).toBe(true)
+    expect(ignored('C:\\repo\\desktop\\binaries\\x86_64-pc-windows-msvc\\RCX5375.tmp')).toBe(true)
+    expect(ignored('/repo/desktop/binaries/aarch64-apple-darwin/dreamcoder-sidecar')).toBe(true)
+    expect(ignored('/repo/desktop/src/main.tsx')).toBe(false)
+  })
 })
diff --git a/desktop/vite.config.ts b/desktop/vite.config.ts
index 5fa73450..34dbb7a6 100644
--- a/desktop/vite.config.ts
+++ b/desktop/vite.config.ts
@@ -3,6 +3,12 @@ import react from '@vitejs/plugin-react'
 import tailwindcss from '@tailwindcss/vite'
 import path from 'path'
 
+export const viteWatchIgnored = [
+  /[\\/]\.[^\\/]+\.bun-build$/,
+  /[\\/]\.bun-cache(?:[\\/]|$)/,
+  /[\\/]binaries(?:[\\/]|$)/,
+]
+
 export default defineConfig({
   plugins: [react(), tailwindcss()],
   build: {
@@ -24,5 +30,8 @@ export default defineConfig({
   server: {
     port: 1420,
     strictPort: true,
+    watch: {
+      ignored: viteWatchIgnored,
+    },
   },
 })
diff --git a/src/entrypoints/sdk/controlSchemas.ts b/src/entrypoints/sdk/controlSchemas.ts
index f694eadd..98aa5e07 100644
--- a/src/entrypoints/sdk/controlSchemas.ts
+++ b/src/entrypoints/sdk/controlSchemas.ts
@@ -792,7 +792,13 @@ const kanbanUpdateCommands = () => [
   z.object({ type: z.literal('request_changes'), card: kanbanCard(), reason: kanbanNote(), links: kanbanLinks() }),
   z.object({ type: z.literal('accept'), card: kanbanCard(), summary: kanbanNote(), links: kanbanLinks() }),
   z.object({ type: z.literal('reset'), card: kanbanCard(), reason: kanbanOptionalNote() }),
-  z.object({ type: z.literal('cancel'), card: kanbanCard(), reason: kanbanOptionalNote() }),
+  z.object({
+    type: z.literal('cancel'),
+    card: kanbanCard(),
+    reason: kanbanOptionalNote(),
+    cancelDependents: z.boolean().optional(),
+    cancelChildren: z.boolean().optional(),
+  }),
   z.object({ type: z.literal('add_dependency'), card: kanbanCard(), dependsOn: kanbanCard() }),
   z.object({ type: z.literal('remove_dependency'), card: kanbanCard(), dependsOn: kanbanCard() }),
   z.object({ type: z.literal('revoke_assignment'), assignment: z.string().min(1), reason: kanbanNote() }),
diff --git a/src/server/__tests__/kanban-api.test.ts b/src/server/__tests__/kanban-api.test.ts
index 6d501978..3f2dc752 100644
--- a/src/server/__tests__/kanban-api.test.ts
+++ b/src/server/__tests__/kanban-api.test.ts
@@ -140,6 +140,22 @@ describe('/api/kanban', () => {
     expect((await api('GET', `/api/kanban/boards/${key}/cards/abc/history`)).status).toBe(400)
   })
 
+  test('reads a linked project file without the session that delivered it', async () => {
+    const key = await createBoard()
+    const report = path.join(project, 'review.md')
+    await fs.writeFile(report, '# verified')
+    const worker = await createSession()
+    await sessionService.deleteSession(worker)
+
+    const response = await api('GET', `/api/kanban/boards/${key}/files?path=${encodeURIComponent(report)}`)
+
+    expect(response.status).toBe(200)
+    expect(await json(response)).toMatchObject({ state: 'ok', content: '# verified', language: 'markdown' })
+    const outside = path.join(configDir, 'outside.md')
+    await fs.writeFile(outside, 'private')
+    expect((await api('GET', `/api/kanban/boards/${key}/files?path=${encodeURIComponent(outside)}`)).status).toBe(403)
+  })
+
   test('delivers an assignment to the session CLI as a project board message', async () => {
     const worker = await createSession()
     const key = await createBoard()
diff --git a/src/server/__tests__/kanban-model.test.ts b/src/server/__tests__/kanban-model.test.ts
index fef92dce..627714c0 100644
--- a/src/server/__tests__/kanban-model.test.ts
+++ b/src/server/__tests__/kanban-model.test.ts
@@ -185,27 +185,38 @@ describe('permission table', () => {
     expect(h.status(t1)).toBe('review')
   })
 
-  it('tells a session that cancels a card which open cards wait on it and which sub-cards are unfinished', () => {
+  it('removes dependencies on a cancelled card while leaving its unfinished sub-cards open by default', () => {
     const { h } = splitExample()
     const root = h.card('Docs', c)
     const child = h.card('Guide', c, { parent: root })
     const waiting = h.card('Release notes', human, { dependsOn: [root] })
-    const finished = h.card('Old notes', human, { dependsOn: [root] })
-    h.run({ type: 'cancel', card: finished }, human)
+    const finished = h.card('Old notes', human)
+    h.assign(finished, 'owner', 'b')
+    submitted(h, finished, b)
+    h.run({ type: 'accept', card: finished, summary: 'checked' }, human)
+    h.run({ type: 'add_dependency', card: finished, dependsOn: root }, human)
 
-    const warnings = h.run({ type: 'cancel', card: root, reason: 'plan changed' }, c)
+    h.run({ type: 'cancel', card: root, reason: 'plan changed' }, c)
 
     expect(h.status(root)).toBe('cancelled')
-    expect(warnings).toEqual([
-      `#${waiting} still depend on card #${root} and cannot start until it is done. Remove that dependency from them, or cancel them too.`,
-      `Card #${root} still has unfinished sub-cards: #${child}. Cancel them too if they are no longer needed.`,
-    ])
+    expect(h.status(child)).toBe('todo')
+    expect(h.board.cards[waiting]!.dependsOn).toEqual([])
+    expect(h.board.cards[finished]!.dependsOn).toEqual([])
   })
 
-  it('does not repeat the cancel impact to a person, whose confirmation already listed it', () => {
-    const { h, t1 } = splitExample()
-    h.card('Release notes', human, { dependsOn: [t1] })
-    expect(h.run({ type: 'cancel', card: t1 }, human)).toEqual([])
+  it('atomically cancels selected dependents and unfinished sub-cards transitively', () => {
+    const { h } = splitExample()
+    const root = h.card('Docs', c)
+    const child = h.card('Guide', c, { parent: root })
+    const grandchild = h.card('Examples', c, { parent: child })
+    const waiting = h.card('Release notes', human, { dependsOn: [root] })
+    const transitive = h.card('Publish', human, { dependsOn: [waiting] })
+
+    h.run({ type: 'cancel', card: root, cancelDependents: true, cancelChildren: true }, human)
+
+    expect([root, child, grandchild, waiting, transitive].map((id) => h.status(id))).toEqual(Array(5).fill('cancelled'))
+    expect(h.board.cards[waiting]!.dependsOn).toEqual([])
+    expect(h.board.cards[transitive]!.dependsOn).toEqual([])
   })
 
   it('lets the reviewer and a person request changes and accept', () => {
diff --git a/src/server/__tests__/kanban-service.test.ts b/src/server/__tests__/kanban-service.test.ts
index 605ea99b..7fe423b1 100644
--- a/src/server/__tests__/kanban-service.test.ts
+++ b/src/server/__tests__/kanban-service.test.ts
@@ -99,6 +99,16 @@ describe('kanban service', () => {
     await expectKanbanError(kanban.createBoard(project), 'CONFLICT')
   })
 
+  it('keeps finding boards written with the original sanitized project key', async () => {
+    const key = project.replace(/[^a-zA-Z0-9]/g, '-')
+    const file = await boardFile(key)
+    await fs.mkdir(path.dirname(file), { recursive: true })
+    await fs.writeFile(file, `${JSON.stringify({ type: 'board_created', project, seq: 1, at: '2026-11-10T00:00:00.000Z', actor: human })}\n`)
+
+    expect(await kanban.boardForSession('worker')).toBe(key)
+    await expectKanbanError(kanban.createBoard(project), 'CONFLICT')
+  })
+
   it('restores the board from its log after a restart', async () => {
     const { key } = await kanban.createBoard(project)
     await kanban.execute(key, { type: 'create_card', title: 'Write docs', status: 'todo', acceptance: ['links work'] }, human)
@@ -127,14 +137,37 @@ describe('kanban service', () => {
     expect(history.every((event) => !Number.isNaN(Date.parse(event.at)))).toBe(true)
   })
 
-  it('skips a half-written last line and keeps the events before it', async () => {
+  it('keeps new events recoverable after a half-written last line', async () => {
     const { key } = await kanban.createBoard(project)
     await kanban.execute(key, { type: 'create_card', title: 'Kept' }, human)
     await fs.appendFile(await boardFile(key), '{"type":"card_created","card":2,"ti')
 
-    const view = await service().view(key, human)
+    const recovered = service()
+    const view = await recovered.view(key, human)
+    await recovered.execute(key, { type: 'create_card', title: 'After recovery' }, human)
 
     expect(view.cards.map((card) => card.title)).toEqual(['Kept'])
+    expect((await service().view(key, human)).cards.map((card) => card.title)).toEqual(['Kept', 'After recovery'])
+  })
+
+  it('uses distinct keys for project paths with the same sanitized form', async () => {
+    const parent = await fs.mkdtemp(path.join(os.tmpdir(), 'kanban-collision-'))
+    const dotted = path.join(parent, 'repo.one')
+    const dashed = path.join(parent, 'repo-one')
+    await fs.mkdir(dotted)
+    await fs.mkdir(dashed)
+    try {
+      const first = await kanban.createBoard(dotted)
+      const second = await kanban.createBoard(dashed)
+      facts.set('dotted', fact({ projectRoot: await fs.realpath(dotted) }))
+      facts.set('dashed', fact({ projectRoot: await fs.realpath(dashed) }))
+
+      expect(second.key).not.toBe(first.key)
+      expect(await kanban.boardForSession('dotted')).toBe(first.key)
+      expect(await kanban.boardForSession('dashed')).toBe(second.key)
+    } finally {
+      await fs.rm(parent, { recursive: true, force: true })
+    }
   })
 
   it('applies concurrent commands one at a time without losing events', async () => {
diff --git a/src/server/api/kanban.ts b/src/server/api/kanban.ts
index 1cda6255..b105b3b9 100644
--- a/src/server/api/kanban.ts
+++ b/src/server/api/kanban.ts
@@ -50,6 +50,12 @@ export async function handleKanbanApi(req: Request, url: URL, segments: string[]
       return Response.json({ events: await kanban.history(key, cardId(childId)) })
     }
 
+    if (key && child === 'files' && !childId && method === 'GET') {
+      const filePath = url.searchParams.get('path')
+      if (!filePath) throw ApiError.badRequest('path query parameter is required for a board file')
+      return Response.json(await kanban.readFile(key, filePath))
+    }
+
     throw new ApiError(405, `Method ${method} not allowed on ${url.pathname}`, 'METHOD_NOT_ALLOWED')
   } catch (error) {
     return errorResponse(toApiError(error))
diff --git a/src/server/services/kanbanModel.ts b/src/server/services/kanbanModel.ts
index e8f180bb..d6b1259e 100644
--- a/src/server/services/kanbanModel.ts
+++ b/src/server/services/kanbanModel.ts
@@ -363,14 +363,35 @@ function cardList(cards: readonly Card[]): string {
   return cards.map((each) => `#${each.id}`).join(', ')
 }
 
-function cancelWarnings(board: Board, card: Card): string[] {
-  const open = (each: Card) => OPEN_STATUSES.has(each.status)
-  const dependents = Object.values(board.cards).filter((each) => open(each) && each.dependsOn.includes(card.id))
-  const children = childrenOf(board, card).filter(open)
-  return [
-    ...(dependents.length ? [`${cardList(dependents)} still depend on card #${card.id} and cannot start until it is done. Remove that dependency from them, or cancel them too.`] : []),
-    ...(children.length ? [`Card #${card.id} still has unfinished sub-cards: ${cardList(children)}. Cancel them too if they are no longer needed.`] : []),
-  ]
+function cancellationEvents(
+  board: Board,
+  card: Card,
+  command: Extract<KanbanCommand, { type: 'cancel' }>,
+): KanbanEventBody[] {
+  const cancelled = new Set([card.id])
+  let changed = true
+  while (changed) {
+    changed = false
+    for (const candidate of Object.values(board.cards)) {
+      if (cancelled.has(candidate.id) || !OPEN_STATUSES.has(candidate.status)) continue
+      const child = command.cancelChildren === true && candidate.parent !== null && cancelled.has(candidate.parent)
+      const dependent = command.cancelDependents === true && candidate.dependsOn.some((id) => cancelled.has(id))
+      if (!child && !dependent) continue
+      cancelled.add(candidate.id)
+      changed = true
+    }
+  }
+  const cards = [card, ...[...cancelled]
+    .filter((id) => id !== card.id)
+    .sort((a, b) => a - b)
+    .map((id) => board.cards[id]!)]
+  const events: KanbanEventBody[] = cards.map((candidate) => transition(candidate, 'cancelled', command.reason))
+  for (const candidate of Object.values(board.cards).sort((a, b) => a.id - b.id)) {
+    for (const dependency of candidate.dependsOn.filter((id) => cancelled.has(id))) {
+      events.push({ type: 'dependency_removed', card: candidate.id, dependsOn: dependency })
+    }
+  }
+  return events
 }
 
 function requireStatus(card: Card, allowed: CardStatus[], action: string): CommandResult | null {
@@ -539,7 +560,7 @@ function validateCardCommand(board: Board, card: Card, command: CardCommand, act
     case 'cancel': {
       const invalid = requireStatus(card, OPEN, 'cancel')
       if (invalid) return invalid
-      return ok([transition(card, 'cancelled', command.reason)], actor.kind === 'session' ? cancelWarnings(board, card) : [])
+      return ok(cancellationEvents(board, card, command))
     }
 
     case 'reopen': {
diff --git a/src/server/services/kanbanService.ts b/src/server/services/kanbanService.ts
index 30c6ba54..e847a90a 100644
--- a/src/server/services/kanbanService.ts
+++ b/src/server/services/kanbanService.ts
@@ -10,6 +10,7 @@ import type { LinkedSessionOptions } from './sessionLinksService.js'
 import { sanitizePath } from '../../utils/sessionStoragePortable.js'
 import { diagnosticsService } from './diagnosticsService.js'
 import { readJsonlFile } from './jsonlFile.js'
+import { WorkspaceService, type WorkspaceReadFileResult } from './workspaceService.js'
 import {
   NEW_SESSION,
   applyEvent,
@@ -40,6 +41,7 @@ const BOARD_KEY_PATTERN = /^[A-Za-z0-9-]+$/
 const EVENTS_FILE = 'events.jsonl'
 const URL_SCHEME = /^[a-z][a-z0-9+.-]*:\/\//i
 const FIRST_LINE_BYTES = 64 * 1024
+const workspaceFiles = new WorkspaceService(async () => null)
 
 const ERROR_STATUS: Record<KanbanServiceErrorCode, number> = {
   FORBIDDEN: 403,
@@ -105,6 +107,12 @@ function digest(value: unknown): string {
   return createHash('sha1').update(JSON.stringify(value)).digest('hex')
 }
 
+function projectBoardKey(project: string): string {
+  const prefix = sanitizePath(project)
+  const suffix = createHash('sha256').update(project).digest('hex').slice(0, 16)
+  return `${prefix}-${suffix}`
+}
+
 async function readFirstLine(filePath: string): Promise<string | null> {
   const handle = await fs.open(filePath, 'r').catch(() => null)
   if (!handle) return null
@@ -167,7 +175,19 @@ export function createKanban(deps: KanbanDeps) {
     const filePath = eventsPath(key)
     try {
       await fs.mkdir(path.dirname(filePath), { recursive: true })
-      await fs.appendFile(filePath, events.map((event) => JSON.stringify(event) + '\n').join(''), 'utf-8')
+      const handle = await fs.open(filePath, 'a+')
+      try {
+        const { size } = await handle.stat()
+        let boundary = ''
+        if (size > 0) {
+          const last = Buffer.alloc(1)
+          await handle.read(last, 0, 1, size - 1)
+          if (last[0] !== 10) boundary = '\n'
+        }
+        await handle.writeFile(boundary + events.map((event) => JSON.stringify(event) + '\n').join(''), 'utf-8')
+      } finally {
+        await handle.close()
+      }
     } catch (error) {
       void diagnosticsService.recordEvent({
         type: 'kanban_write_failed',
@@ -306,8 +326,22 @@ export function createKanban(deps: KanbanDeps) {
     await deps.discardSession(started.sessionId)
   }
 
-  async function boardExists(key: string): Promise<boolean> {
-    return loaded.has(key) || Boolean(await readFirstLine(eventsPath(key)))
+  async function boardProject(key: string): Promise<string | null> {
+    const line = await readFirstLine(eventsPath(key))
+    if (!line) return null
+    try {
+      const first = JSON.parse(line) as KanbanEvent
+      return first.type === 'board_created' ? first.project : null
+    } catch {
+      return null
+    }
+  }
+
+  async function findBoardKey(project: string): Promise<string | null> {
+    const key = projectBoardKey(project)
+    if ((await boardProject(key)) === project) return key
+    const legacy = sanitizePath(project)
+    return (await boardProject(legacy)) === project ? legacy : null
   }
 
   async function resend(key: string, failed: FailedNotification): Promise<string[]> {
@@ -343,9 +377,9 @@ export function createKanban(deps: KanbanDeps) {
     async createBoard(project: string): Promise<BoardView> {
       const actor: KanbanActor = { kind: 'human' }
       const root = await resolveProjectRoot(project)
-      const key = sanitizePath(root)
+      const key = projectBoardKey(root)
       await serialize(key, async () => {
-        if (await boardExists(key)) {
+        if (await findBoardKey(root)) {
           throw new KanbanError('CONFLICT', 'This project already has a board.')
         }
         const state: LoadedBoard = { board: emptyBoard(root), events: [] }
@@ -358,13 +392,15 @@ export function createKanban(deps: KanbanDeps) {
     async boardForSession(sessionId: string, create = false): Promise<string | null> {
       const fact = (await factsFor([sessionId])).get(sessionId)!
       if (!fact.exists || !fact.projectRoot) return null
-      const key = sanitizePath(fact.projectRoot)
-      if (await boardExists(key)) return key
+      const key = await findBoardKey(fact.projectRoot)
+      if (key) return key
       if (!create) return null
-      await this.createBoard(fact.projectRoot).catch((error: unknown) => {
+      try {
+        return (await this.createBoard(fact.projectRoot)).key
+      } catch (error) {
         if (!(error instanceof KanbanError && error.code === 'CONFLICT')) throw error
-      })
-      return key
+        return findBoardKey(fact.projectRoot)
+      }
     },
 
     async view(key: string, actor: KanbanActor): Promise<BoardView> {
@@ -413,6 +449,18 @@ export function createKanban(deps: KanbanDeps) {
       return eventsForCard(state.events, card)
     },
 
+    async readFile(key: string, filePath: string): Promise<WorkspaceReadFileResult> {
+      const state = await load(key)
+      try {
+        return await workspaceFiles.readFileFromRoot(state.board.project, filePath)
+      } catch (error) {
+        if (error instanceof Error && error.message.includes('outside workspace')) {
+          throw new KanbanError('FORBIDDEN', error.message)
+        }
+        throw error
+      }
+    },
+
     clear(): void {
       loaded.clear()
       queues.clear()
diff --git a/src/server/services/workspaceService.ts b/src/server/services/workspaceService.ts
index ead18445..94dc5e56 100644
--- a/src/server/services/workspaceService.ts
+++ b/src/server/services/workspaceService.ts
@@ -402,7 +402,14 @@ export class WorkspaceService {
     sessionId: string,
     filePath: string,
   ): Promise<WorkspaceReadFileResult> {
-    const resolvedPath = await this.resolveWorkspacePath(sessionId, filePath)
+    return this.readFileFromRoot(await this.requireWorkDir(sessionId), filePath)
+  }
+
+  async readFileFromRoot(
+    workDir: string,
+    filePath: string,
+  ): Promise<WorkspaceReadFileResult> {
+    const resolvedPath = await this.resolveWorkspacePathFromRoot(workDir, filePath)
 
     const stat = await this.safeStat(resolvedPath.absolutePath)
     if (stat.kind === 'error') {
@@ -1049,6 +1056,13 @@ export class WorkspaceService {
     requestedPath: string,
   ): Promise<WorkspacePathResolution> {
     const workDir = await this.requireWorkDir(sessionId)
+    return this.resolveWorkspacePathFromRoot(workDir, requestedPath)
+  }
+
+  private async resolveWorkspacePathFromRoot(
+    workDir: string,
+    requestedPath: string,
+  ): Promise<WorkspacePathResolution> {
     const workspaceRoot = await this.getWorkspaceRoot(workDir)
     if (workspaceRoot.kind === 'missing') {
       throw new Error(`Workspace root is missing: ${workDir}`)
diff --git a/src/tools/KanbanListTool/kanbanTools.test.ts b/src/tools/KanbanListTool/kanbanTools.test.ts
index a56d39b0..208e31e0 100644
--- a/src/tools/KanbanListTool/kanbanTools.test.ts
+++ b/src/tools/KanbanListTool/kanbanTools.test.ts
@@ -154,7 +154,7 @@ describe('kanban tools', () => {
     const input = KanbanUpdateTool.inputSchema.parse({ command: { type: 'cancel', card: 4, reason: 'not needed' } })
     expect(await KanbanUpdateTool.checkPermissions(input, {} as never)).toMatchObject({
       behavior: 'ask',
-      message: 'Cancel card #4?',
+      message: 'Cancel card #4 and remove dependencies on the cancelled cards?',
       decisionReason: { type: 'safetyCheck', classifierApprovable: false },
     })
     expect((await hasPermissionsToUseTool(KanbanUpdateTool, input, context as never, undefined as never, 'id')).behavior).toBe('ask')
diff --git a/src/tools/KanbanUpdateTool/KanbanUpdateTool.ts b/src/tools/KanbanUpdateTool/KanbanUpdateTool.ts
index 5aeae6f5..97a56d72 100644
--- a/src/tools/KanbanUpdateTool/KanbanUpdateTool.ts
+++ b/src/tools/KanbanUpdateTool/KanbanUpdateTool.ts
@@ -81,9 +81,13 @@ export const KanbanUpdateTool = buildTool({
   async checkPermissions(input) {
     const { command } = input
     if (command.type === 'cancel') {
+      const effects = [
+        command.cancelDependents ? 'cancel open dependent cards transitively' : 'remove dependencies on the cancelled cards',
+        ...(command.cancelChildren ? ['cancel unfinished sub-cards transitively'] : []),
+      ]
       return {
         behavior: 'ask',
-        message: `Cancel card #${command.card}?`,
+        message: `Cancel card #${command.card} and ${effects.join(' and ')}?`,
         updatedInput: input,
         decisionReason: { type: 'safetyCheck', reason: KANBAN_CANCEL_PERMISSION_REASON, classifierApprovable: false },
       }
diff --git a/src/tools/KanbanUpdateTool/prompt.ts b/src/tools/KanbanUpdateTool/prompt.ts
index 038eb85b..2af3bc53 100644
--- a/src/tools/KanbanUpdateTool/prompt.ts
+++ b/src/tools/KanbanUpdateTool/prompt.ts
@@ -31,7 +31,7 @@ As the creator:
 - When the owner questions an acceptance criterion, decide whether to change it. Change it with edit_card and tell the owner, or tell the owner why it stays. When the user should decide, ask the user in this session first.
 - Choose the reviewer: assign with role "reviewer", or start a new session in that role with ${START_SESSION_TOOL_NAME}. Whoever reviews now is replaced and told so. Put its review instructions in note: what to check and by which standard, for example reviewing the code or helping the user try the result; without a note it gets general instructions. When you also own the card, the user approves every reviewer you choose.
 - move_card (between Backlog and Todo), reset (back to Todo) and revoke_assignment. Reset tells the owner.
-- cancel, when the card is no longer needed. The user approves every cancel. It tells the owner, and the result lists the open cards that depend on it and its unfinished sub-cards: remove those dependencies or cancel those cards too, so nothing is left waiting on it.
+- cancel, when the card is no longer needed. The user approves every cancel. Set cancelDependents to cancel open cards that depend on it and cancelChildren to cancel its unfinished sub-cards; both choices apply transitively. Without cancelDependents, dependencies on every cancelled card are removed atomically so nothing is left waiting on it.
 
 Any session may add_update: record progress, a comment or a decision (kind "progress", "comment" or "decision"). It is saved on the card and notifies nobody.