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

package/lib/types/core/tasks.d.ts

@@ -5,7 +5,9 @@
  * unit-testable in isolation.
  */
 import type { FreezeSnapshot } from './freeze-snapshot.ts';
+import type { ExecutionVerification } from './verification.ts';
 import type { TaskHandover, TaskHandoverInput } from './handover.ts';
+import { type TaskBoardExtensionPayload } from './extension.ts';
 /** Task lifecycle status, one per kanban column. */
 export type TaskStatus = 'backlog' | 'todo' | 'running' | 'done' | 'failed';
 /** Settled outcome of one execution attempt. */
@@ -52,6 +54,14 @@ export interface ExecutionRecord {
     ownResult?: ExecutionOutcome;
     /** Human failure text that arrived with {@link ownResult}. */
     ownError?: string;
+    /**
+     * Goal acceptance state of this execution (task-board goal verification).
+     * Fixed when the execution starts and never rewritten from later settings:
+     * the contract is frozen here, the attempts accrue here, and the settlement
+     * rule reads the pass record here. Absent on an execution that started
+     * before the feature existed, which keeps it on the historical verdict.
+     */
+    verification?: ExecutionVerification;
 }
 /**
  * Maximum number of execution records retained per task. Older settled runs
@@ -75,6 +85,13 @@ export interface ScheduleRule {
     enabled: boolean;
     /** 5-field cron expression: `分 时 日 月 周`. */
     cron: string;
+    /**
+     * IANA zone the cron wall clock is read in (issue #1722). Absent means the
+     * Host process zone, which is what a rule written before zones were
+     * persisted keeps using; the Host stamps its own zone at ledger migration so
+     * a later `TZ` change cannot silently move an existing rule.
+     */
+    timeZone?: string;
     /** Next due instant (ms epoch); maintained by the scheduler/controller. */
     nextRunAt: number | undefined;
     /** Instant of the latest scheduled trigger (ms epoch). */
@@ -214,6 +231,30 @@ export interface TaskRecord {
      * and a subtask's own permission pin cannot be honored in this mode.
      */
     teamRun?: boolean;
+    /**
+     * Start every execution of this task with dsh's built-in `/goal` command,
+     * armed with the composed execution prompt as its objective. The session then
+     * keeps working automatic continuation rounds until the agent marks the goal
+     * complete, and this board settles the execution on the goal's own end
+     * instead of at the first turn end. Absent means ON — the option is checked
+     * by default, so only an explicit `false` runs the task as a single plain
+     * turn. A session whose `/goal` command is refused still runs the prompt.
+     */
+    goalRun?: boolean;
+    /**
+     * Run this task's goal executions WITHOUT the board's acceptance gate.
+     *
+     * Absent means INHERIT: the execution's applicability is decided by the
+     * board-wide `goalVerification` switch frozen at start, exactly as a card
+     * that never touched this option behaves. Only an explicit `true` opts the
+     * card out, and the execution records `applicability: 'disabled'` so the
+     * report says plainly that nothing certified this run.
+     *
+     * The opt-out is per execution, not per run: flipping it never rewrites the
+     * verdict rule of an execution already open, and a rerun or a scheduled
+     * occurrence reads the card's current value when it freezes its contract.
+     */
+    skipVerification?: boolean;
     /**
      * Frozen context snapshot for a continuation card; absent on plain tasks.
      * Sanitized before it enters the ledger (redaction, slash-command taint,
@@ -245,6 +286,20 @@ export interface TaskRecord {
      * absent means on-board.
      */
     archivedAt?: number;
+    /**
+     * Opaque external-provider metadata, keyed by extension id; optional and
+     * additive so existing tasks require no ledger migration. The board stores
+     * and forwards it without interpreting the keys — each provider owns the
+     * shape and validation of its own entry.
+     */
+    integrations?: Record<string, TaskBoardExtensionPayload>;
+    /**
+     * Whether the card is held off the board: it exists in the ledger (and its
+     * execution history is intact) but no column ever renders it. Providers
+     * create hidden cards for work they materialize but do not want displayed;
+     * absent means on-board.
+     */
+    hidden?: boolean;
 }
 /**
  * Statuses a task may be archived from: every status but `running`, whose
@@ -270,7 +325,7 @@ export interface NewTaskInput {
      * inherits the parent's unset execution targets.
      */
     parentId?: string;
-    /** Workspace the execution must run in; empty/absent = the recent workspace. */
+    /** Workspace the execution must run in; empty/absent = the creating session's workspace for a root task, else the recent workspace at execution time. */
     workspaceId?: string;
     /** Agent preset the execution session must be composed from; empty/absent = deployment default. */
     mode?: string;
@@ -282,14 +337,26 @@ export interface NewTaskInput {
     reuseSession?: boolean;
     /** Run the subtree as an Agent Team (Team Lead session plus one teammate per direct subtask). */
     teamRun?: boolean;
+    /**
+     * Start the execution with dsh's built-in `/goal`. Absent/true keeps the
+     * default (goal run); an explicit false requests a single plain turn.
+     */
+    goalRun?: boolean;
+    /**
+     * Run this task's goal executions without the acceptance gate; absent
+     * inherits the board-wide `goalVerification` switch.
+     */
+    skipVerification?: boolean;
     /**
      * Optional scheduled-run rule requested at creation time (the new-task
-     * dialog): an enable flag plus a 5-field cron expression. The create use
-     * case arms it only when enabled and the expression is valid.
+     * dialog): an enable flag, a 5-field cron expression, and the IANA zone its
+     * wall clock is read in (absent means the Host zone). The create use case
+     * arms it only when enabled and the expression is valid.
      */
     schedule?: {
         enabled: boolean;
         cron: string;
+        timeZone?: string;
     };
     /**
      * Optional frozen context snapshot (goal/progress/next, sanitized by the
@@ -309,13 +376,31 @@ export interface NewTaskInput {
      * ahead of the execution prompt; a bare name changes nothing at run time.
      */
     tags?: TaskTag[];
+    /** Opaque external-provider metadata keyed by extension id. */
+    integrations?: Record<string, TaskBoardExtensionPayload>;
+    /** Column the created card opens in; absent means the board default (todo). */
+    status?: TaskStatus;
+    /** Create the card off-board (held in the ledger, never rendered). */
+    hidden?: boolean;
 }
 /** The five kanban columns, in display order. */
 export declare const COLUMNS: readonly {
     status: TaskStatus;
     label: string;
 }[];
-/** Statuses a user may move a card to manually (execution states are owned by the runner). */
+/**
+ * Statuses a card may be moved to by hand: every column. The board UI and the
+ * agent tool surface share this one list, so no column can be manual on one
+ * surface and locked on the other.
+ *
+ * The column is a board statement, not a claim about a run. A hand-written
+ * `done`/`failed` declares that the work finished (or failed) outside a
+ * Host-run execution — human hands, an external system — and a hand-written
+ * `running` says the work is under way without a tracked session. None of them
+ * creates an {@link ExecutionRecord}, which is what keeps a declaration
+ * distinguishable from a recorded outcome in the card's execution history; the
+ * next settled run overwrites the column with the real one.
+ */
 export declare const MANUAL_STATUSES: readonly TaskStatus[];
 /** Statuses the runner may move a card to from 'running'. */
 export declare const RUNNER_SETTLE_STATUSES: readonly TaskStatus[];
@@ -323,8 +408,28 @@ export declare const RUNNER_SETTLE_STATUSES: readonly TaskStatus[];
 export declare const ALL_STATUSES: readonly TaskStatus[];
 /** Brand an unknown string as a status; undefined when it is not one. */
 export declare function isTaskStatus(value: unknown): value is TaskStatus;
-/** Whether a manual move target is allowed from the given status. */
+/**
+ * Whether the manual move `from` -> `to` is a legal *column* change: any
+ * column, and never the one the card already shows.
+ *
+ * Whether the card may be moved at all is a separate question. The lock an
+ * executing card carries belongs to its open execution, never to the column
+ * text, so it is {@link canMoveTask} — not this predicate — that expresses it.
+ */
 export declare function canMoveManually(from: TaskStatus, to: TaskStatus): boolean;
+/**
+ * Whether the board may move `task` to `to` by hand: the card is on-board,
+ * holds no open execution, and the target is a legal column change. The ledger,
+ * the detail view's status buttons and the board's drop handler all decide
+ * through this one predicate, so no two surfaces can disagree about a card.
+ */
+export declare function canMoveTask(task: TaskRecord, to: TaskStatus): boolean;
+/**
+ * Whether the task still has an execution the runner has not settled. This —
+ * not the `running` column — is what "the runner owns this card" means: a card
+ * parked in `running` by hand has no session and stays fully movable.
+ */
+export declare function hasOpenExecution(task: TaskRecord): boolean;
 /** Normalize one optional execution-target string: trim; blank collapses to undefined. */
 export declare function normalizeTargetId(value: string | undefined): string | undefined;
 /**

package/lib/types/core/use-cases/task-create.d.ts

@@ -22,5 +22,6 @@ export interface CreateTaskResult {
  * @param now - clock instant (ms epoch).
  * @param id - minted task id.
  * @param maxSubtaskDepth - deployment subtask depth limit.
+ * @param hostTimeZone - zone a rule that stores no zone of its own follows.
  */
-export declare function applyCreateTask(tasks: readonly TaskRecord[], input: NewTaskInput, now: number, id: string, maxSubtaskDepth?: number): CreateTaskResult;
+export declare function applyCreateTask(tasks: readonly TaskRecord[], input: NewTaskInput, now: number, id: string, maxSubtaskDepth?: number, hostTimeZone?: string): CreateTaskResult;

package/lib/types/core/use-cases/task-schedule.d.ts

@@ -3,6 +3,8 @@ import { type TaskRecord } from '../tasks.ts';
 export interface SetSchedulePatch {
     enabled?: boolean;
     cron?: string;
+    /** IANA zone for the cron wall clock; `null` clears it back to the Host zone. */
+    timeZone?: string | null;
 }
 /** Result of arming/disarming a rule. */
 export interface SetScheduleResult {
@@ -12,15 +14,17 @@ export interface SetScheduleResult {
     applied: boolean;
 }
 /**
- * Set an on-board task's schedule rule. A blank or invalid cron, or an
- * archived task, is rejected (state untouched); an enabled rule computes the
- * next run instant immediately, a disabled one carries no next-run instant.
+ * Set an on-board task's schedule rule. A blank or invalid cron, an unknown or
+ * archived task, or an unusable zone is rejected (state untouched); an enabled
+ * rule computes the next run instant immediately in the rule's own zone, a
+ * disabled one carries no next-run instant.
  * @param tasks - current ledger.
  * @param id - the task to schedule.
  * @param patch - rule fields to change (absent fields keep their current value).
  * @param now - clock instant (ms epoch).
+ * @param hostTimeZone - zone a rule with no stored zone follows.
  */
-export declare function applySetSchedule(tasks: readonly TaskRecord[], id: string, patch: SetSchedulePatch, now: number): SetScheduleResult;
+export declare function applySetSchedule(tasks: readonly TaskRecord[], id: string, patch: SetSchedulePatch, now: number, hostTimeZone: string): SetScheduleResult;
 /**
  * Roll a task's schedule rule forward (scheduler callback): persist the next
  * due instant and the trigger instant. No-op for tasks without a rule (deleted

package/lib/types/core/use-cases/task-tag.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Label-management use cases (issue: labels could not be cleaned up).
+ *
+ * A label lives on every task that carries it, so renaming or removing one is a
+ * ledger-wide edit, not a task edit: the board's label row is the union of the
+ * labels in use, and without these two transitions a label created by an
+ * afternoon experiment stayed on the board forever.
+ *
+ * Both transitions are pure ledger rewrites (no persistence, no notify — the
+ * controller and the Host ledger orchestrate those), and both are idempotent:
+ * a label that no task carries changes nothing and reports no error for the
+ * delete path (the desired end state already holds), while a rename from an
+ * unknown label is refused so a stale tab cannot silently do nothing.
+ *
+ * Renaming onto a name that is already in use MERGES the two: a task carrying
+ * both keeps the row it already had (with its execution hint) and loses the
+ * duplicate, which is the only reading that cannot lose a hint the user typed.
+ */
+import { type TaskRecord } from '../tasks.ts';
+/** Outcome of one ledger-wide label edit. */
+export interface TagEditResult {
+    /** The ledger after the edit, or the input unchanged when nothing applied. */
+    tasks: readonly TaskRecord[];
+    /** Whether any task actually changed (drives whether the caller persists). */
+    changed: boolean;
+    /** Refusal reason; the ledger is unchanged when set. */
+    error?: string;
+}
+/**
+ * Rename one label everywhere, merging into an existing label of the target
+ * name. Every touched task gets a fresh updatedAt; untouched tasks keep theirs.
+ * @param tasks - current ledger.
+ * @param from - the label to rename.
+ * @param to - the new name (an existing name merges the two labels).
+ * @param now - clock instant (ms epoch).
+ * @returns the rewritten ledger, or a refusal.
+ */
+export declare function applyRenameTag(tasks: readonly TaskRecord[], from: string, to: string, now: number): TagEditResult;
+/**
+ * Remove one label from every task that carries it. Archived cards are included:
+ * the board's label row draws from the whole ledger, so a label left on an
+ * archived card would come straight back into the filter.
+ * @param tasks - current ledger.
+ * @param name - the label to remove.
+ * @param now - clock instant (ms epoch).
+ * @returns the rewritten ledger.
+ */
+export declare function applyDeleteTag(tasks: readonly TaskRecord[], name: string, now: number): TagEditResult;

package/lib/types/core/use-cases/task-update.d.ts

@@ -15,7 +15,7 @@ import type { TaskHandoverInput } from '../handover.ts';
  * Editable fields on a task (the update patch surface). `freeze` replaces the
  * continuation-card snapshot (restamping frozenAt); an explicit null clears it.
  */
-export type TaskUpdatePatch = Partial<Pick<TaskRecord, 'title' | 'description' | 'prompt' | 'workspaceId' | 'mode' | 'permission' | 'model' | 'reuseSession' | 'teamRun'>> & {
+export type TaskUpdatePatch = Partial<Pick<TaskRecord, 'title' | 'description' | 'prompt' | 'workspaceId' | 'mode' | 'permission' | 'model' | 'reuseSession' | 'teamRun' | 'goalRun' | 'skipVerification'>> & {
     freeze?: FreezeSnapshot & {
         redacted?: boolean;
     } | null;
@@ -39,8 +39,10 @@ export declare const TASK_CONTENT_FIELDS: readonly ["title", "description", "pro
 export declare function hasContentPatch(patch: TaskUpdatePatch): boolean;
 /**
  * Whether a task's content may still be edited: the task must be on-board
- * (not archived) and must never have started executing. Fail-closed: a
- * running, settled, or cancelled-before-launch task keeps its content fixed.
+ * (not archived) and must never have started executing. Fail-closed: a task
+ * with any execution record — running, settled, or cancelled before launch —
+ * keeps its content fixed. The run, not the column, is the trigger: a card
+ * parked in 'running' by hand has nothing recorded yet and stays editable.
  */
 export declare function canEditTaskContent(task: TaskRecord): boolean;
 /**