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

package/lib/types/client/board/TaskForm.d.ts

@@ -4,7 +4,7 @@
  * NewTaskModal and the EditTaskModal. State stays in the owning modal; these
  * are controlled components.
  */
-import type { ReactNode } from 'react';
+import { type ReactNode } from 'react';
 import { type TaskTag } from '../../core/tasks.ts';
 /** Modal overlay: closes on backdrop press, submits through the form. */
 export declare function ModalShell({ ariaLabel, title, error, pending, submitLabel, onSubmit, onClose, secondaryAction, children, }: {
@@ -22,6 +22,24 @@ export declare function ModalShell({ ariaLabel, title, error, pending, submitLab
     };
     children: ReactNode;
 }): import("react").JSX.Element;
+/**
+ * One collapsible region of a task form (create/edit dialog UX): the form
+ * groups its configuration into a few regions instead of stacking every field
+ * in one long column, so a normal-sized dialog needs no scrollbar. A collapsed
+ * region keeps a one-line summary of the values it holds, so nothing is hidden
+ * without a trace; a region holding a blocking error is forced open by its
+ * owner (forceOpen) rather than reporting the error out of sight.
+ */
+export declare function CollapsibleSection({ title, summary, defaultOpen, forceOpen, children, }: {
+    title: string;
+    /** One-line value preview rendered only while the region is collapsed. */
+    summary?: string | undefined;
+    /** Whether the region starts expanded (the owner's default layout). */
+    defaultOpen?: boolean;
+    /** Open regardless of the stored state: an error inside must stay visible. */
+    forceOpen?: boolean;
+    children: ReactNode;
+}): import("react").JSX.Element;
 /** Title + description + prompt fields shared by the new and edit task forms. */
 export declare function TaskContentFields({ title, description, prompt, onTitleChange, onDescriptionChange, onPromptChange, }: {
     title: string;

package/lib/types/client/board/preset-label.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Display-only labels for the agent-preset roster, shared by the task form and
+ * the detail view.
+ *
+ * The deployment's four built-in presets (the `standard` / `ptc` / `minimal` /
+ * `cordis` rows the shipped web-app bundle declares) carry no display name in
+ * the registry roster, so a picker would list bare ids beside the user presets.
+ * The map below only supplies names for those four; any other id — a renamed
+ * built-in, a community preset, a user preset — falls back to the roster name
+ * and then to the id, so this table can never hide or mislabel a preset.
+ */
+import type { ExecutionPresetOption } from '../../core/controller.ts';
+/** Whether one roster row is a shipped built-in preset. */
+export declare function isBuiltinPreset(id: string): boolean;
+/** Display label of one preset row: built-in label, roster name, or raw id. */
+export declare function presetLabel(preset: Pick<ExecutionPresetOption, 'id' | 'name'>): string;
+/**
+ * Label of the empty ("inherit") choice: names the preset a run actually lands
+ * on when the card pins nothing, which is the deployment default the roster
+ * marks with `isDefault`.
+ */
+export declare function inheritPresetLabel(presets: readonly ExecutionPresetOption[]): string;

package/lib/types/client/host-api.d.ts

@@ -7,13 +7,36 @@ import { type TaskBoardAction, type TaskBoardEventPayload, type TaskBoardParseDr
  * "Unexpected token 'o', \"not found\" is not valid JSON" is what a missing
  * Host half looks like today.
  */
-export type HostApiFailure = 'not-mounted' | 'unauthorized' | 'locked' | 'rejected' | 'timeout' | 'unreachable' | 'unexpected';
+export type HostApiFailure = 
+/** The board's own routes are not registered and nothing explains why. */
+'not-mounted'
+/** Another live DSH process owns the ledger, so this instance registered no board routes (#1730). */
+ | 'ledger-locked'
+/** This row degraded during start for some other reason the family health route reports (#1730). */
+ | 'degraded' | 'unauthorized' | 'forbidden' | 'locked' | 'rejected' | 'timeout' | 'unreachable' | 'unexpected';
 /** Transport failure carrying a stable class next to its user-facing message. */
 export declare class HostApiError extends Error {
     readonly failure: HostApiFailure;
     readonly status?: number | undefined;
     constructor(failure: HostApiFailure, message: string, status?: number | undefined);
 }
+/**
+ * Name the real reason this board's routes are missing (issue #1730).
+ *
+ * The core webserver answers an unmounted route with a bare 404, which cannot
+ * distinguish "this deployment never loaded the plugin" from "this row
+ * degraded during start" — a second DSH process holding `ledger-v2.lock` is
+ * the case that matters, because the panel's advice ("restart the service")
+ * is then false: the lock belongs to the other process, and restarting cannot
+ * win it. The family health route knows the difference, so the 404 is
+ * disambiguated there before anything is shown.
+ * @param fallback - copy for the plain "routes are not there" failure, which
+ *   is route-specific (the board's state route and the AI-parse route phrase
+ *   their own absence); it is also what is shown when the ledger names nothing.
+ * @param fetchImpl - fetch implementation (injected for tests).
+ * @returns the HostApiError to throw for a missing board route.
+ */
+export declare function missingRouteFailure(fallback?: string, fetchImpl?: typeof fetch): Promise<HostApiError>;
 export interface TaskBoardHostTransport {
     bootstrap(legacy: readonly TaskRecord[]): Promise<TaskBoardSnapshot>;
     state(): Promise<TaskBoardSnapshot>;

package/lib/types/client/locales.d.ts

@@ -29,7 +29,10 @@ export declare const zh: {
     'board.created': string;
     'board.hostError': string;
     'board.hostError.notMounted': string;
+    'board.hostError.ledgerLocked': string;
+    'board.hostError.degraded': string;
     'board.hostError.unauthorized': string;
+    'board.hostError.forbidden': string;
     'board.hostError.locked': string;
     'board.hostError.timeout': string;
     'board.hostError.unreachable': string;
@@ -54,6 +57,19 @@ export declare const zh: {
     'new.aiParseFailed': string;
     'board.retryHost': string;
     'board.hostMeta': string;
+    'new.section.parse': string;
+    'new.section.content': string;
+    'new.section.labels': string;
+    'new.section.execution': string;
+    'new.section.run': string;
+    'new.section.handover': string;
+    'new.section.schedule': string;
+    'new.summary.none': string;
+    'new.summary.labelCount': string;
+    'new.summary.filled': string;
+    'new.summary.scheduleOff': string;
+    'new.summary.multiRound': string;
+    'new.summary.singleRound': string;
     'new.title': string;
     'new.titlePlaceholder': string;
     'new.description': string;
@@ -145,13 +161,31 @@ export declare const zh: {
     'detail.schedule.invalid': string;
     'detail.schedule.notScheduled': string;
     'detail.schedule.dueSoon': string;
+    'detail.schedule.timeZone': string;
+    'detail.schedule.timeZoneHost': string;
+    'detail.schedule.timeZoneHostUnknown': string;
+    'detail.schedule.timeZoneHint': string;
+    'detail.schedule.timeZoneSearch': string;
+    'detail.schedule.timeZoneNone': string;
+    'detail.schedule.nextRunOverdue': string;
+    'detail.schedule.duration.days': string;
+    'detail.schedule.duration.hours': string;
+    'detail.schedule.duration.minutes': string;
+    'detail.schedule.duration.seconds': string;
     'card.scheduled': string;
     'new.workspace': string;
-    'new.mode': string;
+    'new.agentPreset': string;
     'new.permission': string;
     'new.model': string;
     'exec.workspace.recent': string;
-    'exec.mode.default': string;
+    'exec.mode.inherit': string;
+    'exec.mode.inheritWith': string;
+    'exec.mode.builtinGroup': string;
+    'exec.mode.customGroup': string;
+    'preset.builtin.standard': string;
+    'preset.builtin.ptc': string;
+    'preset.builtin.minimal': string;
+    'preset.builtin.cordis': string;
     'exec.mode.defaultSuffix': string;
     'exec.mode.brokenSuffix': string;
     'exec.mode.removed': string;
@@ -167,6 +201,8 @@ export declare const zh: {
     'exec.teamRunHint': string;
     'exec.teamRunUnavailable': string;
     'exec.reuseSessionHint': string;
+    'exec.goalRun': string;
+    'exec.goalRunHint': string;
     'detail.executionSettings': string;
     'exec.hint': string;
     'settings.title': string;

package/lib/types/client/schedule-zone.d.ts

@@ -0,0 +1,47 @@
+/** One selectable zone, in the order the picker shows it. */
+export interface ZoneChoice {
+    /** Canonical IANA id, or `''` for the Host-zone entry. */
+    id: string;
+    /** Display label. */
+    label: string;
+}
+/**
+ * Zones offered by the picker: the Host zone first (the default, and the entry
+ * a rule with no stored zone follows), then the runtime's own inventory.
+ *
+ * The Host entry is always present, even before the Host snapshot reports a
+ * zone: it is the entry that stores no zone, so dropping it would leave a rule
+ * unable to express "follow the Host" and would let the control silently
+ * display an unrelated zone.
+ *
+ * A stored zone the inventory does not list (a rule written on another machine
+ * or under a different ICU build) is appended, so opening the editor can never
+ * silently rewrite the rule's zone.
+ * @param hostTimeZone - zone the Host reported for this deployment, when known.
+ * @param storedTimeZone - zone the edited rule already stores, when any.
+ * @returns the de-duplicated choice list.
+ */
+export declare function zoneChoices(hostTimeZone: string | undefined, storedTimeZone?: string): ZoneChoice[];
+/**
+ * The relative half of a next-run label: how far away the instant is, or how
+ * far past it the board is running. `now` is passed in rather than sampled so
+ * callers can share one clock reading across a row, and tests stay
+ * deterministic.
+ * @param targetMs - the instant being described.
+ * @param now - the reference instant.
+ * @returns localized relative wording.
+ */
+export declare function relativeTimeLabel(targetMs: number, now: number): string;
+/**
+ * The full next-run label: the absolute wall clock in the schedule's own zone,
+ * plus the relative distance in parentheses. Showing both matters because a
+ * rule's zone can differ from the reader's, so the wall clock alone is
+ * ambiguous and the distance alone loses the actual moment.
+ * @param targetMs - the instant being described.
+ * @param timeZone - zone to render the absolute half in.
+ * @param formatAbsolute - formatter for the absolute half (keeps Intl caching in the caller).
+ * @param now - the reference instant.
+ * @param translate - translate function, bound so this module stays dependency-light.
+ * @returns the combined label.
+ */
+export declare function nextRunLabel(targetMs: number, timeZone: string | undefined, formatAbsolute: (ms: number, timeZone?: string) => string, now: number): string;

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

@@ -262,6 +262,7 @@ export declare class BoardController {
     setSchedule(id: string, patch: {
         enabled?: boolean;
         cron?: string;
+        timeZone?: string | null;
     }): boolean;
     /**
      * Legacy pure-controller seam retained for migration-focused tests. The

package/lib/types/core/degraded-reason.d.ts

@@ -0,0 +1,46 @@
+/**
+ * The family health ledger's degraded-record contract (issues #1528, #1730).
+ *
+ * A family plugin row that fails during apply is recorded by the dsh-web-all
+ * shell as a degraded record; the shell serves the ledger through its
+ * loopback-only `GET /api/dsh-web-all/degraded` route because the failed
+ * plugin could not register any route of its own — the task board whose ledger
+ * lock is held by another DSH process is exactly that case, and without this
+ * the panel could only report "the Host API is not mounted".
+ *
+ * Both halves define this shape: the shell WRITES it (packages/dsh-web-all,
+ * src/degraded.ts — the two packages have no import edge, one is bundled into
+ * the other's profile) and a plugin's browser half PARSES it. The edits move
+ * together.
+ */
+/** Where a degraded row failed: module import, plugin shape, or fiber start. */
+export type DegradedStage = 'import' | 'shape' | 'start';
+/** One degraded family row as the shell's health route serves it. */
+export interface DegradedRow {
+    /** Real plugin package name from the shell row config. */
+    plugin: string;
+    /** Where the failure happened. */
+    stage: DegradedStage;
+    /** The shell's one-line reason, for display. */
+    reason: string;
+}
+/**
+ * The one degraded record naming `plugin`, or undefined when that row is not
+ * degraded (or the payload does not come from the shell's own shape). A
+ * plugin may appear once: the shell keys the ledger by package name and
+ * refreshes the record on every new failure.
+ * @param body - parsed JSON body of the health route.
+ * @param plugin - the real plugin package name to look for.
+ * @returns the degraded row, or undefined when the ledger does not name it.
+ */
+export declare function degradedRowOf(body: unknown, plugin: string): DegradedRow | undefined;
+/**
+ * Extract the pid of the LIVE process a ledger-lock failure blames, when the
+ * reason identifies one. The task board's lock refusal is the one degraded
+ * reason that carries an owner the user can act on, so the panel renders the
+ * pid in its own sentence and adds the guidance that actually applies.
+ * @param reason - the shell's one-line failure reason.
+ * @returns the confirmed owner pid, or undefined when the reason names none or
+ *   warns that the PID may have been reused (its own text owns the recovery).
+ */
+export declare function ledgerOwnerPid(reason: string): number | undefined;

package/lib/types/core/package-name.d.ts

@@ -0,0 +1,9 @@
+/**
+ * npm identity of this plugin. The dsh-web-all degraded ledger is keyed by the
+ * real plugin package name of a family row, and this plugin's browser half
+ * must name its OWN row there to learn why its Host API is missing (issue
+ * #1730): the served bundle cannot derive the name, because a family row
+ * mounts the package from a versioned profile path. The host half spells the
+ * same name in its single-mount guard (src/index.ts); the two move together.
+ */
+export declare const TASK_BOARD_PACKAGE = "@linxin666/dsh-client-ui-task-board";

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

@@ -1,15 +1,36 @@
 /**
- * Minimal 5-field cron parsing and next-run computation for scheduled task
- * runs. Framework-free and dependency-free so the scheduler and controller
- * share one tiny pure module.
+ * Zone-aware 5-field cron parsing and next-run computation for scheduled task
+ * runs. Framework-free and dependency-free (Intl only) so the Host scheduler
+ * and the browser next-run preview share one tiny pure module.
  *
  * Grammar: five whitespace-separated fields, 分 时 日 月 周. Every field
  * supports the wildcard, step (wildcard or range + "/n"), single value,
  * inclusive range a-b, and comma lists mixing any of those. Ranges: minutes
  * 0-59, hours 0-23, days 1-31, months 1-12, weekdays 0-7 (0 and 7 both mean
- * Sunday). When both the day and weekday fields are restricted they combine
- * with OR semantics (standard cron). Invalid expressions parse to null and
- * are rejected by the UI/controller.
+ * Sunday). Invalid expressions parse to null and are rejected by the UI and
+ * the Host.
+ *
+ * Day semantics follow Vixie cron: a field is *starred* when its field text
+ * starts with `*`. When day-of-month and day-of-week are both restricted the
+ * fields combine with OR; otherwise they combine with AND. The distinction
+ * matters for a stepped star such as `*/2`, which still restricts the dates it
+ * matches, so `0 0 */2 * 1` means "the Mondays that fall on an even day of
+ * month" rather than "every even day, or every Monday".
+ *
+ * Time zone: every candidate wall clock is interpreted in an explicit IANA
+ * zone (the schedule's stored zone, or the Host zone when none is given).
+ * A wall clock that does not exist (spring-forward gap) is skipped, and an
+ * ambiguous wall clock (fall-back overlap) resolves to the earlier instant, so
+ * a repeated local minute fires exactly once. The Host-scheduler semantics are
+ * byte-identical to `@deepseek-ai/dsh-schedule`'s resolver, which was verified
+ * against it across twelve IANA zones (including 30-minute and 45-minute DST
+ * offsets and a date-line jump) and 300k decision instants.
+ *
+ * That upstream is on the experimental track and is NOT a dependency here (no
+ * import, no inject, no peer range), so a change to it fails no test. Re-run the
+ * differential check on any `dsh-schedule` release or cohort bump that moves it,
+ * and keep this comment honest; the re-verification trigger is recorded in
+ * [the owning Agent Note](../../../../.agents/notes/implemented/feature/2026-09-29-task-board-schedule-time-zone.md).
  */
 /** The parsed match sets of one cron expression. */
 export interface CronSchedule {
@@ -19,11 +40,61 @@ export interface CronSchedule {
     months: ReadonlySet<number>;
     /** Weekdays 0-6, 0 = Sunday (input 7 normalized to 0). */
     weekdays: ReadonlySet<number>;
-    /** Whether the day-of-month field was the literal '*' (unrestricted). */
-    dayWildcard: boolean;
-    /** Whether the weekday field was the literal '*' (unrestricted). */
-    weekdayWildcard: boolean;
+    /** Whether the day-of-month field text starts with `*` (Vixie starred). */
+    dayStarred: boolean;
+    /** Whether the weekday field text starts with `*` (Vixie starred). */
+    weekdayStarred: boolean;
+}
+/** Fallback zone when the process reports no usable IANA zone. */
+export declare const HOST_TIME_ZONE_FALLBACK = "UTC";
+/** One resolved wall-clock reading in some zone. */
+export interface ZonedParts {
+    year: number;
+    month: number;
+    day: number;
+    hour: number;
+    minute: number;
 }
+/**
+ * The wall-clock reading of one instant in an explicit zone. Reading through
+ * Intl (rather than the process `Date` accessors) is what makes the result
+ * independent of the Host's own TZ.
+ * @param timeZone - explicit IANA zone.
+ * @param epochMs - instant to read.
+ * @returns the zone-local calendar and clock fields.
+ */
+export declare function partsInZone(timeZone: string, epochMs: number): ZonedParts;
+/**
+ * Resolve a wall clock in an explicit zone to its instant.
+ *
+ * The offset is probed a day either side of the naive guess so both DST
+ * transitions are covered, then every candidate offset whose inverse maps back
+ * to the requested wall clock is kept. No survivor means the wall clock does
+ * not exist (a spring-forward gap); several means it is ambiguous (a fall-back
+ * overlap), and the earliest instant wins so the repeated clock is taken once.
+ * @param timeZone - explicit IANA zone.
+ * @param year - full calendar year.
+ * @param month - 1-12.
+ * @param day - day of month.
+ * @param hour - 0-23.
+ * @param minute - 0-59.
+ * @returns the instant in ms epoch, or undefined when the wall clock is skipped.
+ */
+export declare function zonedEpoch(timeZone: string, year: number, month: number, day: number, hour: number, minute: number): number | undefined;
+/**
+ * The Host process's IANA zone, used for schedules that store no zone of their
+ * own (a ledger written before zones were persisted).
+ * @returns a zone name Intl accepts, never empty.
+ */
+export declare function resolveHostTimeZone(): string;
+/**
+ * Whether a value names a zone this runtime can actually resolve. A stored
+ * zone is trusted only after it round-trips through Intl, so a typo or a zone
+ * that this ICU build does not know can never arm a schedule.
+ * @param value - candidate zone name.
+ * @returns true when the name is usable.
+ */
+export declare function isValidTimeZone(value: string): boolean;
 /**
  * Parse a 5-field cron expression.
  * @returns the match sets, or null when the expression is invalid.
@@ -32,18 +103,22 @@ export declare function parseCron(expr: string): CronSchedule | null;
 /** Whether the expression parses. */
 export declare function isValidCron(expr: string): boolean;
 /**
- * Compute the next matching instant after `fromMs` (ms epoch), in local time,
- * at minute granularity, strictly greater than `fromMs`. Returns the ms epoch
- * of the matching minute's start, or undefined when the calendar constraint
- * can never match (for example `0 0 30 2 *`). The five-year horizon includes
- * a full leap cycle, so a valid February 29 schedule remains reachable from
- * every non-leap year.
+ * Compute the next matching instant after `fromMs` strictly greater than it,
+ * interpreting the expression's wall clock in `timeZone` (the Host zone when
+ * omitted). Returns the ms epoch of the matching minute's start, or undefined
+ * when the calendar constraint can never match (for example `0 0 30 2 *`).
+ * The five-year horizon includes a full leap cycle, so a valid February 29
+ * schedule remains reachable from every non-leap year.
  *
  * Walks candidate year/month/day/hour/minute values straight from the parsed
  * field sets instead of scanning every minute: a sparse expression such as
  * `0 0 29 2 *` used to iterate ~1.5M wall-clock minutes before reaching the
- * next leap day. Wall-clock field construction + the final `matches` re-check
- * preserve the old minute scan's DST semantics exactly (nonexistent spring
- * minutes normalize forward and the repeated fall-back hour is never visited).
+ * next leap day. A candidate wall clock that the zone skips (spring-forward
+ * gap) is passed over, which is what makes the gap semantics fall out of the
+ * candidate walk rather than needing a separate rule.
+ * @param expr - 5-field cron expression.
+ * @param fromMs - exclusive lower bound, ms epoch.
+ * @param timeZone - explicit IANA zone; defaults to the Host zone.
+ * @returns the next trigger instant, or undefined when unreachable.
  */
-export declare function nextRunAtMs(expr: string, fromMs: number): number | undefined;
+export declare function nextRunAtMs(expr: string, fromMs: number, timeZone?: string): number | undefined;

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

@@ -24,28 +24,40 @@ export declare const DEFAULT_SUBTASK_DEPTH = 1;
 export declare function normalizeSubtaskDepth(value: unknown): number;
 /** Whether an unknown value is a settled execution outcome. */
 export declare function isExecutionOutcome(value: unknown): value is ExecutionOutcome;
+/**
+ * Reusable lineage index over ONE task list: the id lookup and the direct
+ * children per parent. A caller that runs several lineage queries over the same
+ * ledger (the link-subtask candidate gate runs one per task) builds this once
+ * instead of rescanning the list per query.
+ */
+export interface LineageIndex {
+    readonly byId: ReadonlyMap<string, TaskRecord>;
+    readonly childrenByParent: ReadonlyMap<string, readonly TaskRecord[]>;
+}
+/** Build the reusable index for a task list (ledger order preserved). */
+export declare function buildLineageIndex(tasks: readonly TaskRecord[]): LineageIndex;
 /**
  * Nearest-first ancestor chain of a task. The walk is cycle-safe and bounded
  * by the ledger size rather than by the deployment maximum: a chain stored
  * under a larger limit survives that limit being lowered, and restore and
  * inheritance must still see all of it.
  */
-export declare function ancestorChain(tasks: readonly TaskRecord[], task: TaskRecord): TaskRecord[];
+export declare function ancestorChain(tasks: readonly TaskRecord[], task: TaskRecord, lineage?: LineageIndex): TaskRecord[];
 /** Root-to-task depth: a root task is 0, its subtask 1, and so on. */
-export declare function taskDepth(tasks: readonly TaskRecord[], id: string): number;
+export declare function taskDepth(tasks: readonly TaskRecord[], id: string, lineage?: LineageIndex): number;
 /** Direct subtasks of a task, in ledger order. */
-export declare function directSubtasks(tasks: readonly TaskRecord[], id: string): TaskRecord[];
+export declare function directSubtasks(tasks: readonly TaskRecord[], id: string, lineage?: LineageIndex): TaskRecord[];
 /**
  * Descendants of a task in breadth-first order, bounded by maxSubtaskDepth
  * total depth. The visited set keeps a malformed ledger from looping.
  */
-export declare function descendantTasks(tasks: readonly TaskRecord[], id: string, maxSubtaskDepth: number): TaskRecord[];
+export declare function descendantTasks(tasks: readonly TaskRecord[], id: string, maxSubtaskDepth: number, lineage?: LineageIndex): TaskRecord[];
 /**
  * Height of a task's own subtree (0 for a leaf), bounded by the hard maximum.
  * The visited set makes the walk terminate on a cyclic hand-edited ledger
  * instead of recursing until the stack overflows.
  */
-export declare function subtreeHeight(tasks: readonly TaskRecord[], id: string, visited?: ReadonlySet<string>): number;
+export declare function subtreeHeight(tasks: readonly TaskRecord[], id: string, visited?: ReadonlySet<string>, lineage?: LineageIndex): number;
 /** Why a parent link was refused; also the source of the Host error text. */
 export type ParentLinkRejection = 'unknown-task' | 'unknown-parent' | 'archived-parent' | 'self-parent' | 'cycle' | 'depth-exceeded';
 export interface ParentLinkCheck {
@@ -61,7 +73,7 @@ export interface ParentLinkCheck {
  * and the resulting depth (parent depth + 1 + the child own subtree height)
  * must stay within maxSubtaskDepth.
  */
-export declare function checkParentLink(tasks: readonly TaskRecord[], childId: string, parentId: string | null, maxSubtaskDepth: number): ParentLinkCheck;
+export declare function checkParentLink(tasks: readonly TaskRecord[], childId: string, parentId: string | null, maxSubtaskDepth: number, lineage?: LineageIndex): ParentLinkCheck;
 /**
  * The tasks one run request opens executions for: the requested task first,
  * then its on-board descendants within the configured depth. Archived tasks
@@ -110,13 +122,20 @@ export declare function effectiveTaskPermission(task: TaskRecord): TaskRecord['p
  */
 /**
  * The immutable teammate name for one team-mode member. Teammate names are
- * lower-kebab-case and must stay unique for the lifetime of the Team, so the
- * run-group token is appended: two runs of the same tree never collide. A title
- * with no ASCII word characters (a CJK title, for example) keeps a stable
- * generic prefix and is still distinguished by the token.
+ * lower-kebab-case and must stay unique for the lifetime of the Team: the
+ * run-group token separates two runs of the same tree, and the member
+ * discriminator separates two members of one run that reduce to the same slug.
+ *
+ * The discriminator is not cosmetic. A title with no ASCII word characters (a
+ * CJK title, for example) carries no slug at all, so every such title of one
+ * run group collides on the generic prefix; Agent Teams answers every member
+ * after the first with `teammate name "..." was already used in this Team`,
+ * and those subtasks never start. Two ASCII titles that share a slug
+ * (`AI 强度预测` next to `AI 配比优化`) collide the same way.
  * @param title - the member task's title.
  * @param token - the run group id (the task id when no group is recorded).
+ * @param memberId - the member task's id, which makes the name unique in the run.
  * @returns the teammate name handed to the Agent Teams service.
  */
-export declare function teammateName(title: string, token: string): string;
+export declare function teammateName(title: string, token: string, memberId?: string): string;
 export declare function resolveExecutionTargets(task: TaskRecord, tasks: readonly TaskRecord[], maxSubtaskDepth?: number): TaskRecord;

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

@@ -75,6 +75,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 +221,16 @@ 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;
     /**
      * Frozen context snapshot for a continuation card; absent on plain tasks.
      * Sanitized before it enters the ledger (redaction, slash-command taint,
@@ -282,14 +299,21 @@ 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;
     /**
      * 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

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-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'>> & {
     freeze?: FreezeSnapshot & {
         redacted?: boolean;
     } | null;