@linxin666/dsh-client-ui-task-board 0.4.3 → 0.4.4

package/lib/types/host-ledger.d.ts

@@ -23,11 +23,20 @@ export interface OpenExecutionReference {
     readonly executionId: string;
     readonly sessionId: string | undefined;
     readonly startedAt: number;
+    /**
+     * True for a member of a team-mode run other than its Lead. A teammate is a
+     * durable member of the Team: it stays alive after its turn ends, so the
+     * roster may keep reporting its session as running, and the turn it completed
+     * is the only verdict it exposes.
+     */
+    readonly teamMember: boolean;
 }
 /** Minimal value copy used by the Host scheduler. */
 export interface DueScheduleReference {
     readonly taskId: string;
     readonly cron: string;
+    /** Zone this rule's wall clock is read in. */
+    readonly timeZone: string;
     readonly nextRunAt: number;
 }
 /** Derived runtime data for one session-poll pass. */
@@ -191,13 +200,56 @@ export declare class HostTaskLedger {
      * (failure dominates, then cancellation).
      */
     private settleCascade;
+    /**
+     * Close every run that is already decided, and fold every lineage whose
+     * members are all settled. The Host poll calls this on every tick, so a run
+     * can no longer be left in the running column by a settle nobody observed:
+     *
+     * - A team run is governed by its Lead. Once the Lead's own outcome is
+     *   recorded, its still-open members are settled with that verdict. A
+     *   teammate is a durable member of the Team and may never report a turn of
+     *   its own, and without this the whole lineage waits on it forever.
+     * - A cascade parent whose members are all settled is finalized here even
+     *   when the settle that completed the tree happened in another process, or
+     *   was interrupted between its child write and its parent write.
+     *
+     * Idempotent: a run that is already folded is left untouched, so a caller may
+     * invoke it on every tick.
+     * @param persist - false to leave the document for the caller to commit.
+     * @returns whether the document changed.
+     */
+    finalizeReadyRuns(persist?: boolean): boolean;
+    /**
+     * The verdict a team run's Lead has already recorded: its own turn outcome
+     * once that turn ended, or the folded outcome once its card settled.
+     */
+    private leadVerdict;
+    /**
+     * Settle every still-open member of a team run with the Lead's verdict.
+     * A teammate that already reported its own outcome keeps it: the ordinary
+     * fold still lets a failure dominate.
+     * @param leadId - the Lead card's task id (never settled here).
+     * @param groupId - the team run's group.
+     * @param verdict - the Lead's outcome, inherited by members that never reported.
+     * @param error - the Lead's failure text, inherited with a failed verdict.
+     * @param now - clock instant (ms epoch).
+     * @returns whether the document changed.
+     */
+    private closeTeamMembers;
     private repairSchedules;
     private reconcileInterruptedStarts;
     /**
-     * Field-preserving v2 to v3 migration. v3 adds no fields yet, so the
-     * migration reuses the v3 normalization, but it first proves every task
-     * row is structurally valid: a v2 document that would silently drop or
-     * coerce rows fails loudly instead (no quarantined-empty restart).
+     * Field-preserving migration of a pre-v4 document. It first proves every task
+     * row is structurally valid, so a document that would silently drop or coerce
+     * rows fails loudly instead (no quarantined-empty restart), and then reuses
+     * the current normalization.
+     *
+     * v4 adds `ScheduleRule.timeZone`. A rule written before v4 was evaluated in
+     * whatever zone the Host process happened to report, so the migration stamps
+     * that zone onto every enabled rule: the trigger instant is preserved exactly
+     * (the stored `nextRunAt` already encodes the old zone), but the rule stops
+     * following a later `TZ` change, which is what made an existing schedule
+     * silently move when the Host's zone changed.
      */
     private migrateLegacyDocument;
     private load;

package/lib/types/host-runner.d.ts

@@ -23,8 +23,18 @@ type ExecutionSessionId = SessionSummary['sessionId'];
 export interface SessionCommandDispatcher {
     execute(sessionId: ExecutionSessionId, line: string, signal: AbortSignal): Promise<CommandResult | undefined>;
 }
-export type ExecutionInspection = {
+export type ExecutionInspection = 
+/**
+ * No verdict yet. `unreadable` separates "the work may still be in progress"
+ * from "this session's history could not be read at all": a reader failure is
+ * not progress, and the caller decides how long to keep waiting before it
+ * reports the execution as undeterminable instead of holding a card open
+ * forever.
+ */
+{
     outcome: 'pending';
+    unreadable?: true;
+    reason?: string;
 } | {
     outcome: 'succeeded';
 } | {
@@ -64,6 +74,17 @@ export interface PromptContext {
     peers?: readonly PromptPeer[];
     /** 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).
+     */
+    schedule?: {
+        triggeredAt: number;
+        timeZone: string;
+        cron: string;
+    };
 }
 /**
  * Build the execution prompt for one task.
@@ -72,6 +93,16 @@ export interface PromptContext {
  * @returns the prompt text.
  */
 export declare function promptText(task: TaskRecord, context?: PromptContext): string;
+/**
+ * Build the objective the built-in `/goal` command receives. A prompt whose
+ * text would be read as a goal operation is prefixed with a neutral label: the
+ * instruction stays intact, and the command arms an objective instead of
+ * clearing, pausing, or editing an unrelated goal (or refusing for a missing
+ * one).
+ * @param prompt - the composed execution prompt.
+ * @returns the objective text for `/goal <objective>`.
+ */
+export declare function goalObjective(prompt: string): string;
 export declare class HostExecutionRunner {
     private readonly gateway;
     private readonly commands?;
@@ -122,6 +153,37 @@ export declare class HostExecutionRunner {
      * the same permission/model pins before the prompt.
      */
     private pinAndPrompt;
+    /**
+     * Arm dsh's built-in goal on the session. The task prompt is queued FIRST, so
+     * the session's first turn carries the instruction verbatim; `/goal
+     * <objective>` then turns the same text into a persistent objective, and
+     * 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.
+     * 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.
+     */
+    private armGoal;
+    /**
+     * The verdict an armed dsh goal imposes on an otherwise completed turn.
+     *
+     * A goal run is one session working many automatic continuation rounds:
+     * dsh's goal-round driver queues the next round whenever the agent goes
+     * idle, so the first completed `turn/end` is not the execution's result.
+     * Settling there would leave the card in `done` while the session keeps
+     * working, and a scheduled task would fire a second, concurrent session.
+     * The session projection is the authority: an `active` goal keeps the
+     * execution pending, a `blocked` goal fails it with the recorded reason, and
+     * any other phase (complete, paused, or no goal at all) leaves the turn
+     * verdict in place.
+     *
+     * An unreadable projection falls back to that turn verdict: a cohort whose
+     * gateway withdrew `session/projections` must not hang every execution.
+     */
+    private goalVerdict;
     listRunning(): Promise<{
         known: true;
         count: number;
@@ -129,6 +191,17 @@ export declare class HostExecutionRunner {
     } | {
         known: false;
     }>;
-    /** Resolve an execution outcome from the session list and bounded history pages. */
-    inspect(sessionId: string, startedAt?: number, sessions?: readonly SessionSummary[]): Promise<ExecutionInspection>;
+    /**
+     * Resolve an execution outcome from the session list and bounded history pages.
+     * @param sessionId - the session the execution runs in.
+     * @param startedAt - instant the execution opened; earlier events are not its own.
+     * @param sessions - roster from the caller's own poll, when it already has one.
+     * @param options.whileRunning - read the first completed turn even while the
+     *   roster reports the session as running. A durable Agent Teams teammate
+     *   stays alive after its turn ends, so `running` never clears for it and the
+     *   turn it completed is the only verdict it will ever expose.
+     */
+    inspect(sessionId: string, startedAt?: number, sessions?: readonly SessionSummary[], options?: {
+        whileRunning?: boolean;
+    }): Promise<ExecutionInspection>;
 }

package/lib/types/host-service.d.ts

@@ -31,6 +31,16 @@ export interface TeamSpawnResult {
 export interface TaskBoardTeamDispatcher {
     spawn(input: TeamSpawnInput): Promise<TeamSpawnResult>;
 }
+/**
+ * Provenance of one cron-triggered cascade: when the rule fired and the zone
+ * its wall clock was read in. Passed into every launched prompt of that run so
+ * a scheduled job knows its own clock rather than inferring one.
+ */
+export interface ScheduledRunContext {
+    triggeredAt: number;
+    timeZone: string;
+    cron: string;
+}
 /**
  * The native timer face the Host arms through. The cordis `timer` service
  * (dsh-base's own `cordis-plugin-timer` row) provides it: its handles are
@@ -63,6 +73,12 @@ export declare class TaskBoardHostService {
      * conversation instead of prompting into a session it cannot see.
      */
     private idleSessionIds;
+    /**
+     * Consecutive unreadable-history polls per open execution (see
+     * {@link noteUnreadableInspection}). Cleared as soon as an inspection
+     * resolves, so a transient reader failure never fails a card.
+     */
+    private readonly unreadablePolls;
     private preventIdleSleep;
     private readonly team;
     private readonly timers;
@@ -100,6 +116,16 @@ export declare class TaskBoardHostService {
     private pollSessions;
     /** Reuse the session list this poll already fetched: one list RPC per tick, not 1 + E. */
     private reconcileExecutions;
+    /**
+     * Count one poll whose session history could not be read. A reader failure is
+     * not progress: the session is not running (the runner only reads history for
+     * one that is idle), so nothing will ever change that verdict. After
+     * {@link UNREADABLE_SETTLE_POLLS} consecutive polls the execution is reported
+     * failed with the recorded reason, instead of holding its card — and every
+     * ancestor of it — in the running column with no way out. The first poll of
+     * each streak is logged, so the Host log names the session.
+     */
+    private noteUnreadableInspection;
     /** Drop the armed schedule timer and forget its target. */
     private clearScheduleTimer;
     /**

package/lib/types/protocol.d.ts

@@ -1,8 +1,10 @@
 import type { TaskUpdatePatch } from './core/use-cases/task-update.ts';
 import { type NewTaskInput, type TaskPermission, type TaskRecord, type TaskStatus } from './core/tasks.ts';
-export declare const TASK_BOARD_SCHEMA_VERSION: 3;
-/** Ledger documents written before v3; loaded once and migrated on startup. */
-export declare const TASK_BOARD_LEGACY_SCHEMA_VERSION: 2;
+export declare const TASK_BOARD_SCHEMA_VERSION: 4;
+/** Ledger documents written before v4; loaded once and migrated on startup. */
+export declare const TASK_BOARD_LEGACY_SCHEMA_VERSION: 3;
+/** Ledger documents written before v3; migrated through the v3 normalization too. */
+export declare const TASK_BOARD_OLDER_SCHEMA_VERSION: 2;
 export declare const TASK_BOARD_API_PREFIX = "/api/task-board";
 export type PowerPhase = 'disabled' | 'idle' | 'acquiring' | 'active' | 'error' | 'unsupported';
 export interface TaskBoardPowerSnapshot {
@@ -90,12 +92,16 @@ export type TaskBoardAction = {
 } | {
     kind: 'restore';
     taskId: string;
+} | {
+    kind: 'settle';
+    taskId: string;
 } | {
     kind: 'set-schedule';
     taskId: string;
     patch: {
         enabled?: boolean;
         cron?: string;
+        timeZone?: string | null;
     };
 } | {
     kind: 'run';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@linxin666/dsh-client-ui-task-board",
   "description": "Host-authoritative task board for the DSH Web GUI with real session execution, Host cron scheduling, and optional cross-platform idle-sleep protection; mounted without DSH source changes.",
-  "version": "0.4.3",
+  "version": "0.4.4",
   "icon": "icon.svg",
   "type": "module",
   "main": "lib/index.js",
@@ -24,7 +24,7 @@
   },
   "dsh": {
     "engines": {
-      "dsh": ">=0.1.7-rc.2"
+      "dsh": ">=0.2.0-rc.1"
     },
     "bundle": {
       "patch": "./cordis.patch.yml"
@@ -44,7 +44,7 @@
     }
   },
   "peerDependencies": {
-    "@deepseek-ai/dsh": ">=0.1.7-rc.2",
+    "@deepseek-ai/dsh": ">=0.2.0-rc.1",
     "react": "^18.2.0"
   },
   "dependencies": {
@@ -52,28 +52,28 @@
   },
   "devDependencies": {
     "@deepseek-ai/cordis": "^4.0.4",
-    "@deepseek-ai/dsh-agent": "^0.1.7-rc.2",
-    "@deepseek-ai/dsh-agent-preset-registry": "^0.1.7-rc.2",
-    "@deepseek-ai/dsh-api-gateway": "^0.1.7-rc.2",
-    "@deepseek-ai/dsh-api-remotes": "^0.1.7-rc.2",
-    "@deepseek-ai/dsh-api-session-controller": "^0.1.7-rc.2",
-    "@deepseek-ai/dsh-api-workspace-controller": "^0.1.7-rc.2",
-    "@deepseek-ai/dsh-client-connection": "^0.1.7-rc.2",
-    "@deepseek-ai/dsh-client-locale": "^0.1.7-rc.2",
-    "@deepseek-ai/dsh-client-store": "^0.1.7-rc.2",
-    "@deepseek-ai/dsh-client-ui-layout": "^0.1.7-rc.2",
-    "@deepseek-ai/dsh-client-ui-renderer": "^0.1.7-rc.2",
-    "@deepseek-ai/dsh-client-ui-settings": "^0.1.7-rc.2",
-    "@deepseek-ai/dsh-client-ui-sidebar": "^0.1.7-rc.2",
-    "@deepseek-ai/dsh-client-ui-slots": "^0.1.7-rc.2",
-    "@deepseek-ai/dsh-client-ui-workspace": "^0.1.7-rc.2",
-    "@deepseek-ai/dsh-commands": "^0.1.7-rc.2",
-    "@deepseek-ai/dsh-host-webserver": "^0.1.7-rc.2",
-    "@deepseek-ai/dsh-llm": "^0.1.7-rc.2",
-    "@deepseek-ai/dsh-settings": "^0.1.7-rc.2",
-    "@deepseek-ai/dsh-system-prompt": "^0.1.7-rc.2",
-    "@deepseek-ai/dsh-tools": "^0.1.7-rc.2",
-    "@deepseek-ai/dsh-workspace": "^0.1.7-rc.2",
+    "@deepseek-ai/dsh-agent": "^0.2.0-rc.1",
+    "@deepseek-ai/dsh-agent-preset-registry": "^0.2.0-rc.1",
+    "@deepseek-ai/dsh-api-gateway": "^0.2.0-rc.1",
+    "@deepseek-ai/dsh-api-remotes": "^0.2.0-rc.1",
+    "@deepseek-ai/dsh-api-session-controller": "^0.2.0-rc.1",
+    "@deepseek-ai/dsh-api-workspace-controller": "^0.2.0-rc.1",
+    "@deepseek-ai/dsh-client-connection": "^0.2.0-rc.1",
+    "@deepseek-ai/dsh-client-locale": "^0.2.0-rc.1",
+    "@deepseek-ai/dsh-client-store": "^0.2.0-rc.1",
+    "@deepseek-ai/dsh-client-ui-layout": "^0.2.0-rc.1",
+    "@deepseek-ai/dsh-client-ui-renderer": "^0.2.0-rc.1",
+    "@deepseek-ai/dsh-client-ui-settings": "^0.2.0-rc.1",
+    "@deepseek-ai/dsh-client-ui-sidebar": "^0.2.0-rc.1",
+    "@deepseek-ai/dsh-client-ui-slots": "^0.2.0-rc.1",
+    "@deepseek-ai/dsh-client-ui-workspace": "^0.2.0-rc.1",
+    "@deepseek-ai/dsh-commands": "^0.2.0-rc.1",
+    "@deepseek-ai/dsh-host-webserver": "^0.2.0-rc.1",
+    "@deepseek-ai/dsh-llm": "^0.2.0-rc.1",
+    "@deepseek-ai/dsh-settings": "^0.2.0-rc.1",
+    "@deepseek-ai/dsh-system-prompt": "^0.2.0-rc.1",
+    "@deepseek-ai/dsh-tools": "^0.2.0-rc.1",
+    "@deepseek-ai/dsh-workspace": "^0.2.0-rc.1",
     "@types/node": "^22.20.0",
     "@types/react": "~18.3.1",
     "@types/react-dom": "^18.3.5",

package/src/client/board/LinkSubtaskModal.tsx

@@ -4,9 +4,9 @@
  * a link the Host would refuse is not offered in the first place; the Host
  * still re-checks the action at submit time.
  */
-import { useState } from 'react'
+import { useMemo, useState } from 'react'
 import type { BoardController } from '../../core/controller.ts'
-import { DEFAULT_SUBTASK_DEPTH, checkParentLink } from '../../core/subtask.ts'
+import { DEFAULT_SUBTASK_DEPTH, buildLineageIndex, checkParentLink } from '../../core/subtask.ts'
 import type { TaskRecord } from '../../core/tasks.ts'
 import { t } from '../locales.ts'
 import css from '../board.module.css'
@@ -28,15 +28,25 @@ export function LinkSubtaskModal({ controller, parent, onClose }: LinkSubtaskMod
   const limit = snapshot.host?.maxSubtaskDepth ?? DEFAULT_SUBTASK_DEPTH
   // Only root, on-board tasks can move under another parent; the lineage gate
   // decides the rest (depth, cycle, archived parent).
-  const candidates = snapshot.tasks.filter(task =>
-    task.archivedAt === undefined
-    // A running task may already be a participant of another run group; the
-    // Host refuses the move, so it is not offered here.
-    && task.status !== 'running'
-    && task.parentId === undefined
-    && task.id !== parent.id
-    && checkParentLink(snapshot.tasks, task.id, parent.id, limit).ok,
-  )
+  //
+  // The gate is run once per candidate task, so it is given ONE lineage index
+  // for the whole pass: without it every call rebuilds the id/child maps and
+  // rescans the ledger, turning a render into quadratic work. The derivation
+  // also runs on every controller notification (the SSE heartbeat included),
+  // so it is memoized on the inputs it actually reads.
+  const tasks = snapshot.tasks
+  const candidates = useMemo(() => {
+    const lineage = buildLineageIndex(tasks)
+    return tasks.filter(task =>
+      task.archivedAt === undefined
+      // A running task may already be a participant of another run group; the
+      // Host refuses the move, so it is not offered here.
+      && task.status !== 'running'
+      && task.parentId === undefined
+      && task.id !== parent.id
+      && checkParentLink(tasks, task.id, parent.id, limit, lineage).ok,
+    )
+  }, [tasks, parent.id, limit])
   const link = async (taskId: string): Promise<void> => {
     setPending(true)
     setError(undefined)