@linxin666/dsh-client-ui-task-board 0.3.23 → 0.3.24

package/lib/index.js

@@ -181,8 +181,10 @@ function isDigits(value) {
 * Pick the session a new execution of this task may continue in, or undefined
 * to mint a fresh conversation. Reuse requires ALL of:
 * - the task opted in (`reuseSession === true`);
-* - the task's newest execution carries a session id and has settled (an open
-*   execution would have made the ledger refuse the run in the first place);
+* - the task's newest SETTLED execution carries a session id (issue #1587: the
+*   launch path calls this after `startExecution` appended this run's own open
+*   record, so reading the array tail always found an unsettled row and reuse
+*   never happened);
 * - the roster is known and that session is present and idle.
 *
 * An unknown roster (session/list unavailable) never reuses: minting a fresh
@@ -194,8 +196,15 @@ function isDigits(value) {
 */
 function reusableSessionId(task, idleSessionIds) {
 	if (task.reuseSession !== true || idleSessionIds === void 0) return void 0;
-	const last = task.executions[task.executions.length - 1];
-	if (last === void 0 || last.sessionId === void 0 || last.endedAt === void 0) return void 0;
+	let last;
+	for (let index = task.executions.length - 1; index >= 0; index -= 1) {
+		const candidate = task.executions[index];
+		if (candidate.sessionId !== void 0 && candidate.endedAt !== void 0) {
+			last = candidate;
+			break;
+		}
+	}
+	if (last === void 0 || last.sessionId === void 0) return void 0;
 	return idleSessionIds.has(last.sessionId) ? last.sessionId : void 0;
 }
 //#endregion
@@ -1406,6 +1415,11 @@ function processIsAlive(pid) {
 	}
 }
 const PROCESS_PROBE_TIMEOUT_MS = 3e3;
+/**
+* The CIM fallback pays a WMI cold start, so it gets a wider budget than the
+* direct `Get-Process` read it backs up.
+*/
+const CIM_PROBE_TIMEOUT_MS = 8e3;
 let ownStartTime;
 let ownStartTimeResolved = false;
 /**
@@ -1430,6 +1444,52 @@ function linuxStartTimeMs(pid) {
 		return;
 	}
 }
+/** Default probe: one hidden, profile-free PowerShell process per script. */
+const runPowerShellProbe = (script, timeoutMs) => {
+	const probe = spawnSync("powershell", [
+		"-NoProfile",
+		"-NonInteractive",
+		"-Command",
+		script
+	], {
+		timeout: timeoutMs,
+		windowsHide: true
+	});
+	if (probe.status !== 0 || probe.stdout.length === 0) return void 0;
+	return probe.stdout.toString("utf8").trim();
+};
+/** The epoch-millisecond reading a probe printed, or undefined when unusable. */
+function parseProbeEpochMs(raw) {
+	if (raw === void 0 || raw.trim() === "") return void 0;
+	const started = Number(raw.trim());
+	return Number.isFinite(started) ? started : void 0;
+}
+/** Start time through Get-Process: precise, but empty for protected processes. */
+function getProcessStartScript(pid) {
+	return "[DateTimeOffset]::FromFileTime((Get-Process -Id " + String(pid) + " -ErrorAction SilentlyContinue).StartTime.ToUniversalTime().ToFileTime()).ToUnixTimeMilliseconds()";
+}
+/** Start time through Win32_Process: readable for System/svchost too. */
+function cimStartScript(pid) {
+	return "$p=Get-CimInstance Win32_Process -Filter \"ProcessId=" + String(pid) + "\" -ErrorAction SilentlyContinue;if($p -ne $null){[DateTimeOffset]::FromFileTime($p.CreationDate.ToUniversalTime().ToFileTime()).ToUnixTimeMilliseconds()}";
+}
+/**
+* Windows start time (Unix epoch ms) of a live process.
+*
+* `Get-Process` is the precise first choice, but an unprivileged caller cannot
+* read `.StartTime` for a protected process (System, svchost): the property is
+* empty, so the probe returns nothing. Without a fallback, a crash leftover
+* lock whose PID was reused by such a process could never be proven stale and
+* blocked every startup until the lock was deleted by hand (issue #1629).
+* Win32_Process through CIM reports the same CreationDate for those processes
+* at the same millisecond precision, so it is the second identity source. The
+* probe is injectable so the fallback chain is testable off Windows.
+*/
+function win32StartTimeMs(pid, probe = runPowerShellProbe) {
+	if (!Number.isSafeInteger(pid) || pid <= 0) return void 0;
+	const direct = parseProbeEpochMs(probe(getProcessStartScript(pid), PROCESS_PROBE_TIMEOUT_MS));
+	if (direct !== void 0) return direct;
+	return parseProbeEpochMs(probe(cimStartScript(pid), CIM_PROBE_TIMEOUT_MS));
+}
 /**
 * Best-effort start time (Unix epoch ms) of a live process. Used to prove
 * whether the ledger lock really belongs to the PID recorded in it, so a
@@ -1439,20 +1499,7 @@ function linuxStartTimeMs(pid) {
 */
 function processStartTimeMs(pid) {
 	if (process.platform === "linux") return linuxStartTimeMs(pid);
-	if (process.platform === "win32") {
-		const probe = spawnSync("powershell", [
-			"-NoProfile",
-			"-NonInteractive",
-			"-Command",
-			"[DateTimeOffset]::FromFileTime((Get-Process -Id " + String(pid) + " -ErrorAction SilentlyContinue).StartTime.ToUniversalTime().ToFileTime()).ToUnixTimeMilliseconds()"
-		], {
-			timeout: PROCESS_PROBE_TIMEOUT_MS,
-			windowsHide: true
-		});
-		if (probe.status !== 0 || probe.stdout.length === 0) return void 0;
-		const started = Number(probe.stdout.toString("utf8").trim());
-		return Number.isFinite(started) ? started : void 0;
-	}
+	if (process.platform === "win32") return win32StartTimeMs(pid);
 	const env = {
 		...process.env,
 		LC_ALL: "C"

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

@@ -7,7 +7,7 @@
 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, children, }: {
+export declare function ModalShell({ ariaLabel, title, error, pending, submitLabel, onSubmit, onClose, secondaryAction, children, }: {
     ariaLabel: string;
     title: string;
     error: string | undefined;
@@ -15,6 +15,11 @@ export declare function ModalShell({ ariaLabel, title, error, pending, submitLab
     submitLabel: string;
     onSubmit: () => void;
     onClose: () => void;
+    /** Optional second action beside the primary submit (e.g. create and run). */
+    secondaryAction?: {
+        label: string;
+        onSubmit: () => void;
+    };
     children: ReactNode;
 }): import("react").JSX.Element;
 /** Title + description + prompt fields shared by the new and edit task forms. */

package/lib/types/client/board/parse-model-pref.d.ts

@@ -0,0 +1,4 @@
+/** The remembered parse model; '' means the Host default (or no preference). */
+export declare function readParseModelPreference(storage?: Pick<Storage, 'getItem'> | undefined): string;
+/** Remember the picked parse model; '' records the Host-default choice. */
+export declare function writeParseModelPreference(model: string, storage?: Pick<Storage, 'setItem'> | undefined): void;

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

@@ -61,6 +61,7 @@ export declare const zh: {
     'new.prompt': string;
     'new.promptPlaceholder': string;
     'new.submit': string;
+    'new.createAndRun': string;
     'new.cancel': string;
     'new.required': string;
     'new.freeze': string;

package/lib/types/client/plugin-card-seat.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Family plugin-card seat.
+ *
+ * A family plugin contributes its settings card to whichever plugin-card seat
+ * the running host actually renders:
+ *
+ * - `web-ui.plugin.item` — the list seat declared by the dsh-web-settings
+ *   group section (this family's own first-level "Web UI plugins" section);
+ * - `settings.plugin.item` — the official keyed seat of the harness's
+ *   `ui-settings-plugins` tab, keyed by the settings namespace the card edits.
+ *
+ * SEAT SELECTION IS NOT A DECLARATION PROBE. The official `ui-settings-plugins`
+ * row belongs to the harness bundle and its `configurable` tab always declares
+ * `settings.plugin.item` before any external plugin's `apply()` runs, so
+ * "is the official seat declared?" answers yes even in the deployment whose
+ * whole point is the family group. Choosing on that probe sends every family
+ * card to the official Plugins tab and leaves the group's own section
+ * permanently empty — the family of reports where the section renders its
+ * heading and zero cards.
+ *
+ * The signal that actually distinguishes the two deployments is whether
+ * dsh-web-settings is loaded: it is the package that owns the group section and
+ * it publishes the `webUiSettings` service during `apply()`, which every
+ * family plugin already reads for its settings scope. Group loaded -> the family
+ * seat; group absent -> the official seat.
+ *
+ * The decision is re-evaluated on every `slots/changed` because the group may
+ * apply after this plugin (the family aggregate orders it first, a profile that
+ * installs the group separately need not): the initial contribution goes to the
+ * official seat, then moves to the family seat the moment the group's section
+ * registers. The entry is disposed before the replacement is registered, so a
+ * card is never in two seats at once.
+ *
+ * The shared tree has no client-SDK dependency, so this module reads its
+ * context through the structural shape below; callers pass the plugin's own
+ * `ctx`.
+ */
+/** The family list seat key. */
+export declare const FAMILY_PLUGIN_CARD_SEAT = "web-ui.plugin.item";
+/** The official keyed plugin-card seat key. */
+export declare const OFFICIAL_PLUGIN_CARD_SEAT = "settings.plugin.item";
+/** The service dsh-web-settings publishes while it is loaded. */
+export declare const FAMILY_GROUP_SERVICE = "webUiSettings";
+/** The slot-registry member this helper uses (structurally satisfied by ctx.slots). */
+export interface PluginCardSlots {
+    /** Contribution of one card entry. */
+    register(options: never, component: never): unknown;
+}
+/** The slice of the client context a card contribution needs. */
+export interface PluginCardContext {
+    slots: PluginCardSlots;
+    /** Service lookup; absent on a context double that only models the slots. */
+    get?(name: string): unknown;
+    /** Event subscription seat; absent on an event-less test double. */
+    on?(event: string, listener: (...args: never[]) => void): unknown;
+}
+/** Owner share of a plugin card (both seats supply nothing). */
+export interface SettingsPluginItemOwnerProps {
+    /** Marker field: card owner props are intentionally empty. */
+    children?: never;
+}
+/** One family plugin's card contribution. */
+export interface PluginCardSeat {
+    /** Settings namespace the card edits (the official seat's dispatch key). */
+    namespace: string;
+    /** Family list-seat entry id. */
+    id: string;
+    /** Family list-seat sort order. */
+    order?: number;
+    /** Family list-seat display label; the official keyed seat carries none. */
+    label?: () => string;
+    /** Locale namespace the card renders with. */
+    locale: string;
+    /** Business-face factory of the registration. */
+    inject?: () => object;
+    /**
+     * The card component. Its props type is the seat's composed shape, which is
+     * chosen at runtime, so the helper takes it erased; the registrant keeps its
+     * own precise typing at the call site.
+     */
+    component: unknown;
+}
+/**
+ * Whether the family group (dsh-web-settings) is loaded in this page. The
+ * service is the group package's own contract, so the probe cannot be fooled
+ * by a harness release that starts declaring the official seat differently.
+ */
+export declare function familyGroupLoaded(ctx: PluginCardContext): boolean;
+/**
+ * Contribute one family plugin card to the seat this host renders, following
+ * the group if it loads later. The entry is disposed and re-registered on a
+ * seat change, never duplicated.
+ * @param ctx - client context (its slot registry decides the seat).
+ * @param seat - the card contribution.
+ */
+export declare function installPluginCard(ctx: PluginCardContext, seat: PluginCardSeat): void;

package/lib/types/client/sidebar-entry-core.d.ts

@@ -1,3 +1,29 @@
+/**
+ * One trailing action button seated at the entry row's right edge (e.g. a
+ * refresh command or a collapse chevron). Rows with actions switch from the
+ * classic single-button structure to a container with a main button plus the
+ * action buttons (nested interactive elements are invalid HTML); rows without
+ * actions keep the classic structure untouched.
+ */
+export interface SidebarEntryAction {
+    /** Stable id stamped as data-dsh-entry-action="<id>" (CSS hooks and tests). */
+    id: string;
+    /** Inline icon markup while the row is active (always, when inactiveIcon is unset). */
+    icon: string;
+    /**
+     * Optional icon while the row is inactive. Setting it makes the action a
+     * state mirror (a collapse chevron): the core swaps the icon and stamps
+     * aria-expanded on every active-state change. Requires the active bridge.
+     */
+    inactiveIcon?: string;
+    /** Localized accessible label (aria-label + title); receives the active state. */
+    label(active: boolean): string;
+    /**
+     * Click handler; receives the button so the caller can drive transient
+     * affordances (a refresh cooldown) without a re-render.
+     */
+    onClick(button: HTMLButtonElement): void;
+}
 /** Per-package configuration for one sidebar entry row. */
 export interface SidebarEntryOptions {
     /** Full attribute name identifying the injected row (idempotency key), e.g. 'data-dsh-ssh-entry'. */
@@ -31,6 +57,12 @@ export interface SidebarEntryOptions {
     };
     /** Click action (open/toggle the owning panel). */
     onToggle(): void;
+    /**
+     * Optional trailing action buttons at the row's right edge. Requires the
+     * package CSS to seat entryMain / entryAction; empty keeps the classic
+     * single-button row.
+     */
+    actions?: readonly SidebarEntryAction[];
     /** Family-block position: 'before' inserts ahead of sibling plugin rows, 'after' behind them. */
     position: 'before' | 'after';
     /**

package/lib/types/core/session-reuse.d.ts

@@ -8,8 +8,10 @@ import type { TaskRecord } from './tasks.ts';
  * Pick the session a new execution of this task may continue in, or undefined
  * to mint a fresh conversation. Reuse requires ALL of:
  * - the task opted in (`reuseSession === true`);
- * - the task's newest execution carries a session id and has settled (an open
- *   execution would have made the ledger refuse the run in the first place);
+ * - the task's newest SETTLED execution carries a session id (issue #1587: the
+ *   launch path calls this after `startExecution` appended this run's own open
+ *   record, so reading the array tail always found an unsettled row and reuse
+ *   never happened);
  * - the roster is known and that session is present and idle.
  *
  * An unknown roster (session/list unavailable) never reuses: minting a fresh

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

@@ -37,6 +37,21 @@ export interface LedgerRuntimeView {
  */
 export declare function processState(pid: number): string | undefined;
 export declare function processIsAlive(pid: number): boolean;
+/** Runs one PowerShell script and returns its trimmed stdout. */
+export type PowerShellProbe = (script: string, timeoutMs: number) => string | undefined;
+/**
+ * Windows start time (Unix epoch ms) of a live process.
+ *
+ * `Get-Process` is the precise first choice, but an unprivileged caller cannot
+ * read `.StartTime` for a protected process (System, svchost): the property is
+ * empty, so the probe returns nothing. Without a fallback, a crash leftover
+ * lock whose PID was reused by such a process could never be proven stale and
+ * blocked every startup until the lock was deleted by hand (issue #1629).
+ * Win32_Process through CIM reports the same CreationDate for those processes
+ * at the same millisecond precision, so it is the second identity source. The
+ * probe is injectable so the fallback chain is testable off Windows.
+ */
+export declare function win32StartTimeMs(pid: number, probe?: PowerShellProbe): number | undefined;
 export declare class HostTaskLedger {
     private readonly now;
     private document;

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.3.23",
+  "version": "0.3.24",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",
@@ -68,6 +68,7 @@
     "@types/node": "^22.20.0",
     "@types/react": "~18.3.1",
     "@types/react-dom": "^18.3.5",
+    "@vitest/coverage-v8": "^3.2.7",
     "jsdom": "^25.0.0",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",

package/src/client/board/NewTaskModal.tsx

@@ -10,6 +10,7 @@ import { collectKnownTags, TASK_PERMISSIONS, type TaskPermission, type TaskRecor
 import { t, type TaskBoardKey } from '../locales.ts'
 import { SCHEDULE_PRESETS } from '../schedule-presets.ts'
 import { ModalShell, TaskContentFields, TaskTagFields, cleanTags } from './TaskForm.tsx'
+import { readParseModelPreference, writeParseModelPreference } from './parse-model-pref.ts'
 import css from '../board.module.css'
 
 export interface NewTaskModalProps {
@@ -54,7 +55,9 @@ export function NewTaskModal({ controller, onClose, initialTask, defaultWorkspac
   // parse face; the section stays hidden otherwise.
   const [canParse] = useState(controller.getSnapshot().canParseTask === true)
   const [parseText, setParseText] = useState('')
-  const [parseModel, setParseModel] = useState('')
+  // Issue #1621: start from the model this browser used last, not from the
+  // roster's first entry; '' is the Host default and stays valid.
+  const [parseModel, setParseModel] = useState(() => readParseModelPreference())
   const [parsePending, setParsePending] = useState(false)
   const [parseError, setParseError] = useState<string | undefined>(undefined)
   const parseAbort = useRef<AbortController | undefined>(undefined)
@@ -67,10 +70,14 @@ export function NewTaskModal({ controller, onClose, initialTask, defaultWorkspac
     [controller],
   )
 
-  // The model roster arrives asynchronously: default to its first entry, which
-  // the user can change before parsing.
+  // The model roster arrives asynchronously. A remembered model the deployment
+  // no longer offers falls back to the Host default; an empty value is the
+  // Host-default choice and is never overwritten by the roster (issue #1621).
   useEffect(() => {
-    if (parseModel === '' && parseModels.length > 0) setParseModel(parseModels[0]!.id)
+    if (parseModel === '' || parseModels.length === 0) return
+    if (parseModels.some(option => option.id === parseModel)) return
+    setParseModel('')
+    writeParseModelPreference('')
   }, [parseModel, options.models])
 
   const runParse = async (): Promise<void> => {
@@ -97,7 +104,13 @@ export function NewTaskModal({ controller, onClose, initialTask, defaultWorkspac
     }
   }
 
-  const submit = async (): Promise<void> => {
+  /**
+   * Create the task through the Host, then optionally start it.
+   * @param runAfterCreate - true for the "create and run" action: the task is
+   * committed either way, and a refused start opens the task instead of
+   * reporting the creation as failed.
+   */
+  const submit = async (runAfterCreate: boolean): Promise<void> => {
     if (scheduleEnabled) {
       const cron = scheduleCron.trim()
       if (cron === '' || !isValidCron(cron)) {
@@ -156,6 +169,14 @@ export function NewTaskModal({ controller, onClose, initialTask, defaultWorkspac
         await controller.archiveTask(initialTask.id)
       }
     }
+    if (runAfterCreate) {
+      // The task exists from here on, so a refused start (a permission above
+      // the session default, a pinned target that went stale) must not read as
+      // a failed creation: open the task, whose detail view owns the
+      // confirmation step and the refusal message.
+      const started = await controller.runTask(task.id)
+      if (!started) controller.openTask(task.id)
+    }
     onClose()
   }
 
@@ -173,8 +194,9 @@ export function NewTaskModal({ controller, onClose, initialTask, defaultWorkspac
       error={error}
       pending={pending}
       submitLabel={t('new.submit')}
-      onSubmit={() => { void submit() }}
+      onSubmit={() => { void submit(false) }}
       onClose={onClose}
+      secondaryAction={{ label: t('new.createAndRun'), onSubmit: () => { void submit(true) } }}
     >
       {canParse && (
         <section className={css.aiParse} data-dsh-part="ai-parse">
@@ -193,8 +215,12 @@ export function NewTaskModal({ controller, onClose, initialTask, defaultWorkspac
               className={css.select}
               value={parseModel}
               aria-label={t('new.aiParseModel')}
-              onChange={event => { setParseModel(event.target.value) }}
+              onChange={event => {
+                setParseModel(event.target.value)
+                writeParseModelPreference(event.target.value)
+              }}
             >
+              <option value="">{t('exec.model.default')}</option>
               {parseModels.map(option => (
                 <option key={option.id} value={option.id}>{option.name ?? option.id}</option>
               ))}

package/src/client/board/TaskForm.tsx

@@ -21,6 +21,7 @@ export function ModalShell({
   submitLabel,
   onSubmit,
   onClose,
+  secondaryAction,
   children,
 }: {
   ariaLabel: string
@@ -30,6 +31,8 @@ export function ModalShell({
   submitLabel: string
   onSubmit: () => void
   onClose: () => void
+  /** Optional second action beside the primary submit (e.g. create and run). */
+  secondaryAction?: { label: string; onSubmit: () => void }
   children: ReactNode
 }) {
   return (
@@ -50,6 +53,16 @@ export function ModalShell({
           <button type="button" className={css.ghostButton} onClick={onClose}>
             {t('new.cancel')}
           </button>
+          {secondaryAction !== undefined && (
+            <button
+              type="button"
+              className={css.ghostButton}
+              disabled={pending}
+              onClick={secondaryAction.onSubmit}
+            >
+              {secondaryAction.label}
+            </button>
+          )}
           <button type="submit" className={css.primaryButton} disabled={pending}>
             {submitLabel}
           </button>

package/src/client/board/parse-model-pref.ts

@@ -0,0 +1,35 @@
+/**
+ * The model the user last picked for AI parsing, remembered per browser so the
+ * next new-task modal starts from it instead of the roster's first entry
+ * (issue #1621). An empty value is a real choice — "let the Host use its
+ * default model" — and is remembered as such.
+ */
+const PARSE_MODEL_KEY = 'dsh-task-board.parse-model'
+
+/** The nearest browser storage, or undefined when the global itself throws. */
+function defaultStorage(): Storage | undefined {
+  try {
+    return globalThis.localStorage
+  } catch {
+    return undefined
+  }
+}
+
+/** The remembered parse model; '' means the Host default (or no preference). */
+export function readParseModelPreference(storage: Pick<Storage, 'getItem'> | undefined = defaultStorage()): string {
+  try {
+    return storage?.getItem(PARSE_MODEL_KEY) ?? ''
+  } catch {
+    // A blocked or full store must never break the form.
+    return ''
+  }
+}
+
+/** Remember the picked parse model; '' records the Host-default choice. */
+export function writeParseModelPreference(model: string, storage: Pick<Storage, 'setItem'> | undefined = defaultStorage()): void {
+  try {
+    storage?.setItem(PARSE_MODEL_KEY, model)
+  } catch {
+    // Storage is optional: the picker still works without it.
+  }
+}

package/src/client/index.ts

@@ -30,6 +30,7 @@ import { TaskBoardSettingsCard, TaskBoardSettingsCardController, type TaskBoardS
 import { en, zh, setRuntimeTranslate, type TaskBoardKey } from './locales.ts'
 import { HttpTaskBoardHostTransport } from './host-api.ts'
 import { reportDailyHeartbeat } from './telemetry.ts'
+import { installPluginCard } from './plugin-card-seat.ts'
 
 /** Locale namespace this plugin owns. */
 const NS = 'task-board'
@@ -164,27 +165,20 @@ export function apply(ctx: ClientContext): void {
   try { setRuntimeTranslate(ctx.locale.bind(NS)) } catch { /* locale missing: document-language fallback stays */ }
 
   // Plugin configuration card: one staged form over the `task-board` settings
-  // namespace, contributed to the Web UI plugin group.
+  // namespace, contributed to whichever plugin-card seat this host declares
+  // (issue #1589).
   const binder = ctx.get('webUiSettings') ?? ctx.settingsScope
   const settingsScope = binder.bind<TaskBoardSettings>({ namespace: TASK_BOARD_NS })
   const settingsCard = new TaskBoardSettingsCardController(settingsScope)
-  ctx.slots.inject('web-ui.plugin.item', () => {
-    try {
-      const unregister = ctx.slots.register({
-        name: 'web-ui.plugin.item',
-        id: 'task-board',
-        order: 110,
-        locale: NS,
-        inject: () => settingsCard.inject(),
-      }, TaskBoardSettingsCard)
-      return () => {
-        settingsCard.dispose()
-        unregister()
-      }
-    } catch {
-      return () => {}
-    }
+  installPluginCard(ctx, {
+    namespace: TASK_BOARD_NS,
+    id: 'task-board',
+    order: 110,
+    locale: NS,
+    inject: () => settingsCard.inject(),
+    component: TaskBoardSettingsCard,
   })
+  ctx.effect(() => () => { settingsCard.dispose() }, 'task-board: settings card')
 
   // The sidebar entry and board view mount once the settings scope settles;
   // while the scope is still loading, the composition default is unknown, so

package/src/client/locales.ts

@@ -62,6 +62,7 @@ export const zh = {
   'new.prompt': '执行 Prompt',
   'new.promptPlaceholder': '发给 agent 的完整指令（留空则使用标题）',
   'new.submit': '创建',
+  'new.createAndRun': '创建并执行',
   'new.cancel': '取消',
   'new.required': '标题不能为空',
   'new.freeze': '冻结快照（可选）',
@@ -252,6 +253,7 @@ export const en: Record<keyof typeof zh, string> = {
   'new.prompt': 'Run Prompt',
   'new.promptPlaceholder': 'The full instruction sent to the agent (title is used when blank)',
   'new.submit': 'Create',
+  'new.createAndRun': 'Create and run',
   'new.cancel': 'Cancel',
   'new.required': 'Title is required',
   'new.freeze': 'Frozen snapshot (optional)',