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

package/src/client/TaskBoardSettingsCard.tsx

@@ -12,8 +12,9 @@ import type { TaskBoardPowerSnapshot, TaskBoardVerificationOptions } from '../pr
 import type { TaskBoardExtensionDispatch } from '../core/extension.ts'
 import { resolveContract, type ModelCatalogView, type VerificationSettings } from '../core/verification.ts'
 import { parseModelRoute } from '../core/verification.ts'
-import { PluginSettingsCard, BooleanField, ChoiceField } from './PluginSettingsCard.tsx'
+import { PluginSettingsCard, BooleanField, ChoiceField, ValueField } from './PluginSettingsCard.tsx'
 import { SUBTASK_DEPTH_MAX, SUBTASK_DEPTH_MIN } from '../core/subtask.ts'
+import { SESSION_POLL_MAX_SECONDS, SESSION_POLL_MIN_SECONDS } from '../core/poll-cadence.ts'
 import { CardForm, booleanField, type CardActions, type CardShell, type FieldSpec, type FieldState as CardFieldState } from './settings-form.ts'
 import settingsCss from './board-settings.module.css'
 
@@ -23,6 +24,28 @@ const SUBTASK_DEPTH_CHOICES: readonly string[] = Array.from(
   (_, index) => String(SUBTASK_DEPTH_MIN + index),
 )
 
+/**
+ * The roster-poll cadence field: a whole number of seconds inside the
+ * supported range, because the Host schema (`sessionPollSeconds`) is numeric.
+ * A draft outside the range blocks the save instead of staging a value the
+ * Host would clamp behind the user's back.
+ */
+function sessionPollField(): FieldSpec {
+  return {
+    field: 'sessionPollSeconds',
+    format: value => typeof value === 'number' && Number.isInteger(value) ? String(value) : '',
+    parse: (text) => {
+      const trimmed = text.trim()
+      if (trimmed === '') return { kind: 'clear' }
+      if (!/^\d+$/.test(trimmed)) return undefined
+      const seconds = Number(trimmed)
+      return seconds >= SESSION_POLL_MIN_SECONDS && seconds <= SESSION_POLL_MAX_SECONDS
+        ? { kind: 'set', value: seconds }
+        : undefined
+    },
+  }
+}
+
 /**
  * The depth field: a choice among the supported levels whose draft text is a
  * number, because the Host schema (`maxSubtaskDepth`) is numeric. A draft
@@ -84,6 +107,14 @@ export interface TaskBoardSettings {
   preventIdleSleep?: boolean
   /** Subtask depth limit (1..3); 1 means a single level of subtasks. */
   maxSubtaskDepth?: number
+  /** Roster-poll cadence in seconds while the board has work to reconcile. */
+  sessionPollSeconds?: number
+  /**
+   * GLOBAL native /goal switch (default off): the master control over whether
+   * this board starts a run with dsh's built-in /goal at all. Frozen per
+   * execution.
+   */
+  goalRunEnabled?: boolean
   /** Goal acceptance for this board's executions (default on). */
   goalVerification?: boolean
   /** Judge model route for goal acceptance; blank inherits the host default. */
@@ -102,6 +133,10 @@ export interface TaskBoardSettingsCardState extends CardShell {
   preventIdleSleep: CardFieldState
   /** Subtask depth limit field. */
   maxSubtaskDepth: CardFieldState
+  /** Roster-poll cadence field. */
+  sessionPollSeconds: CardFieldState
+  /** GLOBAL native /goal switch. */
+  goalRunEnabled: CardFieldState
   /** Goal-acceptance switch. */
   goalVerification: CardFieldState
   /** Judge model route field. */
@@ -132,6 +167,8 @@ export class TaskBoardSettingsCardController {
       booleanField('announceToAgent'),
       booleanField('preventIdleSleep'),
       subtaskDepthField(),
+      sessionPollField(),
+      booleanField('goalRunEnabled'),
       booleanField('goalVerification'),
       judgeModelField(),
       judgeEffortField(),
@@ -146,6 +183,8 @@ export class TaskBoardSettingsCardController {
       announceToAgent: this.form.field('announceToAgent'),
       preventIdleSleep: this.form.field('preventIdleSleep'),
       maxSubtaskDepth: this.form.field('maxSubtaskDepth'),
+      sessionPollSeconds: this.form.field('sessionPollSeconds'),
+      goalRunEnabled: this.form.field('goalRunEnabled'),
       goalVerification: this.form.field('goalVerification'),
       goalVerificationModel: this.form.field('goalVerificationModel'),
       goalVerificationReasoningEffort: this.form.field('goalVerificationReasoningEffort'),
@@ -342,6 +381,16 @@ export function TaskBoardSettingsCard(props: TaskBoardSettingsCardProps) {
             onEdit={(text) => { props.edit('preventIdleSleep', text) }}
             onReset={() => { props.resetField('preventIdleSleep') }}
           />
+          <ValueField
+            id="settings-task-board-session-poll"
+            label={t('settings.sessionPollSeconds')}
+            hint={t('settings.sessionPollSecondsHint')}
+            numeric
+            {...fieldProps}
+            {...state.sessionPollSeconds}
+            onEdit={(text) => { props.edit('sessionPollSeconds', text) }}
+            onReset={() => { props.resetField('sessionPollSeconds') }}
+          />
           <ChoiceField
             id="settings-task-board-subtask-depth"
             label={t('settings.maxSubtaskDepth')}
@@ -358,6 +407,30 @@ export function TaskBoardSettingsCard(props: TaskBoardSettingsCardProps) {
           />
         </PluginSettingsCard>
 
+        <PluginSettingsCard
+          t={t}
+          titleKey="settings.runBehaviorTitle"
+          descriptionKey="settings.runBehaviorCardHint"
+          defaultOpen={false}
+          hideFooter
+          state={nestedShell}
+          onSave={props.save}
+          onDiscard={props.discard}
+        >
+          <BooleanField
+            id="settings-task-board-goal-run"
+            label={t('settings.goalRunGlobal')}
+            hint={t('settings.goalRunGlobalHint')}
+            inheritLabel={t('settings.inherit')}
+            onLabel={t('settings.on')}
+            offLabel={t('settings.off')}
+            {...fieldProps}
+            {...state.goalRunEnabled}
+            onEdit={(text) => { props.edit('goalRunEnabled', text) }}
+            onReset={() => { props.resetField('goalRunEnabled') }}
+          />
+        </PluginSettingsCard>
+
         <PluginSettingsCard
           t={t}
           titleKey="settings.goalVerificationTitle"

package/src/client/board/NewTaskModal.tsx

@@ -7,10 +7,10 @@ import type { BoardController } from '../../core/controller.ts'
 import { isValidCron, nextRunAtMs } from '../../core/schedule.ts'
 import { parseFreezeRequest } from '../../core/freeze-snapshot.ts'
 import { effectiveTaskPermission } from '../../core/subtask.ts'
-import { collectKnownTags, TASK_PERMISSIONS, type TaskPermission, type TaskRecord, type TaskTag } from '../../core/tasks.ts'
+import { collectKnownTags, TASK_PERMISSIONS, type ScheduleMode, type TaskPermission, type TaskRecord, type TaskTag } from '../../core/tasks.ts'
 import { t, type TaskBoardKey } from '../locales.ts'
 import { SCHEDULE_PRESETS } from '../schedule-presets.ts'
-import { nextRunLabel, zoneChoices } from '../schedule-zone.ts'
+import { defaultZonedInputValue, nextRunLabel, parseZonedInput, runCapOption, zonedInputValue, zoneChoices } from '../schedule-zone.ts'
 import { CollapsibleSection, ModalShell, TaskContentFields, TaskTagFields, cleanTags } from './TaskForm.tsx'
 import type { OverlayPhase } from './overlay.tsx'
 import { formatHostTimestamp } from './TaskCard.tsx'
@@ -57,12 +57,20 @@ export function NewTaskModal({ controller, onClose, initialTask, defaultWorkspac
   const [model, setModel] = useState(initialTask?.model ?? parentTask?.model ?? '')
   const inheritedPermission = parentTask === undefined ? undefined : effectiveTaskPermission(parentTask)
   const [reuseSession, setReuseSession] = useState(initialTask?.reuseSession ?? false)
-  // Checked by default: a new task starts its runs with dsh's built-in /goal
-  // unless the user opts out here. A duplicate keeps the original card's choice.
-  const [goalRun, setGoalRun] = useState(initialTask?.goalRun ?? true)
+  // Unchecked by default: a new task runs one plain turn unless the user opts
+  // into dsh's built-in /goal here. A duplicate keeps the original card's choice.
+  const [goalRun, setGoalRun] = useState(initialTask?.goalRun ?? false)
   const [skipVerification, setSkipVerification] = useState(initialTask?.skipVerification ?? false)
   const [scheduleEnabled, setScheduleEnabled] = useState(initialTask?.schedule?.enabled ?? false)
+  const [scheduleMode, setScheduleMode] = useState<ScheduleMode>(initialTask?.schedule?.mode ?? 'cron')
   const [scheduleCron, setScheduleCron] = useState(initialTask?.schedule?.cron ?? '')
+  // A duplicate keeps the original card's plan; a fresh one-shot defaults to
+  // the next hour, so the field never opens on a past instant.
+  const [scheduleAt, setScheduleAt] = useState<string>(() => initialTask?.schedule?.mode === 'once' && initialTask.schedule.at !== undefined
+    ? zonedInputValue(initialTask.schedule.at, initialTask.schedule.timeZone)
+    : defaultZonedInputValue(Date.now(), initialTask?.schedule?.timeZone))
+  const [scheduleMaxRunsChoice, setScheduleMaxRunsChoice] = useState<string>(() => runCapOption(initialTask?.schedule?.maxRuns))
+  const [scheduleMaxRunsText, setScheduleMaxRunsText] = useState<string>(initialTask?.schedule?.maxRuns === undefined ? '' : String(initialTask.schedule.maxRuns))
   // '' means "follow the Host zone" (store no zone), which is the default a
   // user gets unless they pick one explicitly.
   const [scheduleZone, setScheduleZone] = useState(initialTask?.schedule?.timeZone ?? '')
@@ -77,6 +85,11 @@ export function NewTaskModal({ controller, onClose, initialTask, defaultWorkspac
   const [error, setError] = useState<string | undefined>(undefined)
   const [pending, setPending] = useState(false)
   const [options, setOptions] = useState(controller.getSnapshot().executionOptions)
+  // Live GLOBAL native-/goal switch. The new-task form never rewrites a stored
+  // preference from it: the checkbox stays operable and is explained while the
+  // master switch is off, and the user's own choice is what a later re-enable
+  // restores.
+  const [goalRunEnabled, setGoalRunEnabled] = useState(controller.getSnapshot().host?.goalRunEnabled === true)
   // "Parse pasted text" (issue #1540) exists only when the deployment carries a
   // parse face; the section stays hidden otherwise.
   const [canParse] = useState(controller.getSnapshot().canParseTask === true)
@@ -99,7 +112,11 @@ export function NewTaskModal({ controller, onClose, initialTask, defaultWorkspac
   // The workspace list and preset roster arrive from the runtime after mount;
   // follow them so the pickers never freeze on an empty snapshot.
   useEffect(
-    () => controller.subscribe(() => setOptions(controller.getSnapshot().executionOptions)),
+    () => controller.subscribe(() => {
+      const snapshot = controller.getSnapshot()
+      setOptions(snapshot.executionOptions)
+      setGoalRunEnabled(snapshot.host?.goalRunEnabled === true)
+    }),
     [controller],
   )
 
@@ -145,10 +162,25 @@ export function NewTaskModal({ controller, onClose, initialTask, defaultWorkspac
    */
   const submit = async (runAfterCreate: boolean): Promise<void> => {
     if (scheduleEnabled) {
-      const cron = scheduleCron.trim()
-      if (cron === '' || !isValidCron(cron)) {
-        setScheduleError(t('detail.schedule.invalid'))
-        return
+      if (scheduleMode === 'once') {
+        const at = parseZonedInput(scheduleAt, scheduleZone === '' ? hostTimeZone : scheduleZone)
+        if (at === undefined || at <= Date.now()) {
+          setScheduleError(t('detail.schedule.atInvalid'))
+          return
+        }
+      } else {
+        const cron = scheduleCron.trim()
+        if (cron === '' || !isValidCron(cron)) {
+          setScheduleError(t('detail.schedule.invalid'))
+          return
+        }
+        if (scheduleMaxRunsChoice === 'custom') {
+          const cap = Number(scheduleMaxRunsText.trim())
+          if (scheduleMaxRunsText.trim() === '' || !Number.isInteger(cap) || cap < 1) {
+            setScheduleError(t('detail.schedule.maxRunsInvalid'))
+            return
+          }
+        }
       }
     }
     // Optional continuation-card snapshot: parse the freeze block through the
@@ -188,11 +220,26 @@ export function NewTaskModal({ controller, onClose, initialTask, defaultWorkspac
       permission: permission === '' ? undefined : permission as TaskPermission,
       model: model === '' ? undefined : model,
       ...(reuseSession ? { reuseSession: true } : {}),
-      ...(goalRun ? {} : { goalRun: false }),
+      ...(goalRun ? { goalRun: true } : {}),
       ...(skipVerification ? { skipVerification: true } : {}),
       ...(tagList.length > 0 ? { tags: tagList } : {}),
       schedule: scheduleEnabled
-        ? { enabled: true, cron: scheduleCron.trim(), ...(scheduleZone === '' ? {} : { timeZone: scheduleZone }) }
+        ? scheduleMode === 'once'
+          ? {
+              enabled: true,
+              mode: 'once' as const,
+              at: parseZonedInput(scheduleAt, scheduleZone === '' ? hostTimeZone : scheduleZone)!,
+              ...(scheduleZone === '' ? {} : { timeZone: scheduleZone }),
+            }
+          : {
+              enabled: true,
+              mode: 'cron' as const,
+              cron: scheduleCron.trim(),
+              ...(scheduleMaxRunsChoice === 'unlimited' ? {} : {
+                maxRuns: scheduleMaxRunsChoice === 'custom' ? Number(scheduleMaxRunsText.trim()) : Number(scheduleMaxRunsChoice),
+              }),
+              ...(scheduleZone === '' ? {} : { timeZone: scheduleZone }),
+            }
         : undefined,
     })
     if (task === undefined) {
@@ -218,13 +265,18 @@ export function NewTaskModal({ controller, onClose, initialTask, defaultWorkspac
     onClose()
   }
 
-  // Next-run preview for a valid armed cron (creation-time only), computed in
-  // the selected zone so it matches what the Host will arm.
+  // Next-run preview for the armed plan (creation-time only), computed in the
+  // selected zone so it matches what the Host will arm. A one-shot's next run
+  // IS its planned instant; a recurring rule resolves its next occurrence.
   const hostTimeZone = controller.getSnapshot().host?.scheduler.timeZone
   const scheduleTimeZone = scheduleZone === '' ? hostTimeZone : scheduleZone
-  const scheduleNextRun = scheduleEnabled && scheduleCron.trim() !== '' && isValidCron(scheduleCron)
-    ? nextRunAtMs(scheduleCron, Date.now(), scheduleTimeZone)
-    : undefined
+  const scheduleNextRun = !scheduleEnabled
+    ? undefined
+    : scheduleMode === 'once'
+      ? parseZonedInput(scheduleAt, scheduleTimeZone)
+      : scheduleCron.trim() !== '' && isValidCron(scheduleCron)
+        ? nextRunAtMs(scheduleCron, Date.now(), scheduleTimeZone)
+        : undefined
 
   const modalTitle = parentTask !== undefined
     ? t('new.subtaskTitle')
@@ -262,7 +314,9 @@ export function NewTaskModal({ controller, onClose, initialTask, defaultWorkspac
   const tagCount = cleanTags(tags).length
   const labelsSummary = tagCount === 0 ? t('new.summary.none') : t('new.summary.labelCount', { count: String(tagCount) })
   const runSummary = [
-    goalRun ? t('new.summary.multiRound') : t('new.summary.singleRound'),
+    // A card whose goal option is on but whose master switch is off will run one
+    // plain turn: the collapsed line says the truth rather than the stored value.
+    goalRun && goalRunEnabled ? t('new.summary.multiRound') : t('new.summary.singleRound'),
     ...(reuseSession ? [t('exec.reuseSession')] : []),
   ].join(' · ')
   const handoverSummary = freezeText.trim() !== '' || handoverText.trim() !== ''
@@ -270,7 +324,18 @@ export function NewTaskModal({ controller, onClose, initialTask, defaultWorkspac
     : t('new.summary.none')
   const scheduleSummary = !scheduleEnabled
     ? t('new.summary.scheduleOff')
-    : scheduleCron.trim() === '' ? t('new.summary.none') : scheduleCron.trim()
+    : scheduleMode === 'once'
+      ? `${t('detail.schedule.mode.once')} · ${scheduleAt.replace('T', ' ')}`
+      : scheduleCron.trim() === ''
+        ? t('new.summary.none')
+        : [
+            scheduleCron.trim(),
+            ...(scheduleMaxRunsChoice === 'unlimited'
+              ? []
+              : [t('detail.schedule.maxRunsValue', {
+                  count: scheduleMaxRunsChoice === 'custom' ? scheduleMaxRunsText : scheduleMaxRunsChoice,
+                })]),
+          ].join(' · ')
   const parseSummary = parseText.trim() === '' ? t('new.summary.none') : t('new.summary.filled')
 
   return (
@@ -467,11 +532,15 @@ export function NewTaskModal({ controller, onClose, initialTask, defaultWorkspac
           <input
             type="checkbox"
             checked={goalRun}
+            // Always operable: the global switch decides whether the choice
+            // takes effect, never whether it may be stated, and the state (and a
+            // duplicate's template) is never rewritten by it.
             onChange={event => { setGoalRun(event.target.checked) }}
           />
           <span>{t('exec.goalRun')}</span>
         </label>
         <p className={css.detailText}>{t('exec.goalRunHint')}</p>
+        {!goalRunEnabled && <p className={css.detailText}>{t('settings.goalRunGlobalDisabledTaskOption')}</p>}
 
         <label className={css.scheduleToggle}>
           <input
@@ -533,6 +602,32 @@ export function NewTaskModal({ controller, onClose, initialTask, defaultWorkspac
         </label>
         {scheduleEnabled && (
           <>
+            <label className={css.scheduleZone}>
+              <span>{t('detail.schedule.mode')}</span>
+              <select
+                className={css.schedulePreset}
+                value={scheduleMode}
+                aria-label={t('detail.schedule.mode')}
+                onChange={event => { setScheduleMode(event.target.value as ScheduleMode); setScheduleError(undefined) }}
+              >
+                <option value="cron">{t('detail.schedule.mode.cron')}</option>
+                <option value="once">{t('detail.schedule.mode.once')}</option>
+              </select>
+            </label>
+            {scheduleMode === 'once' ? (
+              <label className={css.scheduleZone}>
+                <span>{t('detail.schedule.at')}</span>
+                <input
+                  className={css.input}
+                  type="datetime-local"
+                  value={scheduleAt}
+                  aria-label={t('detail.schedule.at')}
+                  title={t('detail.schedule.atHint')}
+                  onChange={event => { setScheduleAt(event.target.value); setScheduleError(undefined) }}
+                />
+              </label>
+            ) : (
+              <>
             <div className={css.scheduleRow}>
               <input
                 className={`${css.input} ${css.scheduleInput}${scheduleError !== undefined ? ` ${css.scheduleInputInvalid}` : ''}`}
@@ -558,6 +653,42 @@ export function NewTaskModal({ controller, onClose, initialTask, defaultWorkspac
                 ))}
               </select>
             </div>
+                <label className={css.scheduleZone}>
+                  <span>{t('detail.schedule.maxRuns')}</span>
+                  <select
+                    className={css.schedulePreset}
+                    value={scheduleMaxRunsChoice}
+                    aria-label={t('detail.schedule.maxRuns')}
+                    onChange={event => {
+                      setScheduleMaxRunsChoice(event.target.value)
+                      setScheduleError(undefined)
+                      if (event.target.value === 'custom') {
+                        setScheduleMaxRunsText(initialTask?.schedule?.maxRuns === undefined ? '' : String(initialTask.schedule.maxRuns))
+                      }
+                    }}
+                  >
+                    <option value="unlimited">{t('detail.schedule.maxRunsUnlimited')}</option>
+                    <option value="1">{t('detail.schedule.maxRunsValue', { count: '1' })}</option>
+                    <option value="2">{t('detail.schedule.maxRunsValue', { count: '2' })}</option>
+                    <option value="custom">{t('detail.schedule.maxRunsCustom')}</option>
+                  </select>
+                </label>
+                {scheduleMaxRunsChoice === 'custom' && (
+                  <label className={css.scheduleZone}>
+                    <span>{t('detail.schedule.maxRuns')}</span>
+                    <input
+                      className={css.input}
+                      type="number"
+                      min={1}
+                      step={1}
+                      value={scheduleMaxRunsText}
+                      aria-label={t('detail.schedule.maxRuns')}
+                      onChange={event => { setScheduleMaxRunsText(event.target.value); setScheduleError(undefined) }}
+                    />
+                  </label>
+                )}
+              </>
+            )}
             {scheduleError !== undefined && <p className={css.formError}>{scheduleError}</p>}
             <label className={css.scheduleZone}>
               <span>{t('detail.schedule.timeZone')}</span>
@@ -565,7 +696,7 @@ export function NewTaskModal({ controller, onClose, initialTask, defaultWorkspac
                 className={css.schedulePreset}
                 value={scheduleZone}
                 aria-label={t('detail.schedule.timeZone')}
-                title={t('detail.schedule.timeZoneHint')}
+                title={scheduleMode === 'once' ? t('detail.schedule.zoneOnceHint') : t('detail.schedule.timeZoneHint')}
                 onChange={event => { setScheduleZone(event.target.value); setScheduleError(undefined) }}
               >
                 {zoneChoices(hostTimeZone, initialTask?.schedule?.timeZone).map(choice => (

package/src/client/board/TaskCard.tsx

@@ -274,11 +274,11 @@ function TaskCardInner({
               <span
                 className={css.cardSchedule}
                 title={task.schedule.nextRunAt !== undefined
-                  ? `${t('card.scheduled')} · ${formatHostTimestamp(task.schedule.nextRunAt, timeZone)}`
-                  : t('card.scheduled')}
+                  ? `${t(task.schedule.mode === 'once' ? 'card.scheduledOnce' : 'card.scheduled')} · ${formatHostTimestamp(task.schedule.nextRunAt, timeZone)}`
+                  : t(task.schedule.mode === 'once' ? 'card.scheduledOnce' : 'card.scheduled')}
               >
                 <IconClock size={12} />
-                {t('card.scheduled')}
+                {t(task.schedule.mode === 'once' ? 'card.scheduledOnce' : 'card.scheduled')}
               </span>
             )}
             {latest !== undefined && (