@linxin666/dsh-client-ui-task-board 0.4.1 → 0.4.2

package/src/client/board.module.css

@@ -1320,3 +1320,99 @@ html[data-dsh-taskboard-active]:not([data-dsh-ssh-active]) [class*='centerCol']
 .aiParseRow .primaryButton {
   flex: none;
 }
+
+/* --- subtask tree (parent link, cascade runs) ---------------------------------
+ * A subtask is an ordinary card with a parent link; the badges below only mark
+ * the lineage on the board, and the detail block lists the direct children
+ * with their statuses.
+ * ----------------------------------------------------------------------------- */
+
+.cardSubtask {
+  max-width: 100%;
+  padding: 0 7px;
+  overflow: hidden;
+  border: 1px solid var(--dsw-alias-border-l2);
+  border-radius: 999px;
+  background: transparent;
+  color: var(--dsw-alias-label-secondary);
+  font-size: 10px;
+  line-height: 16px;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.cardSubtask[data-tone='failed'] {
+  color: var(--dsw-alias-state-error-primary);
+  border-color: var(--dsw-alias-state-error-primary);
+}
+
+.cardSubtask[data-tone='running'] {
+  color: var(--dsw-alias-state-warn-primary);
+  border-color: var(--dsw-alias-state-warn-primary);
+}
+
+.cardSubtask[data-tone='done'] {
+  color: var(--dsw-alias-state-success-primary);
+  border-color: var(--dsw-alias-state-success-primary);
+}
+
+.subtaskList {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+}
+
+.subtaskRow {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  padding: 6px 10px;
+  border: 1px solid var(--dsw-alias-border-l1);
+  border-radius: 8px;
+  flex-wrap: wrap;
+}
+
+.subtaskRow .linkButton:first-child {
+  flex: 1 1 auto;
+  min-width: 0;
+  text-align: left;
+  overflow-wrap: anywhere;
+}
+
+.subtaskAddRow {
+  display: flex;
+  gap: 8px;
+  flex-wrap: wrap;
+}
+
+.pickList {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  max-height: 320px;
+  overflow-y: auto;
+}
+
+.pickRow {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  padding: 6px 10px;
+  border: 1px solid var(--dsw-alias-border-l1);
+  border-radius: 8px;
+}
+
+.pickTitle {
+  flex: 1 1 auto;
+  min-width: 0;
+  font-size: 13px;
+  color: var(--dsw-alias-label-primary);
+  overflow-wrap: anywhere;
+}
+

package/src/client/host-api.ts

@@ -11,6 +11,16 @@ import {
   type TaskBoardSnapshot,
 } from '../protocol.ts'
 
+/**
+ * Client-side base for the board's routes: DOCUMENT-RELATIVE (issue #1707).
+ *
+ * The host registers `TASK_BOARD_API_PREFIX` root-absolute; the page is served
+ * with `<base href="./">`, so the browser half must drop the leading slash or
+ * a sub-path deployment escapes its entry directory. Derived from the shared
+ * constant so host and client cannot drift.
+ */
+const CLIENT_API_PREFIX = TASK_BOARD_API_PREFIX.slice(1)
+
 const IMPORT_MARKER = 'dsh.taskBoard.v2.hostImported'
 const SOURCE_KEY = 'dsh.taskBoard.v2.sourceId'
 const IMPORT_REQUEST_KEY = 'dsh.taskBoard.v2.importRequestId'
@@ -114,7 +124,7 @@ export class HttpTaskBoardHostTransport implements TaskBoardHostTransport {
   }
 
   async state(): Promise<TaskBoardSnapshot> {
-    return await this.request(`${TASK_BOARD_API_PREFIX}/state`, { cache: 'no-store' })
+    return await this.request(`${CLIENT_API_PREFIX}/state`, { cache: 'no-store' })
   }
 
   async action(action: TaskBoardAction, initiator?: string): Promise<TaskBoardSnapshot> {
@@ -123,7 +133,7 @@ export class HttpTaskBoardHostTransport implements TaskBoardHostTransport {
 
   private async post(requestId: string, action: TaskBoardAction, initiator?: string): Promise<TaskBoardSnapshot> {
     const envelope: TaskBoardActionEnvelope = { requestId, action, ...(initiator === undefined || initiator === '' ? {} : { initiator }) }
-    return await this.request(`${TASK_BOARD_API_PREFIX}/action`, {
+    return await this.request(`${CLIENT_API_PREFIX}/action`, {
       method: 'POST',
       headers: { 'content-type': 'application/json' },
       body: JSON.stringify(envelope),
@@ -154,7 +164,7 @@ export class HttpTaskBoardHostTransport implements TaskBoardHostTransport {
   async parseDraft(request: TaskBoardParseRequest, signal?: AbortSignal): Promise<TaskBoardParseDraft> {
     let response: Response
     try {
-      response = await fetch(`${TASK_BOARD_API_PREFIX}/parse`, {
+      response = await fetch(`${CLIENT_API_PREFIX}/parse`, {
         method: 'POST',
         headers: { 'content-type': 'application/json' },
         body: JSON.stringify(request),
@@ -193,7 +203,7 @@ export class HttpTaskBoardHostTransport implements TaskBoardHostTransport {
   }
 
   subscribe(listener: (event?: TaskBoardEventPayload) => void): () => void {
-    const events = new EventSource(`${TASK_BOARD_API_PREFIX}/events`)
+    const events = new EventSource(`${CLIENT_API_PREFIX}/events`)
     let lastStreamErrorNotify = 0
     events.onmessage = (message: MessageEvent<string>): void => {
       try {

package/src/client/index.ts

@@ -384,7 +384,17 @@ export function apply(ctx: ClientContext): void {
     if (enabled) mountUi()
     else uiDisposer?.()
   }
-  settingsForm.subscribe(syncEnabled)
+  const unsubscribeSettings = settingsForm.subscribe(syncEnabled)
+  // The mounted surfaces and the settings subscription belong to this fiber.
+  // The loader replaces a rebuilt bundle IN PLACE (fiber teardown and re-apply
+  // without a page reload), and that same teardown removes the dictionaries
+  // this row and board render through — a row left behind would stay visible
+  // showing raw dictionary keys, and a surviving subscription could mount a
+  // second one from a dead instance.
+  ctx.effect(() => () => {
+    unsubscribeSettings()
+    uiDisposer?.()
+  }, 'task-board: DOM surfaces')
   syncEnabled()
 }
 

package/src/client/locales.ts

@@ -157,12 +157,16 @@ export const zh = {
   'exec.mode.brokenSuffix': '（不可用）',
   'exec.mode.removed': '（已移除）',
   'exec.permission.default': '会话默认',
+  'exec.permission.inheritParent': '继承父任务（{permission}）',
   'exec.permission.read-only': '只读',
   'exec.permission.workspace-write': '工作区可写',
   'exec.permission.danger-full-access': '完全访问',
   'exec.model.default': '宿主默认（agent-default-model）',
   'exec.model.unknown': '（未知模型/回退默认）',
   'exec.reuseSession': '在同一对话继续',
+  'exec.teamRun': '用 Agent Team 执行（Leader/teammate）',
+  'exec.teamRunHint': '开启后：执行本任务只启动一个 Leader 会话，每个子任务由它派生为 teammate 并在该会话内并行工作（子任务自身的权限钉住不适用）。关闭则每个成员各开独立会话。',
+  'exec.teamRunUnavailable': '当前部署未提供 Agent Teams 服务，无法启用。',
   'exec.reuseSessionHint': '开启后，本任务的后续执行在上一次会话里继续（该会话空闲且仍存在时），不再每次新建对话；每次复用时都会重新应用上面钉住的权限与模型。',
   'detail.executionSettings': '执行设置',
   'exec.hint': '执行时生效：工作区决定执行会话落在哪个工作区；模式决定会话的 agent 预设；权限经 /permission 命令应用到会话。留空则使用运行时默认。',
@@ -170,7 +174,7 @@ export const zh = {
   'settings.title': '任务看板',
   'settings.description': '控制 Host 任务看板、agent 播报与运行期间的系统空闲睡眠保护。',
   'settings.enabled': '启用任务看板',
-  'settings.enabledHint': '关闭后隐藏侧边栏入口与看板视图。',
+  'settings.enabledHint': '关闭后隐藏侧边栏入口与看板视图，并注销 task_board_* agent 工具；开启时任何会话都可以通过这些工具读写看板、子任务与定时计划。',
   'settings.announceToAgent': '向 agent 播报任务看板',
   'settings.announceToAgentHint': '开启：每条 agent 系统提示都会包含本看板的说明；关闭：不播报，agent 仅在用户主动提及时了解看板。',
   'settings.preventIdleSleep': '阻止系统空闲睡眠',
@@ -194,6 +198,36 @@ export const zh = {
   'settings.unsaved': '未保存',
   'settings.saveFailed': '部署未接受这些值，已保留供你修改。',
   'settings.invalidNumber': '请输入数字，留空则使用默认值。',
+  'settings.maxSubtaskDepth': '子任务深度上限',
+  'settings.maxSubtaskDepthHint': '默认 1：一个任务只允许一层子任务，子任务不能再创建或关联子任务。最大 3。执行父任务会并发执行它的整棵子任务树，层级越深，一次执行开启的会话越多。',
+  'settings.maxSubtaskDepthOption': '{depth} 层',
+  // 子任务（父子关系、级联执行、关联/解除关联）。
+  'detail.parent': '父任务',
+  'detail.parent.open': '打开父任务',
+  'detail.subtasks': '子任务',
+  'detail.subtasks.empty': '还没有子任务',
+  'detail.subtasks.add': '添加子任务',
+  'detail.subtasks.link': '关联现有任务',
+  'detail.subtasks.detach': '解除关联',
+  'detail.subtasks.runningLock': '子任务正在执行，结算后才能解除关联或改挂父任务',
+  'detail.subtasks.runHint': '执行本任务会同时并发执行它的 {count} 个子任务；子任务失败不影响其它子任务继续执行。',
+  'detail.subtasks.waiting': '等待子任务结算',
+  'detail.subtasks.depthLimit': '当前子任务深度上限为 {depth} 层，子任务不能再创建或关联子任务。',
+  'detail.subtasks.hostOnly': '连接 Host 后才能创建或关联子任务。',
+  'new.subtaskTitle': '新建子任务',
+  'new.subtaskInherit': '未单独选择的执行设置继承父任务（工作区、模式、权限、模型），可在此覆盖。',
+  'link.subtask.title': '关联现有任务',
+  'link.subtask.hint': '只能关联没有父任务的在看板任务；关联后它成为本任务的子任务。',
+  'link.subtask.empty': '没有可关联的任务',
+  'link.subtask.confirm': '关联',
+  'card.subtask': '子任务',
+  'card.subtasks': '{count} 子任务',
+  'card.subtasksFailed': '{count} 失败',
+  'card.subtasksRunning': '{count} 运行中',
+  'card.subtasksBreakdown': '子任务 {total}：已完成 {done}，运行中 {running}，失败 {failed}',
+  'board.hideSubtasks': '隐藏子任务',
+  'board.showSubtasks': '显示子任务',
+  'board.subtaskFilterHint': '看板默认只显示父任务；搜索或按标签筛选时会自动展开子任务。',
 } satisfies Record<string, string>
 
 /** en dictionary, complete against the zh key set. */
@@ -348,12 +382,16 @@ export const en: Record<keyof typeof zh, string> = {
   'exec.mode.brokenSuffix': ' (unavailable)',
   'exec.mode.removed': ' (removed)',
   'exec.permission.default': 'Session default',
+  'exec.permission.inheritParent': 'Inherit parent ({permission})',
   'exec.permission.read-only': 'Read-only',
   'exec.permission.workspace-write': 'Workspace Write',
   'exec.permission.danger-full-access': 'Full Access',
   'exec.model.default': 'Host default (agent-default-model)',
   'exec.model.unknown': ' (unknown / fallback to default)',
   'exec.reuseSession': 'Continue in the same conversation',
+  'exec.teamRun': 'Run with an Agent Team (Lead + teammates)',
+  'exec.teamRunHint': 'On: running this task starts one Lead session and spawns a teammate per subtask inside it, working in parallel (a subtask permission pin does not apply). Off: every member gets its own independent session.',
+  'exec.teamRunUnavailable': 'This deployment serves no Agent Teams service, so team runs cannot be enabled.',
   'exec.reuseSessionHint': 'When on, later runs continue in the previous session (when that session is idle and still exists) instead of starting a new conversation each time; the pinned permission and model above are re-applied on every reuse.',
   'detail.executionSettings': 'Execution Settings',
   'exec.hint': 'Applied when the task runs: the workspace decides where the execution session lands; the mode composes the session\'s agent preset; the permission is applied through the /permission command. Blank = runtime default.',
@@ -361,7 +399,7 @@ export const en: Record<keyof typeof zh, string> = {
   'settings.title': 'Task Board',
   'settings.description': 'Configure the Host task board, agent announcement, and idle-system-sleep protection while work is pending.',
   'settings.enabled': 'Enable the task board',
-  'settings.enabledHint': 'When off, the sidebar entry and board view are hidden.',
+  'settings.enabledHint': 'When off, the sidebar entry and board view are hidden and the task_board_* agent tools are unregistered; while on, any session can read and drive the board, its subtasks and its schedules through those tools.',
   'settings.announceToAgent': 'Announce the task board to agents',
   'settings.announceToAgentHint': 'On: every agent system prompt includes a note about this board. Off: no announcement; agents learn about the board only when you mention it.',
   'settings.preventIdleSleep': 'Prevent idle system sleep',
@@ -385,6 +423,36 @@ export const en: Record<keyof typeof zh, string> = {
   'settings.unsaved': 'Unsaved',
   'settings.saveFailed': 'The deployment did not accept these values; they were left for you to correct.',
   'settings.invalidNumber': 'Enter a number, or leave blank to use the default.',
+  'settings.maxSubtaskDepth': 'Subtask depth limit',
+  'settings.maxSubtaskDepthHint': 'Default 1: a task may carry one level of subtasks, and a subtask cannot create or link further subtasks. Maximum 3. Running a task also runs its whole subtask tree concurrently, and every extra level opens more sessions per run.',
+  'settings.maxSubtaskDepthOption': '{depth} levels',
+  // Subtasks (parent/child links, cascade runs, link/detach).
+  'detail.parent': 'Parent task',
+  'detail.parent.open': 'Open parent task',
+  'detail.subtasks': 'Subtasks',
+  'detail.subtasks.empty': 'No subtasks yet',
+  'detail.subtasks.add': 'Add subtask',
+  'detail.subtasks.link': 'Link existing task',
+  'detail.subtasks.detach': 'Detach',
+  'detail.subtasks.runningLock': 'This subtask is running; it can be detached or re-linked once it settles',
+  'detail.subtasks.runHint': 'Running this task also runs its {count} subtasks concurrently; one subtask failing does not stop the others.',
+  'detail.subtasks.waiting': 'Waiting for subtasks',
+  'detail.subtasks.depthLimit': 'The subtask depth limit is {depth}; a subtask cannot create or link further subtasks.',
+  'detail.subtasks.hostOnly': 'Connect to the Host to create or link subtasks.',
+  'new.subtaskTitle': 'New Subtask',
+  'new.subtaskInherit': 'Execution settings left unset inherit the parent (workspace, mode, permission, model); override any of them here.',
+  'link.subtask.title': 'Link an existing task',
+  'link.subtask.hint': 'Only an on-board task without a parent can be linked; it then becomes a subtask of this task.',
+  'link.subtask.empty': 'No task can be linked',
+  'link.subtask.confirm': 'Link',
+  'card.subtask': 'subtask',
+  'card.subtasks': '{count} subtasks',
+  'card.subtasksFailed': '{count} failed',
+  'card.subtasksRunning': '{count} running',
+  'card.subtasksBreakdown': 'Subtasks {total}: {done} done, {running} running, {failed} failed',
+  'board.hideSubtasks': 'Hide subtasks',
+  'board.showSubtasks': 'Show subtasks',
+  'board.subtaskFilterHint': 'The board shows parent tasks only; a text or label filter reveals the subtasks automatically.',
 }
 
 /** The dictionary key union. */

package/src/core/controller.ts

@@ -17,7 +17,9 @@ import { applyArchiveTask, applyRestoreTask } from './use-cases/task-archive.ts'
 import { applyCreateTask } from './use-cases/task-create.ts'
 import { applyDeleteTask } from './use-cases/task-delete.ts'
 import { applyScheduleNextRun as applyScheduleRollForward, applySetSchedule } from './use-cases/task-schedule.ts'
+import { applySetParent } from './use-cases/task-parent.ts'
 import { applyUpdateTask, type TaskUpdatePatch } from './use-cases/task-update.ts'
+import { DEFAULT_SUBTASK_DEPTH } from './subtask.ts'
 import type {
   TaskBoardAction,
   TaskBoardEventPayload,
@@ -111,6 +113,13 @@ export interface ExecutionOptionsSnapshot {
   models?: readonly ExecutionModelOption[]
 }
 
+/**
+ * Host-owned state the browser mirrors. SSE frames carry the volatile subset
+ * (revision/scheduler/power); a full snapshot also carries the deployment
+ * constants the UI reads (session default permission, subtask depth).
+ */
+export type HostMirror = Pick<TaskBoardSnapshot, 'revision' | 'scheduler' | 'power' | 'sessionDefaultPermission' | 'maxSubtaskDepth' | 'teamRunAvailable'>
+
 /** Immutable controller snapshot for UI subscriptions. */
 export interface ControllerSnapshot {
   tasks: readonly TaskRecord[]
@@ -126,7 +135,7 @@ export interface ControllerSnapshot {
   /** Whether this deployment can parse pasted text into task fields (issue #1540). */
   canParseTask?: boolean
   transportError?: string
-  host?: Pick<TaskBoardSnapshot, 'revision' | 'scheduler' | 'power' | 'sessionDefaultPermission'>
+  host?: HostMirror
 }
 
 /** The selected task (resolved from the ledger), or undefined. */
@@ -173,7 +182,7 @@ export class BoardController {
   private readonly pendingTaskIds = new Set<string>()
   private readonly taskQueues = new Map<string, Promise<void>>()
   private transportError: string | undefined
-  private hostState: Pick<TaskBoardSnapshot, 'revision' | 'scheduler' | 'power' | 'sessionDefaultPermission'> | undefined
+  private hostState: HostMirror | undefined
   private remoteSubscribed = false
   private remoteInitialization: Promise<boolean> | undefined
 
@@ -291,7 +300,7 @@ export class BoardController {
 
   createTask(input: NewTaskInput): TaskRecord | undefined {
     const id = this.uuid()
-    const { task, tasks } = applyCreateTask(this.tasks, input, this.now(), id)
+    const { task, tasks } = applyCreateTask(this.tasks, input, this.now(), id, this.mirrorDepth())
     if (task === undefined) return undefined
     this.tasks = [...tasks]
     this.persistAndNotify()
@@ -302,7 +311,10 @@ export class BoardController {
   async createTaskConfirmed(input: NewTaskInput): Promise<TaskRecord | undefined> {
     if (this.deps.transport === undefined) return this.createTask(input)
     const id = this.uuid()
-    const preview = applyCreateTask(this.tasks, input, this.now(), id).task
+    // The preview must obey the SAME lineage gate the Host will: a browser-side
+    // default of one level would reject a legal subtask-of-subtask before the
+    // request is ever sent.
+    const preview = applyCreateTask(this.tasks, input, this.now(), id, this.mirrorDepth()).task
     if (preview === undefined) return undefined
     return await this.commitRemote({ kind: 'create', id, input }, id)
       ? this.tasks.find(task => task.id === id)
@@ -392,7 +404,7 @@ export class BoardController {
    * @returns true when applied.
    */
   archiveTask(id: string): boolean {
-    const { tasks, archived } = applyArchiveTask(this.tasks, id, this.now())
+    const { tasks, archived } = applyArchiveTask(this.tasks, id, this.now(), this.mirrorDepth())
     if (!archived) return false
     if (this.deps.transport !== undefined) {
       void this.commitRemote({ kind: 'archive', taskId: id }, id)
@@ -403,9 +415,27 @@ export class BoardController {
     return true
   }
 
+  /**
+   * Attach an existing task under a parent (or detach it with a null parent)
+   * through the Host. The lineage gate — parent exists and is on-board, no
+   * cycle, depth within the deployment limit — belongs to the Host; a refusal
+   * surfaces through the transport error like every other rejected action.
+   * @returns true when the link was accepted by the authority.
+   */
+  async setParent(id: string, parentId: string | null): Promise<boolean> {
+    if (this.deps.transport === undefined) {
+      const result = applySetParent(this.tasks, id, parentId, this.now(), this.mirrorDepth())
+      if (!result.applied) return false
+      this.tasks = [...result.tasks]
+      this.persistAndNotify()
+      return true
+    }
+    return await this.commitRemote({ kind: 'set-parent', taskId: id, parentId }, id)
+  }
+
   /** Restore an archived task back onto the board (same status column). */
   restoreTask(id: string): boolean {
-    const { tasks, archived } = applyRestoreTask(this.tasks, id, this.now())
+    const { tasks, archived } = applyRestoreTask(this.tasks, id, this.now(), this.mirrorDepth())
     if (!archived) return false
     if (this.deps.transport !== undefined) {
       void this.commitRemote({ kind: 'restore', taskId: id }, id).then(restored => {
@@ -604,13 +634,44 @@ export class BoardController {
     if (event !== undefined && this.hostState !== undefined && event.revision === this.hostState.revision
       && typeof event.scheduler === 'object' && event.scheduler !== null
       && typeof event.power === 'object' && event.power !== null) {
-      this.hostState = { revision: event.revision, scheduler: event.scheduler, power: event.power }
+      this.hostState = { ...this.hostState, revision: event.revision, scheduler: event.scheduler, power: event.power }
       this.notify()
       return
     }
     void this.refreshRemote()
   }
 
+  /**
+   * Deployment subtask depth limit the browser mirrors from the last Host
+   * snapshot; the fallback is the deployment default for the legacy path (no
+   * transport) and for the window before the first snapshot arrives.
+   */
+  private mirrorDepth(): number {
+    return this.hostState?.maxSubtaskDepth ?? DEFAULT_SUBTASK_DEPTH
+  }
+
+  /**
+   * Project a Host snapshot onto the browser's mirror. SSE frames and partial
+   * snapshots carry only the volatile subset (revision/scheduler/power), so the
+   * deployment constants the UI reads — the session-default permission the
+   * confirmation banner compares against and the subtask depth limit — are
+   * carried over from the last full snapshot instead of being dropped by a
+   * heartbeat frame.
+   */
+  private mirrorOf(snapshot: TaskBoardSnapshot): HostMirror {
+    const sessionDefaultPermission = snapshot.sessionDefaultPermission ?? this.hostState?.sessionDefaultPermission
+    const maxSubtaskDepth = snapshot.maxSubtaskDepth ?? this.hostState?.maxSubtaskDepth
+    const teamRunAvailable = snapshot.teamRunAvailable ?? this.hostState?.teamRunAvailable
+    return {
+      revision: snapshot.revision,
+      scheduler: snapshot.scheduler,
+      power: snapshot.power,
+      ...(sessionDefaultPermission === undefined ? {} : { sessionDefaultPermission }),
+      ...(maxSubtaskDepth === undefined ? {} : { maxSubtaskDepth }),
+      ...(teamRunAvailable === undefined ? {} : { teamRunAvailable }),
+    }
+  }
+
   private async refreshRemote(preserveError?: string): Promise<boolean> {
     const transport = this.deps.transport
     if (transport === undefined) return true
@@ -634,7 +695,7 @@ export class BoardController {
     const sameGeneration = currentLedgerId === nextLedgerId
     if (sameGeneration && this.hostState !== undefined && snapshot.revision < this.hostState.revision) return false
     this.tasks = [...snapshot.tasks]
-    this.hostState = { revision: snapshot.revision, scheduler: snapshot.scheduler, power: snapshot.power }
+    this.hostState = this.mirrorOf(snapshot)
     this.transportError = undefined
     if (this.selectedTaskId !== undefined && !this.tasks.some(task => task.id === this.selectedTaskId)) {
       this.selectedTaskId = undefined

package/src/core/store.ts

@@ -11,6 +11,7 @@
  */
 import { isValidCron } from './schedule.ts'
 import { isTaskPermission, isTaskStatus, normalizeTags, normalizeTargetId, type ScheduleRule, type TaskFreeze, type TaskRecord, type TaskPermission, type TaskStatus } from './tasks.ts'
+import { isExecutionOutcome } from './subtask.ts'
 import type { TaskHandover } from './handover.ts'
 import { sanitizeFreezeSnapshot } from './freeze-snapshot.ts'
 import { sanitizeHandover } from './handover.ts'
@@ -62,6 +63,7 @@ function isTaskRecordShape(value: unknown): value is Omit<TaskRecord, 'status'>
   if (typeof record.prompt !== 'string') return false
   if (typeof record.createdAt !== 'number') return false
   if (typeof record.updatedAt !== 'number') return false
+  if (record.parentId !== undefined && typeof record.parentId !== 'string') return false
   if (record.workspaceId !== undefined && typeof record.workspaceId !== 'string') return false
   if (record.mode !== undefined && typeof record.mode !== 'string') return false
   if (record.permission !== undefined && typeof record.permission !== 'string') return false
@@ -179,6 +181,19 @@ export function parseLedger(raw: string | null): TaskRecord[] {
     // clear a malformed persisted rule rather than leave it in the row.
     const task: TaskRecord = { ...row, status: normalizeStatus(row.status) }
     task.schedule = normalizeSchedule(row.schedule)
+    // The lineage link is repaired like every other optional field: a blank or
+    // non-string parent id clears the link instead of dropping the row. Whether
+    // the link is structurally sound (parent exists, no cycle) is decided where
+    // the whole list is known (HostTaskLedger.parseHostTasks).
+    task.parentId = normalizeTargetId(row.parentId)
+    // Cascade bookkeeping on execution records is repaired field by field too,
+    // so a hand-edited ledger degrades a run group instead of the whole task.
+    task.executions = task.executions.map(execution => ({
+      ...execution,
+      runGroupId: normalizeTargetId(execution.runGroupId),
+      ownResult: isExecutionOutcome(execution.ownResult) ? execution.ownResult : undefined,
+      ownError: typeof execution.ownError === 'string' ? execution.ownError : undefined,
+    }))
     // Execution targets are normalized like the schedule: blank strings
     // clear the pin and unknown permission strings from a future version
     // fall back to the session default instead of dropping the row.