@linxin666/dsh-client-ui-task-board 0.4.5 → 0.4.7

package/src/client/locales.ts

@@ -152,6 +152,7 @@ export const zh = {
   'detail.noSession': '暂无会话',
   'detail.executionStarted': '已启动',
   'detail.execution.initiator': '发起会话 {session}',
+  'detail.execution.external': 'Host 之外完成：{agent}',
   'detail.executionEnded': '已结束',
   'detail.result.succeeded': '成功',
   'detail.result.failed': '失败',
@@ -194,7 +195,35 @@ export const zh = {
   'detail.schedule.duration.hours': '{count} 小时',
   'detail.schedule.duration.minutes': '{count} 分钟',
   'detail.schedule.duration.seconds': '{count} 秒',
+  // 调度方式：单次计划与循环规则是两类计划，不是同一 cron 的日期限定写法。
+  'detail.schedule.mode': '调度方式',
+  'detail.schedule.mode.cron': '循环',
+  'detail.schedule.mode.once': '单次',
+  'detail.schedule.at': '执行时间',
+  'detail.schedule.atHint': '按所选时区解读的计划时刻；必须是未来时间。',
+  'detail.schedule.atInvalid': '请选择未来的有效时间',
+  'detail.schedule.plannedAt': '计划时间',
+  'detail.schedule.zoneOnceHint': '所选时刻按此时区解读。',
+  'detail.schedule.maxRuns': '次数上限',
+  'detail.schedule.maxRunsUnlimited': '不限次数',
+  'detail.schedule.maxRunsValue': '最多 {count} 次',
+  'detail.schedule.maxRunsCustom': '自定义',
+  'detail.schedule.maxRunsInvalid': '次数上限必须是正整数',
+  'detail.schedule.runs': '已执行 {done}/{total} 次',
+  'detail.schedule.runsUnlimited': '已执行 {done} 次',
+  'detail.schedule.remaining': '剩余 {count} 次',
+  'detail.schedule.cancel': '关闭调度',
+  'detail.schedule.ended': '调度已结束：{reason}',
+  'detail.schedule.skipped': '上次跳过：{reason}',
+  'detail.schedule.stop.fired': '单次计划已执行',
+  'detail.schedule.stop.limit': '已达次数上限',
+  'detail.schedule.stop.no-target': '计划已无可执行时刻',
+  'detail.schedule.stop.missed': '错过执行时刻，已跳过',
+  'detail.schedule.stop.busy': '触发时任务正在运行，已跳过',
+  'detail.schedule.stop.permission': '权限待人工确认，已跳过',
+  'detail.schedule.stop.launch-failed': '启动失败未创建执行，次数已退回',
   'card.scheduled': '定时',
+  'card.scheduledOnce': '单次',
   'new.workspace': '工作区',
   'new.agentPreset': 'Agent 预设',
   'new.permission': '权限',
@@ -218,13 +247,21 @@ export const zh = {
   'exec.permission.danger-full-access': '完全访问',
   'exec.model.default': '宿主默认（agent-default-model）',
   'exec.model.unknown': '（未知模型/回退默认）',
+  'exec.reasoning': '思考档位',
+  'exec.reasoning.inherit': '沿用模型/宿主默认',
+  'exec.reasoning.unknown': '（未知档位）',
+  'exec.reasoning.hint.pickModel': '先选择要钉住的模型，才能设置它的思考档位。',
+  'exec.reasoning.hint.unknownModel': '无法从当前名册确认该模型的可选档位；已保存的值原样保留。',
+  'exec.reasoning.hint.noEfforts': '该模型没有可选的思考档位，始终沿用模型/宿主的默认值。',
+  'exec.reasoning.hint.inherit': '留空即沿用该模型/宿主的默认档位。',
+  'exec.teamRunAutoHint': '创建或关联子任务成功后，父任务会自动开启 Agent Team 执行（可随时手动关闭）。',
   'exec.reuseSession': '在同一对话继续',
   'exec.teamRun': '用 Agent Team 执行（Leader/teammate）',
   'exec.teamRunHint': '开启后：执行本任务只启动一个 Leader 会话，每个子任务由它派生为 teammate 并在该会话内并行工作（子任务自身的权限钉住不适用）。关闭则每个成员各开独立会话。',
   'exec.teamRunUnavailable': '当前部署未提供 Agent Teams 服务，无法启用。',
   'exec.reuseSessionHint': '开启后，本任务的后续执行在上一次会话里继续（该会话空闲且仍存在时），不再每次新建对话；每次复用时都会重新应用上面钉住的权限与模型。',
   'exec.goalRun': '以 dsh 内置的 /goal 开始执行任务',
-  'exec.goalRunHint': '默认开启：执行时把任务目标作为持久目标交给 dsh 内置的 /goal，会话会自动续跑多轮，直到 agent 标记目标完成；看板在该目标真正结束后才结算本次执行。关闭则只执行一轮普通对话。',
+  'exec.goalRunHint': '默认关闭：勾选后执行时把任务目标作为持久目标交给 dsh 内置的 /goal，会话会自动续跑多轮，直到 agent 标记目标完成；看板在该目标真正结束后才结算本次执行。不勾选则只执行一轮普通对话。',
   'exec.skipVerification': '跳过本任务的验收',
   'exec.skipVerificationHint': '默认关闭：勾选后本任务以 goal 形式执行时不再拦截 update_goal 标记完成，也不要求通过验收；执行记录会标注「该卡片跳过验收」。仅对之后新开的执行生效，验收总开关关闭时本项无意义。',
   'detail.executionSettings': '执行设置',
@@ -258,9 +295,18 @@ export const zh = {
   'settings.unsaved': '未保存',
   'settings.saveFailed': '部署未接受这些值，已保留供你修改。',
   'settings.invalidNumber': '请输入数字，留空则使用默认值。',
+  'settings.sessionPollSeconds': '会话轮询间隔（秒）',
+  'settings.sessionPollSecondsHint': '默认 5 秒。仅在看板有需要核对的事情——运行中的卡片或未结算的执行——时才读取会话名册；两者都没有时不再轮询，Host 不会持续扫描持久化会话目录。取值 1–300 秒：间隔越短结算越快、Host 负载越高。',
   'settings.maxSubtaskDepth': '子任务深度上限',
   'settings.maxSubtaskDepthHint': '默认 1：一个任务只允许一层子任务，子任务不能再创建或关联子任务。最大 3。执行父任务会并发执行它的整棵子任务树，层级越深，一次执行开启的会话越多。',
   'settings.maxSubtaskDepthOption': '{depth} 层',
+  'settings.runLaunchWidth': '并发启动上限',
+  'settings.runLaunchWidthHint': '默认 3。一次执行会开启整棵子任务树，但同一刻最多只有这么多个成员在创建会话并入队 Prompt，其余成员排队等待——全部都会启动，只是分批进入运行列。默认值取自本仓「重型实施子代理并发 ≤ 3」的实测纪律。取值 1–16：越大启动越快，Host 的内存与 swap 压力越高。执行中修改只影响尚未入列的启动。',
+  'settings.runBehaviorTitle': '运行行为',
+  'settings.runBehaviorCardHint': '全局原生 /goal 执行开关（总开关，默认关闭）。',
+  'settings.goalRunGlobal': '全局启用 DSH 原生 /goal 执行',
+  'settings.goalRunGlobalHint': '默认关闭。关闭时所有任务都按普通单回合执行，不调用 dsh 内置的 /goal；只有这里开启、且任务级「以 /goal 开始执行」被勾选时，才执行原生 /goal。任务级勾选始终可操作、也不会被这里的开关改写，总开关只决定它是否生效。开关按执行启动时冻结，只影响之后新开的执行。',
+  'settings.goalRunGlobalDisabledTaskOption': '全局「原生 /goal 执行」总开关已关闭：任务级选项仍可随时勾选或取消，但暂不生效，你保存的偏好也不会被改写；开启总开关后即按该偏好执行。本次执行按普通单回合进行，未执行 goal 验收。',
   'settings.goalVerificationTitle': '任务验收',
   'settings.goalVerification': '启用任务验收',
   'settings.goalVerificationCardHint': '验收开关、裁判模型与判据阈值。',
@@ -285,11 +331,17 @@ export const zh = {
   'settings.goalVerificationEffortFallback': '所选推理强度 {requested} 不被目标模型支持，已回退为 {resolved}。',
   'settings.goalVerificationEffortFallbackNone': '所选推理强度 {requested} 不被目标模型支持，已回退为该模型默认档位（不显式传参）。',
   'settings.goalVerificationModelInvalid': '配置的验收模型不是 provider/model 形式，已回退宿主默认。',
+  'settings.cardDefaultsTitle': '新建卡片默认值',
+  'settings.cardDefaultsCardHint': '新建对话框打开时预填的 Agent 预设、权限、模型与思考档位；留空即不设置，创建卡片的行为与未配置时完全一致。它们只是预填，不改变任何既有语义，新建的卡片仍可随时修改；思考档位默认值只在卡片最终钉住的模型就是这里的默认模型时才生效。',
+  'settings.cardDefaultModeHint': '留空不钉住任何值，新建卡片照旧继承部署默认预设。取值优先级为：新建对话框里的显式选择 > 复制源卡或父任务已钉住的值 > 这里的默认值；子任务沿用父卡已钉住的值。',
+  'settings.cardDefaultPermissionHint': '留空为不设置（用会话默认）。高于会话默认权限基线的默认值仍只是预填：卡片执行前照旧需要人工确认。子任务从不沿用父卡的权限，只在父卡未钉住、且这里设置了默认值时才预填。',
+  'settings.cardDefaultModelHint': '留空为宿主默认（agent-default-model）。对话框里的显式选择优先于源卡/父卡已钉住的值，后者优先于这里的默认值；自己选了模型的调用方不借用任何默认档位。',
   'running.executing': '执行中',
   'running.verifying': '验收中',
   'running.repairing': '验收未通过修复中',
   'running.verificationPassed': '验收通过',
   'running.verificationFailed': '验收未通过',
+  'running.verificationInvalid': '验收无效，等待处理',
   'verify.title': '验收报告',
   'verify.status.passed': '通过',
   'verify.status.failed': '未通过',
@@ -297,6 +349,34 @@ export const zh = {
   'verify.status.verifying': '验收中',
   'verify.status.pending': '待验收',
   'verify.status.off': '本次执行未启用验收',
+  'verify.status.invalid': '验收无效',
+  'verify.status.invalidHeld': '验收无效，等待人工处理',
+  'verify.attemptInvalid': '第 {index} 次验收无效',
+  'verify.invalidReason.missing-finding': '未达标的判据没有对应的结构化问题反馈',
+  'verify.invalidReason.unlocatable-quote': '问题反馈引用的位置不存在于本次裁判所见的证据中',
+  'verify.invalidReason.baseline-finding': '问题反馈指向空工作基线，而不是本次执行的工作',
+  'verify.invalidReason.vacuous-finding': '问题反馈为空或空泛评价，没有说明实际观测与差异',
+  'verify.invalidReason.insufficient-evidence': '裁判看到的证据不足（例如轨迹被截断），无法支撑否决',
+  'verify.invalidReason.unknown': '未产生可用的质量判定',
+  'verify.invalidCounts': '有效质量判定 {quality}/{max} · 无效验收 {invalid}/{maxInvalid} · 验收异常 {exceptions}/{max}',
+  'verify.invalidDetail': '无效原因：{reason}',
+  'verify.criterionFindings': '结构化问题反馈（判据 · 引用位置 · 实际引用）',
+  'verify.criterionFinding': '{criterion} · {location}：“{quote}”',
+  'verify.criterionFindingFull': '{criterion} · {location}：“{quote}” 要求：{requirement} 观测：{observation} 差异：{gap}',
+  'verify.location.task': '任务要求',
+  'verify.location.trajectory': '执行轨迹',
+  'verify.location.workspace': '宿主记录的变更',
+  'verify.location.baseline': '空工作基线（不构成否决证据）',
+  'verify.location.unknown': '未标明位置',
+  'verify.detailRemoved': '本条验收的详细材料已在通过并成功结算后自动清理（不是裁判未举证）。',
+  'verify.cleanup.cleaned': '本次执行的验收专用详细材料已在通过并成功结算后自动清理；以下为保留的轻量审计凭据。',
+  'verify.cleanup.pending': '验收专用详细材料待清理（将通过并结算后启动）。',
+  'verify.cleanup.failed': '验收详细材料清理失败（已重试 {attempts} 次）：{error}；通过记录仍然有效，宿主重启后会补清。',
+  'verify.cleanup.audit': '保留凭据：第 {index} 次 · {stage} · 分数 {score} · 证据哈希 {hash}',
+  'verify.cleanup.stage.quality': '质量判定',
+  'verify.cleanup.stage.invalid': '无效验收',
+  'verify.cleanup.stage.exception': '验收异常',
+  'verify.cleanup.stage.budget': '时间预算耗尽',
   'verify.summary': '总分 {score}（阈值 {threshold}）· 空工作基线 {baseline}',
   'verify.criteria': '逐项判据',
   'verify.criterion': '{name}：{score}（阈值 {threshold}）',
@@ -315,9 +395,10 @@ export const zh = {
   'verify.usageIncomplete': '（至少一次请求的用量未知，以上为下限）',
   'verify.finalFailure': '判定依据：{reason}',
   'verify.applicability.disabled': '本次执行启动时验收开关关闭，按原有回合判定结算。',
-  'verify.applicability.goalUnavailable': '本次执行未成为 goal 执行（/goal 被拒绝或不可用），验收未强制执行。',
+  'verify.applicability.goalUnavailable': '本次执行未成为 goal 执行（卡片未勾选「以 /goal 开始执行任务」，或 /goal 被拒绝/不可用），验收未强制执行。',
   'verify.applicability.skipped': '该任务卡勾选了「跳过验收」，本次执行未经验收判定。',
   'verify.applicability.teamMember': '团队执行成员：由 Lead 的团队汇总证据统一验收。',
+  'verify.applicability.goalDisabled': '本次执行启动时全局「原生 /goal 执行」总开关关闭，按普通单回合执行：本次未执行 goal 验收，既不算已验收通过，也不因此判失败。',
   'verify.effortFallback': '推理强度回退：{requested} → {resolved}',
   'verify.thresholdValue': '{value}%',
   // 子任务（父子关系、级联执行、关联/解除关联）。
@@ -329,7 +410,8 @@ export const zh = {
   'detail.subtasks.link': '关联现有任务',
   'detail.subtasks.detach': '解除关联',
   'detail.subtasks.runningLock': '子任务正在执行，结算后才能解除关联或改挂父任务',
-  'detail.subtasks.runHint': '执行本任务会同时并发执行它的 {count} 个子任务；子任务失败不影响其它子任务继续执行。',
+  'detail.subtasks.runHint': '执行本任务会同时并发执行它 {count} 个未完成的子任务；已在完成列的子任务不会重复执行，子任务失败不影响其它子任务继续执行。',
+  'detail.subtasks.runHintSettled': '这个任务的子任务都已在完成列；执行本任务不会重复执行它们，要让某个子任务再跑一次，把它移回待办列或单独执行它。',
   'detail.subtasks.waiting': '等待子任务结算',
   'detail.subtasks.depthLimit': '当前子任务深度上限为 {depth} 层，子任务不能再创建或关联子任务。',
   'detail.subtasks.hostOnly': '连接 Host 后才能创建或关联子任务。',
@@ -515,6 +597,7 @@ export const en: Record<keyof typeof zh, string> = {
   'detail.noSession': 'No session',
   'detail.executionStarted': 'Started',
   'detail.execution.initiator': 'Initiated by session {session}',
+  'detail.execution.external': 'Completed outside this Host by {agent}',
   'detail.executionEnded': 'Ended',
   'detail.result.succeeded': 'Succeeded',
   'detail.result.failed': 'Failed',
@@ -557,7 +640,36 @@ export const en: Record<keyof typeof zh, string> = {
   'detail.schedule.duration.hours': '{count}h',
   'detail.schedule.duration.minutes': '{count}m',
   'detail.schedule.duration.seconds': '{count}s',
+  // Scheduling mode: a one-shot and a recurring rule are two kinds of plan,
+  // not the same cron expression restricted to a date.
+  'detail.schedule.mode': 'Mode',
+  'detail.schedule.mode.cron': 'Recurring',
+  'detail.schedule.mode.once': 'Once',
+  'detail.schedule.at': 'Run at',
+  'detail.schedule.atHint': 'Planned instant, read in the selected zone; it must be in the future.',
+  'detail.schedule.atInvalid': 'Choose a valid future time',
+  'detail.schedule.plannedAt': 'Planned time',
+  'detail.schedule.zoneOnceHint': 'The chosen instant is read in this zone.',
+  'detail.schedule.maxRuns': 'Run limit',
+  'detail.schedule.maxRunsUnlimited': 'Unlimited',
+  'detail.schedule.maxRunsValue': 'At most {count} runs',
+  'detail.schedule.maxRunsCustom': 'Custom',
+  'detail.schedule.maxRunsInvalid': 'The run limit must be a positive whole number',
+  'detail.schedule.runs': 'Ran {done}/{total}',
+  'detail.schedule.runsUnlimited': 'Ran {done}',
+  'detail.schedule.remaining': '{count} left',
+  'detail.schedule.cancel': 'Cancel schedule',
+  'detail.schedule.ended': 'Schedule ended: {reason}',
+  'detail.schedule.skipped': 'Last skip: {reason}',
+  'detail.schedule.stop.fired': 'the one-shot ran',
+  'detail.schedule.stop.limit': 'the run limit was reached',
+  'detail.schedule.stop.no-target': 'the plan has no reachable occurrence',
+  'detail.schedule.stop.missed': 'the instant was missed and skipped',
+  'detail.schedule.stop.busy': 'the task was already running, so the occurrence was skipped',
+  'detail.schedule.stop.permission': 'a permission awaited human confirmation, so the occurrence was skipped',
+  'detail.schedule.stop.launch-failed': 'the launch failed before any execution existed, so the run was refunded',
   'card.scheduled': 'scheduled',
+  'card.scheduledOnce': 'once',
   'new.workspace': 'Workspace',
   'new.agentPreset': 'Agent preset',
   'new.permission': 'Permission',
@@ -581,13 +693,21 @@ export const en: Record<keyof typeof zh, string> = {
   'exec.permission.danger-full-access': 'Full Access',
   'exec.model.default': 'Host default (agent-default-model)',
   'exec.model.unknown': ' (unknown / fallback to default)',
+  'exec.reasoning': 'Reasoning effort',
+  'exec.reasoning.inherit': 'Model or Host default',
+  'exec.reasoning.unknown': ' (unknown effort)',
+  'exec.reasoning.hint.pickModel': 'Pin a model first, then choose its reasoning effort.',
+  'exec.reasoning.hint.unknownModel': "The current roster cannot confirm this model's effort levels; the stored value is kept as it is.",
+  'exec.reasoning.hint.noEfforts': 'This model offers no selectable reasoning effort, so the model or Host default always applies.',
+  'exec.reasoning.hint.inherit': 'Leave it empty to follow the model or Host default.',
+  'exec.teamRunAutoHint': 'Once a subtask is created or linked, the parent task turns on Agent Team execution automatically (you can switch it off at any time).',
   '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.',
   'exec.goalRun': "Start the run with dsh's built-in /goal",
-  'exec.goalRunHint': 'On by default: the run arms dsh built-in /goal with the task objective, so the session keeps working automatic continuation rounds until the agent marks the goal complete, and the board settles the execution only when that goal really ends. Off: one plain turn.',
+  'exec.goalRunHint': 'Off by default: when checked, the run arms dsh built-in /goal with the task objective, so the session keeps working automatic continuation rounds until the agent marks the goal complete, and the board settles the execution only when that goal really ends. Unchecked: one plain turn.',
   'exec.skipVerification': 'Skip acceptance for this task',
   'exec.skipVerificationHint': 'Off by default: when checked, a goal-form run of this task no longer gates update_goal on a passing acceptance, and the execution record is marked as skipped. It applies only to executions started afterwards, and means nothing while the board-wide acceptance switch is off.',
   'detail.executionSettings': 'Execution Settings',
@@ -621,9 +741,18 @@ 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.sessionPollSeconds': 'Session poll interval (seconds)',
+  'settings.sessionPollSecondsHint': 'Default 5. The Host reads the DSH session roster only while the board has something to reconcile: a running card or an open execution. With neither it stops polling and never re-scans the persisted session directory. Range 1 to 300 seconds: a shorter interval settles runs sooner and costs the Host more.',
   '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',
+  'settings.runLaunchWidth': 'Concurrent run launches',
+  'settings.runLaunchWidthHint': 'Default 3. A run opens its whole subtree, but only this many members create their session and queue their prompt at the same time; the rest wait their turn. Every member still starts, entering the running column in batches. The default comes from this repository\'s measured guidance for heavy implementation subagents (at most three). Range 1 to 16: a larger width starts runs sooner and costs the Host more memory and swap. Edited during a run, it bounds the launches that have not been admitted yet.',
+  'settings.runBehaviorTitle': 'Run behavior',
+  'settings.runBehaviorCardHint': 'The global native /goal switch (master control, off by default).',
+  'settings.goalRunGlobal': 'Global: run tasks with dsh native /goal',
+  'settings.goalRunGlobalHint': 'Off by default. While off, every task runs one plain turn and never calls dsh built-in /goal; a run uses native /goal only when this is on AND the task-level option is checked (see the task option below). The task-level checkbox always stays operable and this switch never rewrites it: the master switch only decides whether that choice takes effect. The switch is frozen when an execution starts, so it only affects runs opened afterwards.',
+  'settings.goalRunGlobalDisabledTaskOption': 'The global native /goal switch is off: the task-level option can still be checked or cleared, but it has no effect right now and the preference you save is never rewritten; turning the global switch back on applies it. This execution runs one plain turn and performs no goal acceptance.',
   'settings.goalVerificationTitle': 'Task acceptance',
   'settings.goalVerification': 'Enable task acceptance',
   'settings.goalVerificationCardHint': 'The switch, the judge model and the criteria threshold.',
@@ -647,12 +776,18 @@ export const en: Record<keyof typeof zh, string> = {
   'settings.goalVerificationRouteMissing': 'The host serves no model catalog, so no judge route resolves: with acceptance on, a goal completion claim is refused and recorded as an acceptance anomaly.',
   'settings.goalVerificationEffortFallback': 'The selected reasoning effort {requested} is not supported by the target model; it falls back to {resolved}.',
   'settings.goalVerificationEffortFallbackNone': 'The selected reasoning effort {requested} is not supported by the target model; it falls back to that model default level (not sent explicitly).',
+  'settings.cardDefaultsTitle': 'New-card defaults',
+  'settings.cardDefaultsCardHint': 'What the new-task dialog opens with: agent preset, permission, model and reasoning effort. Blank sets nothing, so creating a card behaves exactly as it does unconfigured. They are only prefills and change no existing meaning, and every new card stays editable; the default reasoning effort applies only while a card ends up on the configured default model.',
+  'settings.cardDefaultModeHint': 'Blank pins nothing: a new card keeps following the deployment default preset. A target resolves as the explicit choice in the new-task dialog, then the value carried over from the source card or parent, then this default; a subtask keeps what its parent already pinned.',
+  'settings.cardDefaultPermissionHint': 'Blank sets nothing (the session default applies). A default above the session permission baseline is still only a prefill: the card still needs a human confirmation before it may run. A subtask never carries its parent permission; this default fills in only where the parent pinned none.',
+  'settings.cardDefaultModelHint': 'Blank is the host default (agent-default-model). An explicit choice in the dialog wins over the value carried over from the source card or parent, which wins over this default; a caller that pins a model of its own borrows no default reasoning level.',
   'settings.goalVerificationModelInvalid': 'The configured judge model is not a provider/model route; the host default is used instead.',
   'running.executing': 'Executing',
   'running.verifying': 'Verifying',
   'running.repairing': 'Fixing a failed acceptance',
   'running.verificationPassed': 'Acceptance passed',
   'running.verificationFailed': 'Acceptance failed',
+  'running.verificationInvalid': 'Invalid acceptance, waiting for a human',
   'verify.title': 'Acceptance report',
   'verify.status.passed': 'Passed',
   'verify.status.failed': 'Failed',
@@ -660,6 +795,34 @@ export const en: Record<keyof typeof zh, string> = {
   'verify.status.verifying': 'Verifying',
   'verify.status.pending': 'Not yet verified',
   'verify.status.off': 'Acceptance was off for this execution',
+  'verify.status.invalid': 'Invalid acceptance',
+  'verify.status.invalidHeld': 'Invalid acceptance, waiting for a human',
+  'verify.attemptInvalid': 'Invalid acceptance {index}',
+  'verify.invalidReason.missing-finding': 'A failing criterion carries no structured finding of its own',
+  'verify.invalidReason.unlocatable-quote': 'A finding cites a passage that is not in the evidence the judge saw',
+  'verify.invalidReason.baseline-finding': 'A finding points at the empty-work baseline instead of this execution\'s work',
+  'verify.invalidReason.vacuous-finding': 'A finding is empty or a generic evaluation with no observation or difference',
+  'verify.invalidReason.insufficient-evidence': 'The judge saw too little evidence (for example a truncated trace) to support a veto',
+  'verify.invalidReason.unknown': 'No usable quality verdict was produced',
+  'verify.invalidCounts': 'Valid quality verdicts {quality}/{max} · invalid acceptances {invalid}/{maxInvalid} · anomalies {exceptions}/{max}',
+  'verify.invalidDetail': 'Invalid because: {reason}',
+  'verify.criterionFindings': 'Structured findings (criterion · cited location · verbatim citation)',
+  'verify.criterionFinding': '{criterion} · {location}: "{quote}"',
+  'verify.criterionFindingFull': '{criterion} · {location}: "{quote}" requirement: {requirement} observed: {observation} gap: {gap}',
+  'verify.location.task': 'task statement',
+  'verify.location.trajectory': 'execution trajectory',
+  'verify.location.workspace': 'host-recorded changes',
+  'verify.location.baseline': 'empty-work baseline (not evidence against the work)',
+  'verify.location.unknown': 'location not named',
+  'verify.detailRemoved': 'This attempt detail was cleaned up automatically after the execution passed and settled (the judge did report evidence).',
+  'verify.cleanup.cleaned': 'The acceptance-only detail of this execution was cleaned up automatically after it passed and settled; what remains is the lightweight audit credential.',
+  'verify.cleanup.pending': 'The acceptance-only detail is pending cleanup (started once the execution passes and settles).',
+  'verify.cleanup.failed': 'Cleaning the acceptance detail failed after {attempts} attempts: {error}. The pass record is still valid and the host retries on its next start.',
+  'verify.cleanup.audit': 'Kept credential: attempt {index} · {stage} · score {score} · evidence hash {hash}',
+  'verify.cleanup.stage.quality': 'quality verdict',
+  'verify.cleanup.stage.invalid': 'invalid acceptance',
+  'verify.cleanup.stage.exception': 'acceptance anomaly',
+  'verify.cleanup.stage.budget': 'time budget exhausted',
   'verify.summary': 'Total {score} (threshold {threshold}) · empty-work baseline {baseline}',
   'verify.criteria': 'Per-criterion scores',
   'verify.criterion': '{name}: {score} (threshold {threshold})',
@@ -678,9 +841,10 @@ export const en: Record<keyof typeof zh, string> = {
   'verify.usageIncomplete': ' (at least one request usage is unknown; these counts are a floor)',
   'verify.finalFailure': 'Verdict basis: {reason}',
   'verify.applicability.disabled': 'Acceptance was off when this execution started; it settles on the historical verdict.',
-  'verify.applicability.goalUnavailable': 'This execution never became a goal run (/goal was refused or unavailable), so acceptance was not enforced.',
+  'verify.applicability.goalUnavailable': 'This execution never became a goal run (the card did not check Start with /goal, or /goal was refused or unavailable), so acceptance was not enforced.',
   'verify.applicability.skipped': 'This card checked Skip acceptance, so the execution was never judged.',
   'verify.applicability.teamMember': 'Team member: the Lead team-summary evidence is accepted as one execution.',
+  'verify.applicability.goalDisabled': 'The global native /goal switch was off when this execution started, so it ran one plain turn: no goal acceptance was performed, which neither counts as a pass nor fails the run.',
   'verify.effortFallback': 'Reasoning effort fallback: {requested} → {resolved}',
   'verify.thresholdValue': '{value}%',
   // Subtasks (parent/child links, cascade runs, link/detach).
@@ -692,7 +856,8 @@ export const en: Record<keyof typeof zh, string> = {
   '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.runHint': 'Running this task also runs its {count} unfinished subtasks concurrently; a subtask already in the done column is not run again, and one subtask failing does not stop the others.',
+  'detail.subtasks.runHintSettled': 'Every subtask of this task is already in the done column; running this task does not repeat them. To run one again, move it back to the todo column or run it on its own.',
   '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.',

package/src/client/plugin-card-seat.ts

@@ -86,6 +86,11 @@ export interface PluginCardSeat {
   label?: () => string
   /** Locale namespace the card renders with. */
   locale: string
+  /**
+   * Child slots this card declares and renders. Forwarded to whichever seat
+   * the host renders; absent for a card that declares none.
+   */
+  children?: Record<string, unknown>
   /** Business-face factory of the registration. */
   inject?: () => object
   /**
@@ -162,12 +167,14 @@ export function installPluginCard(ctx: PluginCardContext, seat: PluginCardSeat):
           ...(seat.order === undefined ? {} : { order: seat.order }),
           ...(seat.label === undefined ? {} : { label: seat.label }),
           locale: seat.locale,
+          ...(seat.children === undefined ? {} : { children: seat.children }),
           ...(seat.inject === undefined ? {} : { inject }),
         }
         : {
           name: OFFICIAL_PLUGIN_CARD_SEAT,
           key: seat.bundle,
           locale: seat.locale,
+          ...(seat.children === undefined ? {} : { children: seat.children }),
           ...(seat.inject === undefined ? {} : { inject }),
         }) as never, component) as () => void
       current = target

package/src/client/schedule-zone.ts

@@ -7,8 +7,9 @@
  * the Host schedules with (`core/schedule.ts`), so the preview a user sees is
  * computed by the code that will actually arm the rule.
  */
-import { isValidTimeZone } from '../core/schedule.ts'
-import { t } from './locales.ts'
+import { isValidTimeZone, partsInZone, resolveHostTimeZone, zonedEpoch } from '../core/schedule.ts'
+import { scheduleRunBudget, type ScheduleRule, type ScheduleStopReason } from '../core/tasks.ts'
+import { t, type TaskBoardKey } from './locales.ts'
 
 /** One selectable zone, in the order the picker shows it. */
 export interface ZoneChoice {
@@ -112,6 +113,103 @@ export function relativeTimeLabel(targetMs: number, now: number): string {
   return `${durationParts(delta)}`
 }
 
+/** Zero-pad a calendar/clock field for a `datetime-local` value. */
+function pad(value: number): string {
+  return String(value).padStart(2, '0')
+}
+
+/**
+ * The `datetime-local` input value for an instant, read in an explicit zone:
+ * `YYYY-MM-DDTHH:mm`. Uses the shared engine's zone reader, so the editor
+ * shows the same wall clock the Host schedules by.
+ * @param epochMs - the instant to render.
+ * @param timeZone - zone to read it in; absent uses the Host zone.
+ * @returns the input value.
+ */
+export function zonedInputValue(epochMs: number, timeZone?: string): string {
+  const parts = partsInZone(usableZone(timeZone), epochMs)
+  return `${parts.year}-${pad(parts.month)}-${pad(parts.day)}T${pad(parts.hour)}:${pad(parts.minute)}`
+}
+
+/**
+ * Parse a `datetime-local` input value back to an instant, read in an explicit
+ * zone. Returns undefined when the text is not a whole calendar wall clock or
+ * names one the zone skips (a spring-forward gap), so the editor can refuse an
+ * unusable instant instead of silently moving it.
+ * @param value - the input text.
+ * @param timeZone - zone to interpret it in; absent uses the Host zone.
+ * @returns the instant, or undefined when it is not a usable wall clock.
+ */
+export function parseZonedInput(value: string, timeZone?: string): number | undefined {
+  const match = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})/.exec(value.trim())
+  if (match === null) return undefined
+  const [year, month, day, hour, minute] = match.slice(1).map(Number)
+  if (month < 1 || month > 12 || day < 1 || day > 31 || hour > 23 || minute > 59) return undefined
+  return zonedEpoch(usableZone(timeZone), year, month, day, hour, minute)
+}
+
+/**
+ * The default instant a new one-shot editor opens on: the next whole hour,
+ * rendered in the zone the rule will be read in.
+ * @param now - reference instant.
+ * @param timeZone - zone the rule is read in.
+ * @returns the input value for a near-future default.
+ */
+export function defaultZonedInputValue(now: number, timeZone?: string): string {
+  const nextHour = Math.ceil(now / 3_600_000) * 3_600_000
+  return zonedInputValue(nextHour, timeZone)
+}
+
+/** The zone the input helpers resolve against: an explicit resolved zone, or the Host zone. */
+function usableZone(timeZone: string | undefined): string {
+  return timeZone !== undefined && isValidTimeZone(timeZone) ? timeZone : resolveHostTimeZone()
+}
+
+/**
+ * The editor's run-cap option for a stored cap: the two named presets, the
+ * unlimited entry, or a custom value the editor shows in its own field.
+ * @param maxRuns - the stored cap, when any.
+ * @returns the select option value.
+ */
+export function runCapOption(maxRuns: number | undefined): string {
+  if (maxRuns === undefined) return 'unlimited'
+  if (maxRuns === 1) return '1'
+  if (maxRuns === 2) return '2'
+  return 'custom'
+}
+
+/** The locale key describing why a rule stopped or skipped an occurrence. */
+export function stopReasonKey(reason: ScheduleStopReason): TaskBoardKey {
+  return `detail.schedule.stop.${reason}` as TaskBoardKey
+}
+
+/**
+ * The run-budget line: how many scheduled executions the Host opened and how
+ * many remain. Derived from the counter and the cap rather than stored, so the
+ * display cannot drift from the ledger.
+ * @param rule - the schedule rule.
+ * @returns localized wording.
+ */
+export function budgetLabel(rule: ScheduleRule): string {
+  const budget = scheduleRunBudget(rule)
+  const done = String(rule.runCount)
+  if (budget === undefined) return t('detail.schedule.runsUnlimited', { done })
+  const remaining = Math.max(budget - rule.runCount, 0)
+  return `${t('detail.schedule.runs', { done, total: String(budget) })} · ${t('detail.schedule.remaining', { count: String(remaining) })}`
+}
+
+/** The line describing a rule that stopped itself, or undefined while it may still fire. */
+export function endedLabel(rule: ScheduleRule): string | undefined {
+  if (rule.endedReason === undefined) return undefined
+  return t('detail.schedule.ended', { reason: t(stopReasonKey(rule.endedReason)) })
+}
+
+/** The line describing the last skipped occurrence, or undefined when none. */
+export function skippedLabel(rule: ScheduleRule): string | undefined {
+  if (rule.skippedReason === undefined) return undefined
+  return t('detail.schedule.skipped', { reason: t(stopReasonKey(rule.skippedReason)) })
+}
+
 /**
  * The full next-run label: the absolute wall clock in the schedule's own zone,
  * plus the relative distance in parentheses. Showing both matters because a

package/src/client/settings-entry-form.ts

@@ -52,7 +52,6 @@ function pendingSnapshot<T>(): ConfigFormSnapshot<T> {
     user: undefined,
     revision: undefined,
     writable: false,
-    mode: 'host',
   }
 }
 

package/src/core/card-defaults.ts

@@ -0,0 +1,132 @@
+/**
+ * New-card defaults: the execution targets a freshly created card starts from,
+ * and how they combine with what the caller picked and with the card a subtask
+ * or a duplicate is created from.
+ *
+ * Framework-free (no cordis, no runtime imports) because BOTH halves compile
+ * it: the Host resolves the seed when it writes the card, and the browser
+ * resolves the same seed to open the new-task dialog on it. One pure function
+ * is the only place the rules live, so the dialog and the ledger cannot drift.
+ *
+ * Every target is resolved in ONE order: what the caller picked wins over the
+ * value carried over from the card this one is created from, which wins over
+ * the board's new-card defaults, and a target nothing supplies stays blank
+ * ("no pin, resolved at run time"). A duplicate is a copy of its source and a
+ * subtask is derived from its parent, so both keep the source's own pins and
+ * fill only the fields that source left unset.
+ *
+ * The permission of a PARENT is the one exception: it never participates. The
+ * permission is not copied onto a card at creation — doing so would also have
+ * to copy the parent's human confirmation to stay runnable, and a detached
+ * child would keep both, so one confirmed parent would mint unbounded confirmed
+ * elevated roots. It is resolved along the ancestor chain at launch instead
+ * (core/subtask.ts), which is what makes detaching remove the inheritance by
+ * construction. A duplicate is not a hierarchy link, so it copies the
+ * permission like every other target. The board's own default permission is not
+ * a parent binding either and does apply to a subtask; it only pre-fills the
+ * card, and a value above the session baseline still needs a human
+ * confirmation before the card may run.
+ *
+ * The reasoning level is bound to the model route it was chosen for and never
+ * crosses to another one:
+ *
+ *   - a level the caller picked is used as it stands;
+ *   - a caller that pinned a model of its own inherits no level at all, not
+ *     even one the same model happens to carry on the source card;
+ *   - otherwise the source card's level travels with the source value it was
+ *     stored on, exactly as the card's own model/level pair does, and wins over
+ *     the board default level, so a board that configures none behaves exactly
+ *     as the create path always has;
+ *   - a board default level applies only while the card's final model IS the
+ *     configured default model, and a blank default model makes it inert —
+ *     a level the resolved model does not declare could only be refused by
+ *     model selection at run time.
+ */
+import type { TaskRecord } from './tasks.ts'
+
+/** The board's configured new-card defaults; a blank target means "not set". */
+export interface CardDefaults {
+  /** Agent preset a new card starts from. */
+  mode?: string
+  /** Permission a new card starts from. */
+  permission?: string
+  /** Model a new card starts from. */
+  model?: string
+  /** Reasoning level a new card starts from, for the model above. */
+  reasoningEffort?: string
+}
+
+/** The card a new one is created from, and how it is derived from it. */
+export interface CardTargetSource {
+  /** A copy of the source card, or a subtask of it. */
+  kind: 'duplicate' | 'parent'
+  /** The source card's execution targets. */
+  task: Pick<TaskRecord, 'mode' | 'permission' | 'model' | 'reasoningEffort'>
+}
+
+/** The resolved targets of the card about to be created; blank means "unset". */
+export interface CardTargetSeed {
+  mode: string
+  permission: string
+  model: string
+  reasoningEffort: string
+}
+
+/** Trim one optional target: blank text means "not set", like every stored pin. */
+function textOf(value: string | undefined): string {
+  return value?.trim() ?? ''
+}
+
+/**
+ * Resolve the execution targets a new card starts from.
+ * @param defaults - the board's configured new-card defaults, if any.
+ * @param source - the card this one is created from (a duplicate or a parent), if any.
+ * @param picked - what the caller chose explicitly; a non-blank value wins.
+ * @returns the four targets, blank where nothing supplies a value.
+ */
+export function resolveCardTargets(
+  defaults: CardDefaults | undefined,
+  source: CardTargetSource | undefined,
+  picked?: Partial<CardTargetSeed>,
+): CardTargetSeed {
+  const defaultMode = textOf(defaults?.mode)
+  const defaultPermission = textOf(defaults?.permission)
+  const defaultModel = textOf(defaults?.model)
+  // A default level with no default model of its own names no route to bind to
+  // (only a hand-edited settings document can express that), so it is inert.
+  const defaultEffort = defaultModel === '' ? '' : textOf(defaults?.reasoningEffort)
+  const chosen = {
+    mode: textOf(picked?.mode),
+    permission: textOf(picked?.permission),
+    model: textOf(picked?.model),
+    reasoningEffort: textOf(picked?.reasoningEffort),
+  }
+  const copied = source === undefined ? undefined : {
+    mode: textOf(source.task.mode),
+    permission: textOf(source.task.permission),
+    model: textOf(source.task.model),
+    reasoningEffort: textOf(source.task.reasoningEffort),
+  }
+
+  /** The value carried over from the source card, or the board default. */
+  const inherited = (key: 'mode' | 'permission' | 'model'): string => {
+    const fallback = key === 'mode' ? defaultMode : key === 'model' ? defaultModel : defaultPermission
+    // A parent's binding never travels; a duplicate's does (it is not a link).
+    if (copied === undefined || (key === 'permission' && source?.kind === 'parent')) return fallback
+    return copied[key] === '' ? fallback : copied[key]
+  }
+
+  const mode = chosen.mode === '' ? inherited('mode') : chosen.mode
+  const permission = chosen.permission === '' ? inherited('permission') : chosen.permission
+  const model = chosen.model === '' ? inherited('model') : chosen.model
+
+  let reasoningEffort = chosen.reasoningEffort
+  if (reasoningEffort === '' && chosen.model === '') {
+    // The caller pinned no model of its own, so the level follows the source
+    // pair first and the board default second.
+    const sourced = copied === undefined ? '' : copied.reasoningEffort
+    reasoningEffort = sourced !== '' ? sourced : (model !== '' && model === defaultModel ? defaultEffort : '')
+  }
+
+  return { mode, permission, model, reasoningEffort }
+}