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

package/src/client/board/VerificationReport.tsx

@@ -13,13 +13,18 @@
  * execution row's existing markup instead of extending that enum.
  */
 import {
+  MAX_INVALID_ATTEMPTS,
   MAX_QUALITY_ATTEMPTS,
   exceptionAttempts,
+  invalidAttempts,
   qualityAttempts,
   verificationPhase,
   verificationTotals,
+  type AcceptanceAuditRecord,
+  type AcceptanceCleanupRecord,
   type ExecutionVerification,
   type VerificationAttempt,
+  type VerificationCriterionFinding,
 } from '../../core/verification.ts'
 import { t } from '../locales.ts'
 import type { TaskBoardKey } from '../locales.ts'
@@ -46,24 +51,67 @@ const PHASE_STATUS_KEY: Record<ReturnType<typeof verificationPhase>, TaskBoardKe
   repairing: 'verify.status.failed',
   passed: 'verify.status.passed',
   failed: 'verify.status.failed',
+  invalid: 'verify.status.invalidHeld',
 }
 
-/** One recorded attempt: a quality verdict or an acceptance anomaly. */
-function AttemptRow({ attempt }: { attempt: VerificationAttempt }) {
-  const exception = attempt.stage === 'exception'
+/** Evidence location → locale key, for one structured finding's citation. */
+const LOCATION_KEY: Record<VerificationCriterionFinding['location'], TaskBoardKey> = {
+  task: 'verify.location.task',
+  trajectory: 'verify.location.trajectory',
+  workspace: 'verify.location.workspace',
+  baseline: 'verify.location.baseline',
+  unknown: 'verify.location.unknown',
+}
+
+/** Invalid reason → locale key. */
+function invalidReasonKey(attempt: VerificationAttempt): TaskBoardKey {
+  switch (attempt.invalidReason) {
+    case 'missing-finding': return 'verify.invalidReason.missing-finding'
+    case 'unlocatable-quote': return 'verify.invalidReason.unlocatable-quote'
+    case 'baseline-finding': return 'verify.invalidReason.baseline-finding'
+    case 'vacuous-finding': return 'verify.invalidReason.vacuous-finding'
+    case 'insufficient-evidence': return 'verify.invalidReason.insufficient-evidence'
+    default: return 'verify.invalidReason.unknown'
+  }
+}
+
+/** Audit stage → locale key (the lightweight credential after cleanup). */
+const AUDIT_STAGE_KEY: Record<AcceptanceAuditRecord['stage'], TaskBoardKey> = {
+  quality: 'verify.cleanup.stage.quality',
+  invalid: 'verify.cleanup.stage.invalid',
+  exception: 'verify.cleanup.stage.exception',
+  budget: 'verify.cleanup.stage.budget',
+}
+
+/** One recorded attempt: a quality verdict, an invalid veto, an anomaly, or a budget stop. */
+function AttemptRow({ attempt, detailRemoved }: { attempt: VerificationAttempt, detailRemoved: boolean }) {
+  // Everything that is not a quality verdict renders as an anomaly row: a
+  // budget stop carries no score either, and an invalid acceptance carries a
+  // score the board REFUSED to book, so showing either as a scored failure
+  // would read as a judgement the board never made. The invalid row gets its
+  // own badge and reason line, because it is a distinct outcome.
+  const invalid = attempt.stage === 'invalid'
+  const exception = attempt.stage !== 'quality' && !invalid
   const result = exception ? 'failed' : attempt.passed ? 'succeeded' : 'failed'
   return (
     <li className={css.executionRow} data-result={result}>
       <span className={css.executionBadge} data-result={result}>
-        {exception ? t('verify.status.exception') : attempt.passed ? t('verify.status.passed') : t('verify.status.failed')}
+        {invalid ? t('verify.status.invalid') : exception ? t('verify.status.exception') : attempt.passed ? t('verify.status.passed') : t('verify.status.failed')}
       </span>
       <span className={css.executionTimes}>
-        {exception
-          ? t('verify.attemptException', { index: String(attempt.index) })
-          : t('verify.attempt', { index: String(attempt.index) })}
+        {invalid
+          ? t('verify.attemptInvalid', { index: String(attempt.index) })
+          : exception
+            ? t('verify.attemptException', { index: String(attempt.index) })
+            : t('verify.attempt', { index: String(attempt.index) })}
         {' · '}{routeLabel(attempt)}
-        {!exception && ' · ' + t('verify.rounds', { rounds: String(attempt.rounds) })}
+        {!exception && !invalid && ' · ' + t('verify.rounds', { rounds: String(attempt.rounds) })}
       </span>
+      {invalid && (
+        <span className={css.executionTimes}>
+          {t('verify.invalidDetail', { reason: t(invalidReasonKey(attempt)) })}
+        </span>
+      )}
       {attempt.error !== undefined && <span className={css.executionTimes}>{attempt.error}</span>}
       {!exception && (
         <>
@@ -88,6 +136,25 @@ function AttemptRow({ attempt }: { attempt: VerificationAttempt }) {
           </ul>
         </>
       )}
+      {(attempt.criterionFindings ?? []).length > 0 && (
+        <>
+          <span className={css.executionTimes}>{t('verify.criterionFindings')}</span>
+          <ul className={css.executionList}>
+            {(attempt.criterionFindings ?? []).map((finding, index) => (
+              <li key={findingKey(attempt, index)} className={css.executionTimes}>
+                {t('verify.criterionFindingFull', {
+                  criterion: finding.criterionId,
+                  location: t(LOCATION_KEY[finding.location]),
+                  quote: finding.quote,
+                  requirement: finding.requirement,
+                  observation: finding.observation,
+                  gap: finding.gap,
+                })}
+              </li>
+            ))}
+          </ul>
+        </>
+      )}
       {attempt.findings.length > 0 && (
         <>
           <span className={css.executionTimes}>{t('verify.findings')}</span>
@@ -98,8 +165,12 @@ function AttemptRow({ attempt }: { attempt: VerificationAttempt }) {
           </ul>
         </>
       )}
-      {!exception && attempt.findings.length === 0 && (
-        <span className={css.executionTimes}>{t('verify.noFindings')}</span>
+      {!exception && !invalid && attempt.findings.length === 0 && (
+        // A cleaned attempt has no findings because the acceptance removed them,
+        // not because the judge gave none: saying "the judge reported no
+        // finding" here would invite exactly the misreading the cleanup rule
+        // exists to avoid.
+        <span className={css.executionTimes}>{t(detailRemoved ? 'verify.detailRemoved' : 'verify.noFindings')}</span>
       )}
       <span className={css.executionTimes}>
         {t('verify.evidence', {
@@ -145,16 +216,20 @@ export function VerificationReport({ verification }: { verification: ExecutionVe
       ? 'verify.applicability.skipped'
       : verification.applicability === 'goal-unavailable'
         ? 'verify.applicability.goalUnavailable'
-        : verification.applicability === 'team-member' ? 'verify.applicability.teamMember' : undefined
+        : verification.applicability === 'goal-disabled'
+          ? 'verify.applicability.goalDisabled'
+          : verification.applicability === 'team-member' ? 'verify.applicability.teamMember' : undefined
   return (
     <div className={css.executionTimes}>
       <span className={css.executionBadge} data-result={phase === 'passed' ? 'succeeded' : phase === 'failed' ? 'failed' : undefined}>
         {t('verify.title')} · {t(PHASE_STATUS_KEY[phase])}
       </span>
       <span className={css.executionTimes}>
-        {t('verify.counts', {
+        {t('verify.invalidCounts', {
           quality: String(qualityAttempts(verification).length),
           max: String(MAX_QUALITY_ATTEMPTS),
+          invalid: String(invalidAttempts(verification).length),
+          maxInvalid: String(MAX_INVALID_ATTEMPTS),
           exceptions: String(exceptionAttempts(verification).length),
         })}
       </span>
@@ -194,10 +269,54 @@ export function VerificationReport({ verification }: { verification: ExecutionVe
       {verification.attempts.length > 0 && (
         <ul className={css.executionList}>
           {[...verification.attempts].reverse().map(attempt => (
-            <AttemptRow key={attempt.at.toString(36) + '-' + attempt.stage + '-' + String(attempt.index)} attempt={attempt} />
+            <AttemptRow
+              key={attempt.at.toString(36) + '-' + attempt.stage + '-' + String(attempt.index)}
+              attempt={attempt}
+              detailRemoved={verification.cleanup?.state === 'cleaned'}
+            />
           ))}
         </ul>
       )}
+      {verification.cleanup !== undefined && <CleanupNotice cleanup={verification.cleanup} />}
     </div>
   )
 }
+
+/**
+ * Retention notice of one execution's acceptance detail.
+ *
+ * It exists so a reader never mistakes a cleaned-up report for a judge that
+ * produced no evidence: the notice says the detail WAS produced and was removed
+ * by the automatic cleanup, and lists the lightweight credential that survives.
+ * A pending or failed cleanup is reported the same way — never as a missing
+ * verdict and never as a revoked pass.
+ */
+function CleanupNotice({ cleanup }: { cleanup: AcceptanceCleanupRecord }) {
+  const key: TaskBoardKey = cleanup.state === 'cleaned'
+    ? 'verify.cleanup.cleaned'
+    : cleanup.state === 'failed' ? 'verify.cleanup.failed' : 'verify.cleanup.pending'
+  return (
+    <>
+      <span className={css.executionTimes}>
+        {cleanup.state === 'failed'
+          ? t(key, { attempts: String(cleanup.attempts), error: cleanup.lastError ?? '' })
+          : t(key)}
+      </span>
+      {cleanup.audit.length > 0 && (
+        <ul className={css.executionList}>
+          {cleanup.audit.map((record, index) => (
+            <li key={record.at.toString(36) + '-' + record.stage + '-' + String(index)} className={css.executionTimes}>
+              {t('verify.cleanup.audit', {
+                index: String(index + 1),
+                stage: t(AUDIT_STAGE_KEY[record.stage]),
+                score: percent(record.score),
+                hash: record.evidenceHash.slice(0, 12),
+              })}
+              {record.findingSummary === undefined ? '' : ' · ' + record.findingSummary}
+            </li>
+          ))}
+        </ul>
+      )}
+    </>
+  )
+}

package/src/client/board/model-options.ts

@@ -0,0 +1,178 @@
+/**
+ * Execution model options: the picker rows built from the official
+ * `session/modelCatalog` reply, and the reasoning-effort derivation both
+ * execution-target editors read off them (the create dialog and the detail
+ * page share one contract here, so they cannot promise different levels).
+ *
+ * The pickers must offer each model's real reasoning levels, which only the
+ * catalog declares — so the reply is normalized once, here, instead of every
+ * picker re-reading the wire shape. The fallback discovery path carries no
+ * capability metadata at all; its rows stay silent about reasoning rather than
+ * claiming a model supports none.
+ */
+import type { ExecutionModelOption } from '../../core/controller.ts'
+import type { TaskBoardKey } from '../locales.ts'
+
+/** One model's declared reasoning capability, as a picker row carries it. */
+type ModelReasoning = NonNullable<ExecutionModelOption['reasoning']>
+
+/** A plain JSON object, or undefined for anything else (including arrays). */
+function record(value: unknown): Record<string, unknown> | undefined {
+  return typeof value === 'object' && value !== null && !Array.isArray(value) ? value as Record<string, unknown> : undefined
+}
+
+/** A non-empty string, or undefined. */
+function text(value: unknown): string | undefined {
+  return typeof value === 'string' && value !== '' ? value : undefined
+}
+
+/** The effort ids an adapter published for one model, in catalog order. */
+function effortIdsOf(reasoning: Record<string, unknown>): string[] {
+  const efforts: string[] = []
+  for (const entry of Array.isArray(reasoning.efforts) ? reasoning.efforts : []) {
+    const id = text(record(entry)?.id)
+    if (id !== undefined && !efforts.includes(id)) efforts.push(id)
+  }
+  return efforts
+}
+
+/**
+ * What the catalog declares about one model's reasoning: a published
+ * `reasoning` block is what "this route reasons" means, and a model published
+ * without one is declared to have none. A model the reply never described at
+ * all is a different state, expressed by the row carrying no capability.
+ */
+function reasoningOf(model: Record<string, unknown>): ModelReasoning {
+  const reasoning = record(model.reasoning)
+  if (reasoning === undefined) return { supported: false }
+  const efforts = effortIdsOf(reasoning)
+  return { supported: true, ...(efforts.length === 0 ? {} : { efforts }) }
+}
+
+/**
+ * One picker row, or undefined when the entry carries no usable id.
+ * @param withCapability - whether this reply declares reasoning metadata at
+ * all; the flat discovery list does not, so its rows stay silent about it.
+ */
+function rowOf(model: Record<string, unknown>, provider: string | undefined, withCapability: boolean): ExecutionModelOption | undefined {
+  const id = text(model.id)
+  if (id === undefined) return undefined
+  const reasoning = withCapability ? reasoningOf(model) : undefined
+  return {
+    id: provider === undefined ? id : `${provider}/${id}`,
+    name: text(model.name) ?? id,
+    ...(provider === undefined ? {} : { provider }),
+    ...(reasoning === undefined ? {} : { reasoning }),
+  }
+}
+
+/**
+ * Normalize a `session/modelCatalog` reply into picker rows: one row per model
+ * of every provider group, keyed by the qualified route an execution pins.
+ * @param value - the raw catalog reply.
+ * @returns the rows, empty when the reply is unreadable.
+ */
+export function modelOptionsFromCatalog(value: unknown): ExecutionModelOption[] {
+  const options: ExecutionModelOption[] = []
+  const groups = record(value)?.groups
+  for (const entry of Array.isArray(groups) ? groups : []) {
+    const group = record(entry)
+    if (group === undefined) continue
+    const provider = text(group.id) ?? text(group.provider)
+    for (const item of Array.isArray(group.models) ? group.models : []) {
+      const model = record(item)
+      if (model === undefined) continue
+      const row = rowOf(model, provider, true)
+      if (row !== undefined) options.push(row)
+    }
+  }
+  return options
+}
+
+/**
+ * Normalize the flat `llm/discoverModels` list into picker rows. That reply
+ * names models only, so every row leaves the reasoning capability unknown.
+ * @param value - the raw discovery list.
+ * @returns the rows, empty when the list is unreadable.
+ */
+export function modelOptionsFromDiscoveredModels(value: unknown): ExecutionModelOption[] {
+  const options: ExecutionModelOption[] = []
+  for (const item of Array.isArray(value) ? value : []) {
+    const model = record(item)
+    if (model === undefined) continue
+    const row = rowOf(model, undefined, false)
+    if (row !== undefined) options.push(row)
+  }
+  return options
+}
+
+/**
+ * The picker rows of a model roster: the qualified `provider/model` route as
+ * the value a pin stores, and the provider beside the model name so two
+ * providers offering one model name stay distinguishable.
+ * @param models - the roster rows.
+ * @returns the choice rows, in roster order.
+ */
+export function modelChoiceRows(models: readonly ExecutionModelOption[]): Array<{ value: string; label: string }> {
+  return models.map(model => ({
+    value: model.id,
+    label: (model.provider === undefined ? '' : model.provider + ' · ') + (model.name ?? model.id),
+  }))
+}
+
+/**
+ * The capability row the roster publishes for one model route.
+ * @returns undefined when no model is pinned, or the roster does not describe
+ * the pinned one — an unknown model is not the same as a model without
+ * reasoning.
+ */
+export function reasoningOfModel(
+  models: readonly ExecutionModelOption[],
+  modelId: string,
+): ExecutionModelOption['reasoning'] | undefined {
+  if (modelId === '') return undefined
+  return models.find(item => item.id === modelId)?.reasoning
+}
+
+/**
+ * The effort ids the picker offers for a model, in catalog order.
+ * @returns an empty list when the model is unpinned, unknown, declares no
+ * reasoning, or publishes no selectable level.
+ */
+export function reasoningEffortsFor(models: readonly ExecutionModelOption[], modelId: string): string[] {
+  const reasoning = reasoningOfModel(models, modelId)
+  return reasoning?.supported === true ? [...reasoning.efforts ?? []] : []
+}
+
+/** Whether the effort picker may be operated: a pinned model with declared, selectable levels. */
+export function reasoningPickerEnabled(models: readonly ExecutionModelOption[], modelId: string): boolean {
+  return reasoningEffortsFor(models, modelId).length > 0
+}
+
+/**
+ * The effort to keep when the picked model changes. Only a model that declares
+ * its levels can invalidate one: a model the roster cannot describe keeps the
+ * stored value, because the roster has no grounds to call it invalid.
+ * @param effort - the effort currently stored/selected ('' = follow the default).
+ * @returns the effort to keep.
+ */
+export function reconcileReasoningEffort(
+  models: readonly ExecutionModelOption[],
+  modelId: string,
+  effort: string,
+): string {
+  if (effort === '') return ''
+  const reasoning = reasoningOfModel(models, modelId)
+  if (reasoning === undefined) return modelId === '' ? '' : effort
+  return reasoning.efforts?.includes(effort) === true ? effort : ''
+}
+
+/**
+ * The copy explaining why the picker is in its current state. One lookup for
+ * both editors, so the create dialog and the detail page never drift apart.
+ */
+export function reasoningHintKey(models: readonly ExecutionModelOption[], modelId: string): TaskBoardKey {
+  if (modelId === '') return 'exec.reasoning.hint.pickModel'
+  if (reasoningOfModel(models, modelId) === undefined) return 'exec.reasoning.hint.unknownModel'
+  return reasoningPickerEnabled(models, modelId) ? 'exec.reasoning.hint.inherit' : 'exec.reasoning.hint.noEfforts'
+}

package/src/client/board/preset-label.ts

@@ -42,3 +42,35 @@ export function inheritPresetLabel(presets: readonly ExecutionPresetOption[]): s
   if (fallback === undefined) return t('exec.mode.inherit')
   return t('exec.mode.inheritWith', { preset: presetLabel(fallback) })
 }
+
+/** One preset row a picker renders: the stored id, its label, and whether it may be picked. */
+export interface PresetChoiceRow {
+  /** The value a pin stores. */
+  id: string
+  /** Display label, already carrying the default and unavailable suffixes. */
+  label: string
+  /** True when the preset cannot compose a session: the row is shown but not selectable. */
+  disabled: boolean
+}
+
+/**
+ * The picker rows of one roster, split into the built-in and the user presets.
+ * Both pickers render these rows — the create dialog's mode select and the
+ * settings card's default-preset field — so their wording and their
+ * unavailable rows cannot drift apart.
+ * @param presets - the roster options.
+ * @returns one row list per group, in roster order.
+ */
+export function presetChoiceRows(presets: readonly ExecutionPresetOption[]): { builtin: PresetChoiceRow[]; custom: PresetChoiceRow[] } {
+  const row = (preset: ExecutionPresetOption): PresetChoiceRow => ({
+    id: preset.id,
+    label: presetLabel(preset)
+      + (preset.isDefault ? t('exec.mode.defaultSuffix') : '')
+      + (preset.broken !== undefined ? t('exec.mode.brokenSuffix') : ''),
+    disabled: preset.broken !== undefined,
+  })
+  return {
+    builtin: presets.filter(preset => isBuiltinPreset(preset.id)).map(row),
+    custom: presets.filter(preset => !isBuiltinPreset(preset.id)).map(row),
+  }
+}

package/src/client/board/preset-roster.ts

@@ -0,0 +1,58 @@
+/**
+ * The agent-preset roster the execution-target pickers read: one read of the
+ * generated api-remotes face, and its normalization into the option rows the
+ * board controller and the settings card's new-card-defaults topic both
+ * consume.
+ *
+ * The roster is a runtime fact of the deployment, not ledger state. The
+ * namespace mounts with the official api-remotes assembly, so the read itself
+ * is wired through a scoped inject at the call site (see src/client/index.ts);
+ * this module owns only the shape both consumers agree on, so neither has to
+ * know how the wire face answers.
+ */
+import type { ClientRemote } from '@deepseek-ai/dsh-api-remotes/client'
+import type { ExecutionPresetOption } from '../../core/controller.ts'
+
+/** The generated Remote namespace the mode pickers read their roster from. */
+export type PresetRemote = ClientRemote['agentPresets']
+
+/** One agent-preset row the wire face answers with. */
+export interface PresetRosterRow {
+  id: string
+  name?: string
+  description?: string
+  /** Why this preset cannot compose a session; absent when it can. */
+  broken?: string
+  isDefault: boolean
+}
+
+/**
+ * Read the agent-preset roster of one deployment. The caller passes the
+ * namespace resolved inside its scoped inject, so a host that serves no such
+ * namespace never reaches here; a host that serves it answers `ok: false`
+ * instead, which leaves the caller's options untouched.
+ * @param remote - the `remote.agentPresets` namespace.
+ * @returns the roster, or a failed read the caller ignores.
+ */
+export async function readPresetRoster(remote: PresetRemote): Promise<{ ok: boolean; presets: readonly PresetRosterRow[] }> {
+  const response = await remote.list()
+  if (!response.ok) return { ok: false, presets: [] }
+  return { ok: true, presets: response.value.presets }
+}
+
+/**
+ * Normalize one roster into the picker rows the UI consumes. A preset that
+ * cannot compose a session keeps its `broken` reason: the pickers show it and
+ * disable it, so a missing preset never looks like a missing roster.
+ * @param presets - the roster rows.
+ * @returns the picker options.
+ */
+export function presetOptionsFromRoster(presets: readonly PresetRosterRow[]): ExecutionPresetOption[] {
+  return presets.map(preset => ({
+    id: preset.id,
+    name: preset.name,
+    description: preset.description,
+    broken: preset.broken,
+    isDefault: preset.isDefault,
+  }))
+}

package/src/client/board/status-key.ts

@@ -23,6 +23,9 @@ export const VERIFICATION_PHASE_KEY: Record<VerificationPhase, TaskBoardKey> = {
   repairing: 'running.repairing',
   passed: 'running.verificationPassed',
   failed: 'running.verificationFailed',
+  // Held for a human: the judge produced no usable veto, so this is NOT the
+  // quality-failure label.
+  invalid: 'running.verificationInvalid',
 }
 
 /**

package/src/client/board/team-run-promotion.ts

@@ -0,0 +1,39 @@
+/**
+ * Team-run promotion for a parent card that just gained a subtask. A card with
+ * subtasks is exactly what the Agent Team mode is for, so the two join actions
+ * (create a subtask, link an existing task) opt the parent in — but only after
+ * the Host confirmed the join, and only where the deployment serves Agent
+ * Teams. A refused join changes nothing, and a parent that already opted in is
+ * left alone rather than rewritten.
+ *
+ * Nothing here runs on mount or from a render effect: an existing card is only
+ * ever touched by the user's own join action, so switching the option off by
+ * hand stays off.
+ */
+import type { BoardController } from '../../core/controller.ts'
+import type { TaskRecord } from '../../core/tasks.ts'
+
+/**
+ * Whether a join would promote this parent: the deployment serves Agent Teams
+ * and the parent has not opted in yet.
+ * @param controller - the board controller (the snapshot carries both facts).
+ * @param parent - the task that gained a subtask, if there is one.
+ */
+export function parentAwaitsTeamRunPromotion(controller: BoardController, parent: TaskRecord | undefined): boolean {
+  if (parent === undefined) return false
+  const snapshot = controller.getSnapshot()
+  if (snapshot.host?.teamRunAvailable !== true) return false
+  // The freshest record wins: the card may have been edited since this modal
+  // opened with its own copy.
+  return (snapshot.tasks.find(task => task.id === parent.id) ?? parent).teamRun !== true
+}
+
+/**
+ * Opt the parent in after the Host confirmed the join.
+ * @returns true when the opt-in was written; false when it did not apply.
+ */
+export async function promoteParentForTeamRun(controller: BoardController, parent: TaskRecord | undefined): Promise<boolean> {
+  if (parent === undefined) return false
+  if (!parentAwaitsTeamRunPromotion(controller, parent)) return false
+  return await controller.updateTask(parent.id, { teamRun: true })
+}