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

package/src/host-runner.ts

@@ -159,12 +159,12 @@ export interface PromptContext {
   /** True when those members run as teammates inside this session (Team Lead). */
   team?: boolean
   /**
-   * Scheduled-run provenance: the instant the cron rule actually fired and the
-   * IANA zone its wall clock was read in. Present only for a cron-triggered
-   * run, so the model can resolve an unqualified date in the run's own terms
-   * instead of guessing from the Host clock (issue #1722).
+   * Scheduled-run provenance: the instant the rule actually fired, its kind,
+   * and the IANA zone its wall clock was read in. Present only for a
+   * timer-triggered run, so the model can resolve an unqualified date in the
+   * run's own terms instead of guessing from the Host clock (issue #1722).
    */
-  schedule?: { triggeredAt: number; timeZone: string; cron: string }
+  schedule?: { triggeredAt: number; timeZone: string; mode: 'cron' | 'once'; cron?: string }
 }
 
 /**
@@ -184,16 +184,20 @@ function peerPromptPreamble(context: PromptContext): string | undefined {
 }
 
 /**
- * The scheduled-run section: this execution was triggered by the card's cron
- * rule rather than by a person. It states the firing instant, the rule's zone,
- * and the rule text, so the run's own clock is unambiguous — the board's
+ * The scheduled-run section: this execution was triggered by the card's
+ * schedule rather than by a person. It states the firing instant, the rule's
+ * zone, and the rule text, so the run's own clock is unambiguous — the board's
  * scheduler fires on a wall clock in a specific IANA zone, which is not
- * necessarily the zone of whatever session the run lands in.
+ * necessarily the zone of whatever session the run lands in. A one-shot says
+ * so explicitly, so the run does not expect a recurrence.
  */
 function schedulePromptPreamble(context: PromptContext): string | undefined {
   const schedule = context.schedule
   if (schedule === undefined) return undefined
   const stamp = new Date(schedule.triggeredAt).toISOString()
+  if (schedule.mode === 'once') {
+    return `本次执行由任务看板的单次定时自动触发：计划时间 ${stamp}（UTC），时区 ${schedule.timeZone}。这是一次性计划，本次执行之后该卡片不会再自动执行。需要判断「今天」「现在」或计算时间窗口时，以该时区的触发时间为准。`
+  }
   return `本次执行由任务看板的定时规则自动触发：触发时间 ${stamp}（UTC），规则时区 ${schedule.timeZone}，cron 表达式 ${schedule.cron}。需要判断「今天」「现在」或计算时间窗口时，以该时区的触发时间为准。`
 }
 
@@ -356,7 +360,24 @@ export class HostExecutionRunner {
    * @param options - optional session to continue in.
    * @returns the session id the execution runs in.
    */
-  async launch(task: TaskRecord, options: { reuseSessionId?: string; promptContext?: PromptContext; onSession?: (sessionId: string) => void; onGoalArmed?: (armed: boolean) => void } = {}): Promise<string> {
+  async launch(task: TaskRecord, options: {
+    reuseSessionId?: string
+    promptContext?: PromptContext
+    onSession?: (sessionId: string) => void
+    onGoalArmed?: (armed: boolean) => void
+    /**
+     * GLOBAL native /goal switch, resolved by the caller ONCE per execution and
+     * carried here so the decision is frozen for this launch.
+     *
+     * Frozen deliberately: a settings edit made while the run is in flight must
+     * not arm, disarm or otherwise change the goal/acceptance contract of a run
+     * already running. Absent means off — the default for every deployment that
+     * never touched the switch, including cards written before the option
+     * existed. A plain single turn is what an off switch produces; the task-level
+     * `goalRun` still applies on top of it (both must ASK for a goal).
+     */
+    goalEnabled?: boolean
+  } = {}): Promise<string> {
     // A handover bundle overrides the legacy pin fields: the bundle is the
     // authoritative execution triplet for a continuation card (issue #5). A
     // card that pins nothing is resolved to the deployment's most recently used
@@ -396,7 +417,7 @@ export class HostExecutionRunner {
         // at the gate without its binding.
         options.onSession?.(reused)
         await this.assertReusedPreset(reused, mode)
-        await this.pinAndPrompt(reused, task, permission, options.promptContext, options.onGoalArmed)
+        await this.pinAndPrompt(reused, task, permission, options.promptContext, options.onGoalArmed, options.goalEnabled === true)
       } catch (error) {
         throw new SessionLaunchError(reused, error)
       }
@@ -410,7 +431,7 @@ export class HostExecutionRunner {
     options.onSession?.(sessionId)
     try {
       await this.invoke('session', 'rename', { sessionId, title: task.title })
-      await this.pinAndPrompt(sessionId, task, permission, options.promptContext, options.onGoalArmed)
+      await this.pinAndPrompt(sessionId, task, permission, options.promptContext, options.onGoalArmed, options.goalEnabled === true)
     } catch (error) {
       throw new SessionLaunchError(sessionId, error)
     }
@@ -456,6 +477,7 @@ export class HostExecutionRunner {
     permission: TaskPermission | undefined,
     context: PromptContext = {},
     onGoalArmed?: (armed: boolean) => void,
+    goalEnabled = false,
   ): Promise<void> {
     if (permission !== undefined) {
       if (this.commands === undefined) throw new Error('permission command dispatcher is unavailable')
@@ -484,7 +506,7 @@ export class HostExecutionRunner {
       mode: 'queue' as const,
       content: [{ type: 'text' as const, text: promptText(task, context) }],
     })
-    const armed = await this.armGoal(sessionId, task, context)
+    const armed = await this.armGoal(sessionId, task, context, goalEnabled)
     onGoalArmed?.(armed)
   }
 
@@ -512,14 +534,25 @@ export class HostExecutionRunner {
    * dsh's goal-round driver keeps starting continuation rounds until the agent
    * marks it complete (see {@link goalVerdict} for how the run settles).
    *
-   * Opt-out: a task whose `goalRun` is an explicit false runs one plain turn.
+   * Two switches gate the arming, and BOTH must ask for it:
+   * - the GLOBAL native-/goal switch (`goalEnabled`, default OFF), frozen when
+   *   this execution started; and
+   * - the task's own `goalRun` (absent means off, only an explicit true opts
+   *   the card into a goal run).
+   *
    * A refusal (no command dispatcher, no `/goal` command in this cohort, an
-   * objective the command rejects) is reported and the run continues as that
-   * plain turn: the task was asked to run, and a missing goal mode must not
-   * lose the work.
+   * objective the command rejects) is reported and the run continues as a plain
+   * turn: the task was asked to run, and a missing goal mode must not lose the
+   * work.
+   * @param sessionId - the session to arm in.
+   * @param task - the task being run.
+   * @param context - the run's prompt context.
+   * @param goalEnabled - the GLOBAL switch, frozen for this execution.
+   * @returns whether `/goal` was really armed.
    */
-  private async armGoal(sessionId: ExecutionSessionId, task: TaskRecord, context: PromptContext): Promise<boolean> {
-    if (task.goalRun === false) return false
+  private async armGoal(sessionId: ExecutionSessionId, task: TaskRecord, context: PromptContext, goalEnabled: boolean): Promise<boolean> {
+    if (!goalEnabled) return false
+    if (task.goalRun !== true) return false
     if (this.commands === undefined) {
       console.warn('[dsh-task-board] no command dispatcher is available; task ' + task.id + ' runs without /goal')
       return false