@linxin666/dsh-client-ui-task-board 0.3.17 → 0.3.19

package/lib/index.js

@@ -1,7 +1,7 @@
 import z from "schemastery";
 import { spawn, spawnSync } from "node:child_process";
 import { createHash, timingSafeEqual } from "node:crypto";
-import { chmodSync, closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { chmodSync, closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, join, win32 } from "node:path";
 import { homedir } from "node:os";
 import { isAbsolute as isAbsolute$1, join as join$1 } from "node:path/posix";
@@ -174,6 +174,29 @@ function isDigits(value) {
 	return /^\d+$/.test(value);
 }
 //#endregion
+//#region src/core/session-reuse.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 roster is known and that session is present and idle.
+*
+* An unknown roster (session/list unavailable) never reuses: minting a fresh
+* conversation is always safe, prompting into a session we cannot see is not.
+* @param task - the task about to run.
+* @param idleSessionIds - ids the last roster saw as present and not running;
+*   undefined when that roster is unknown.
+* @returns the session id to continue in, or undefined for a fresh session.
+*/
+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;
+	return idleSessionIds.has(last.sessionId) ? last.sessionId : void 0;
+}
+//#endregion
 //#region src/dsh-home.ts
 /**
 * DSH_HOME resolution shared by the plugin family's Host halves: the
@@ -285,6 +308,7 @@ function createTask(input, now, id) {
 		mode: normalizeTargetId(input.mode),
 		permission: isTaskPermission(input.permission) ? input.permission : void 0,
 		model: normalizeTargetId(input.model),
+		reuseSession: input.reuseSession === true ? true : void 0,
 		...input.freeze === void 0 ? {} : { freeze: freezeOf(input.freeze, now) },
 		...input.handover === void 0 ? {} : { handover: {
 			...input.handover,
@@ -582,6 +606,7 @@ function isTaskRecordShape(value) {
 	if (record.workspaceId !== void 0 && typeof record.workspaceId !== "string") return false;
 	if (record.mode !== void 0 && typeof record.mode !== "string") return false;
 	if (record.permission !== void 0 && typeof record.permission !== "string") return false;
+	if (record.reuseSession !== void 0 && typeof record.reuseSession !== "boolean") return false;
 	if (!Array.isArray(record.executions)) return false;
 	for (const execution of record.executions) {
 		if (typeof execution !== "object" || execution === null) return false;
@@ -695,6 +720,7 @@ function parseLedger(raw) {
 		task.mode = normalizeTargetId(row.mode);
 		task.archivedAt = typeof row.archivedAt === "number" && Number.isFinite(row.archivedAt) ? row.archivedAt : void 0;
 		task.permission = isTaskPermission(row.permission) ? row.permission : void 0;
+		task.reuseSession = row.reuseSession === true ? true : void 0;
 		task.freeze = normalizeFreeze(row.freeze);
 		task.handover = normalizeHandover(row.handover);
 		task.permissionConfirmedAt = typeof row.permissionConfirmedAt === "number" && Number.isFinite(row.permissionConfirmedAt) ? row.permissionConfirmedAt : void 0;
@@ -929,6 +955,7 @@ function applyUpdateTask(tasks, id, patch, now) {
 			bundledAt: now
 		};
 		if ("permission" in patch && patch.permission !== void 0 && patch.permission !== task.permission || "handover" in patch) next.permissionConfirmedAt = void 0;
+		if ("reuseSession" in patch) next.reuseSession = patch.reuseSession === true ? true : void 0;
 		if (workspaceId !== void 0 || "workspaceId" in patch) next.workspaceId = workspaceId;
 		if (mode !== void 0 || "mode" in patch) next.mode = mode;
 		if (permission !== void 0 || "permission" in patch) next.permission = permission;
@@ -1022,6 +1049,7 @@ function importedTask(value) {
 		...task.workspaceId === void 0 ? {} : { workspaceId: task.workspaceId },
 		...task.mode === void 0 ? {} : { mode: task.mode },
 		...task.permission === void 0 ? {} : { permission: task.permission },
+		...task.reuseSession === void 0 ? {} : { reuseSession: task.reuseSession },
 		...task.archivedAt === void 0 ? {} : { archivedAt: task.archivedAt },
 		...task.freeze === void 0 ? {} : { freeze: task.freeze },
 		...task.handover === void 0 ? {} : { handover: task.handover }
@@ -1063,10 +1091,12 @@ function createInput(value) {
 		"schedule",
 		"freeze",
 		"handover",
-		"model"
+		"model",
+		"reuseSession"
 	])) return false;
 	if (typeof input.title !== "string" || typeof input.description !== "string" || typeof input.prompt !== "string") return false;
 	if (!optionalString(input.workspaceId) || !optionalString(input.mode) || !optionalString(input.model)) return false;
+	if (input.reuseSession !== void 0 && typeof input.reuseSession !== "boolean") return false;
 	if (input.permission !== void 0 && !isTaskPermission(input.permission)) return false;
 	if (input.freeze !== void 0 && freezePayload(input.freeze) === void 0) return false;
 	if (input.handover !== void 0 && handoverPayload(input.handover) === void 0) return false;
@@ -1088,8 +1118,10 @@ function updatePatch(value) {
 		"permission",
 		"freeze",
 		"handover",
-		"model"
+		"model",
+		"reuseSession"
 	])) return false;
+	if (patch.reuseSession !== void 0 && patch.reuseSession !== null && typeof patch.reuseSession !== "boolean") return false;
 	for (const key of [
 		"title",
 		"description",
@@ -1455,6 +1487,7 @@ var HostTaskLedger = class {
 		this.file = join(dir, "ledger-v2.json");
 		this.lockFile = join(dir, "ledger-v2.lock");
 		this.schedulerFile = join(dir, "scheduler-v2.json");
+		this.cleanStaleTemporaryFiles(dir);
 		this.lockFd = this.acquireLock();
 		try {
 			this.document = this.load(dir);
@@ -1467,6 +1500,15 @@ var HostTaskLedger = class {
 			throw error;
 		}
 	}
+	/** Remove leftover *.tmp-* files from previous crashes or interrupted writes. */
+	cleanStaleTemporaryFiles(dir) {
+		try {
+			const entries = readdirSync(dir);
+			for (const entry of entries) if (entry.includes(".tmp-")) try {
+				unlinkSync(join(dir, entry));
+			} catch {}
+		} catch {}
+	}
 	/** Revision + scheduler without any task cloning; feeds the SSE event frame. */
 	summary() {
 		const { importedSources: _imports, ...scheduler } = this.document.scheduler;
@@ -1604,7 +1646,12 @@ var HostTaskLedger = class {
 			...patch
 		};
 		if (patch.lastTickAt !== void 0 && Object.keys(patch).every((key) => key === "lastTickAt")) {
-			this.writeSchedulerSidecar();
+			try {
+				this.writeSchedulerSidecar();
+			} catch (error) {
+				if (error?.code === "ENOSPC") return;
+				throw error;
+			}
 			return;
 		}
 		this.commit(false);
@@ -2128,7 +2175,17 @@ var HostExecutionRunner = class {
 			...signal === void 0 ? {} : { signal }
 		});
 	}
-	async launch(task) {
+	/**
+	* Launch one execution. Without `options.reuseSessionId` a fresh session is
+	* created, renamed, pinned, and prompted (the historical contract). With it,
+	* the run continues in that existing session (issue #1419): the conversation
+	* keeps its title and history, the pinned permission/model are re-asserted so
+	* the task's execution contract still holds, and the prompt is queued.
+	* @param task - the task to run.
+	* @param options - optional session to continue in.
+	* @returns the session id the execution runs in.
+	*/
+	async launch(task, options = {}) {
 		const workspaceId = task.handover?.workspaceId ?? task.workspaceId;
 		const mode = task.handover?.mode ?? task.mode;
 		const permission = task.handover?.permission ?? task.permission;
@@ -2140,6 +2197,15 @@ var HostExecutionRunner = class {
 			if (preset === void 0) throw new Error("agent preset not found: " + mode);
 			if (preset.broken !== void 0) throw new Error("agent preset is unavailable: " + preset.broken);
 		}
+		const reused = options.reuseSessionId;
+		if (reused !== void 0) {
+			try {
+				await this.pinAndPrompt(reused, task, permission);
+			} catch (error) {
+				throw new SessionLaunchError(reused, error);
+			}
+			return reused;
+		}
 		const sessionId = (await this.invoke("session", "create", {
 			...workspaceId === void 0 ? {} : { workspaceId },
 			...mode === void 0 ? {} : { agentPreset: mode }
@@ -2149,41 +2215,49 @@ var HostExecutionRunner = class {
 				sessionId,
 				title: task.title
 			});
-			if (permission !== void 0) {
-				if (this.commands === void 0) throw new Error("permission command dispatcher is unavailable");
-				const command = await this.commands.execute(sessionId, "/permission " + permission, AbortSignal.timeout(3e4));
-				if (command === void 0) throw new Error("permission command was not acknowledged");
-				if (command.kind !== "success") throw new Error(command.text ?? "permission command failed");
-			}
-			if (task.model !== void 0 && task.model.trim() !== "") {
-				const rawModel = task.model.trim();
-				const slashIdx = rawModel.indexOf("/");
-				const provider = slashIdx >= 0 ? rawModel.slice(0, slashIdx).trim() : void 0;
-				const modelId = slashIdx >= 0 ? rawModel.slice(slashIdx + 1).trim() : rawModel;
-				try {
-					await this.invoke("session", "selectModel", {
-						sessionId,
-						...provider ? { provider } : {},
-						model: modelId
-					});
-				} catch (modelError) {
-					console.warn(`[dsh-task-board] failed to select model "${task.model}" for session ${sessionId}, falling back to default:`, modelError);
-				}
-			}
-			await this.invoke("session", "prompt", {
-				sessionId,
-				requestId: "task-board-" + crypto.randomUUID(),
-				mode: "queue",
-				content: [{
-					type: "text",
-					text: promptText(task)
-				}]
-			});
+			await this.pinAndPrompt(sessionId, task, permission);
 		} catch (error) {
 			throw new SessionLaunchError(sessionId, error);
 		}
 		return sessionId;
 	}
+	/**
+	* Re-assert the pinned execution contract on a session and queue the task
+	* prompt. Shared by the fresh-session and reuse paths so both apply exactly
+	* the same permission/model pins before the prompt.
+	*/
+	async pinAndPrompt(sessionId, task, permission) {
+		if (permission !== void 0) {
+			if (this.commands === void 0) throw new Error("permission command dispatcher is unavailable");
+			const command = await this.commands.execute(sessionId, "/permission " + permission, AbortSignal.timeout(3e4));
+			if (command === void 0) throw new Error("permission command was not acknowledged");
+			if (command.kind !== "success") throw new Error(command.text ?? "permission command failed");
+		}
+		if (task.model !== void 0 && task.model.trim() !== "") {
+			const rawModel = task.model.trim();
+			const slashIdx = rawModel.indexOf("/");
+			const provider = slashIdx >= 0 ? rawModel.slice(0, slashIdx).trim() : void 0;
+			const modelId = slashIdx >= 0 ? rawModel.slice(slashIdx + 1).trim() : rawModel;
+			try {
+				await this.invoke("session", "selectModel", {
+					sessionId,
+					...provider ? { provider } : {},
+					model: modelId
+				});
+			} catch (modelError) {
+				console.warn(`[dsh-task-board] failed to select model "${task.model}" for session ${sessionId}, falling back to default:`, modelError);
+			}
+		}
+		await this.invoke("session", "prompt", {
+			sessionId,
+			requestId: "task-board-" + crypto.randomUUID(),
+			mode: "queue",
+			content: [{
+				type: "text",
+				text: promptText(task)
+			}]
+		});
+	}
 	async listRunning() {
 		for (let attempt = 1;; attempt++) try {
 			const response = await this.invoke("session", "list", {});
@@ -2617,6 +2691,13 @@ var TaskBoardHostService = class {
 	pollInFlight = false;
 	tickInFlight = false;
 	active = true;
+	/**
+	* Ids the last roster poll saw as present and idle; undefined while the
+	* roster is unknown. Session reuse (issue #1419) requires this positive
+	* evidence, so a launch before the first successful poll mints a fresh
+	* conversation instead of prompting into a session it cannot see.
+	*/
+	idleSessionIds;
 	preventIdleSleep = false;
 	lastPowerJson = "";
 	now;
@@ -2625,6 +2706,7 @@ var TaskBoardHostService = class {
 		this.runner = new HostExecutionRunner(gateway, options.commandDispatcher, options.workspaceRegistry);
 		this.power = options.power ?? new PowerInhibitor();
 		this.now = options.now ?? Date.now;
+		installStreamErrorGuards();
 		this.ledger.subscribe(() => {
 			this.syncPowerReasons();
 			this.emit();
@@ -2714,7 +2796,8 @@ var TaskBoardHostService = class {
 	}
 	async launch(opened) {
 		try {
-			const sessionId = await this.runner.launch(opened.task);
+			const reuseSessionId = reusableSessionId(opened.task, this.idleSessionIds);
+			const sessionId = await this.runner.launch(opened.task, reuseSessionId === void 0 ? {} : { reuseSessionId });
 			this.ledger.attachSession(opened.task.id, opened.execution.id, sessionId);
 		} catch (error) {
 			if (error instanceof SessionLaunchError) this.ledger.attachSession(opened.task.id, opened.execution.id, error.sessionId);
@@ -2727,6 +2810,7 @@ var TaskBoardHostService = class {
 		const running = await this.runner.listRunning();
 		const previous = this.power.snapshot();
 		if (!running.known) {
+			this.idleSessionIds = void 0;
 			this.power.updateReasons({
 				runningSessions: previous.runningSessions,
 				armedSchedules: this.ledger.armedScheduleCount(),
@@ -2734,6 +2818,7 @@ var TaskBoardHostService = class {
 			});
 			return;
 		}
+		this.idleSessionIds = new Set(running.items.filter((item) => !item.running).map((item) => item.sessionId));
 		const runtime = this.ledger.runtimeView();
 		this.power.updateReasons({
 			runningSessions: running.count,
@@ -2774,14 +2859,14 @@ var TaskBoardHostService = class {
 	}
 	scheduleLaunch(opened) {
 		this.launch(opened).catch((error) => {
-			console.error("[dsh-task-board] execution launch settlement failed", error);
+			safeConsoleError("[dsh-task-board] execution launch settlement failed", error);
 		});
 	}
 	schedulePoll() {
 		if (this.pollInFlight || this.disposed) return;
 		this.pollInFlight = true;
 		this.pollSessions().catch((error) => {
-			console.error("[dsh-task-board] session polling failed", error);
+			safeConsoleError("[dsh-task-board] session polling failed", error);
 		}).finally(() => {
 			this.pollInFlight = false;
 		});
@@ -2790,7 +2875,7 @@ var TaskBoardHostService = class {
 		if (this.tickInFlight || this.disposed) return;
 		this.tickInFlight = true;
 		this.tickSchedule(first).catch((error) => {
-			console.error("[dsh-task-board] scheduler tick failed", error);
+			safeConsoleError("[dsh-task-board] scheduler tick failed", error);
 		}).finally(() => {
 			this.tickInFlight = false;
 		});
@@ -2808,6 +2893,25 @@ var TaskBoardHostService = class {
 		for (const listener of [...this.listeners]) listener();
 	}
 };
+/**
+* Install stream error listeners on process.stderr and process.stdout so that
+* transient write failures (e.g. ENOSPC when the disk is full, or EPIPE on a
+* closed pipe) never emit unhandled 'error' events that kill the Node.js host process.
+*/
+function installStreamErrorGuards() {
+	for (const stream of [process.stderr, process.stdout]) if (stream && typeof stream.on === "function") {
+		if (!(typeof stream.listenerCount === "function" && stream.listenerCount("error") > 0)) stream.on("error", () => {});
+	}
+}
+/**
+* Defensively log to console.error without letting stderr write failures
+* (e.g. ENOSPC from SyncWriteStream on redirected logs) crash the host process.
+*/
+function safeConsoleError(message, ...args) {
+	try {
+		console.error(message, ...args);
+	} catch {}
+}
 //#endregion
 //#region src/http.ts
 /** Family-default JSON response headers; callers may append or override. */

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

@@ -1,6 +1,12 @@
 import type { BoardController } from '../../core/controller.ts';
-/** New-task form overlay. */
-export declare function NewTaskModal({ controller, onClose }: {
+import { type TaskRecord } from '../../core/tasks.ts';
+export interface NewTaskModalProps {
     controller: BoardController;
     onClose: () => void;
-}): import("react").JSX.Element;
+    /** Optional task template to clone/duplicate from. */
+    initialTask?: TaskRecord;
+    /** Optional callback after successful duplication (e.g. to archive source). */
+    onDuplicateSuccess?: (sourceTaskId: string) => Promise<void>;
+}
+/** New-task form overlay. */
+export declare function NewTaskModal({ controller, onClose, initialTask, onDuplicateSuccess }: NewTaskModalProps): import("react").JSX.Element;

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

@@ -59,9 +59,13 @@ export declare const zh: {
     'detail.permissionConfirmed': string;
     'detail.title': string;
     'detail.edit': string;
+    'detail.duplicate': string;
+    'detail.duplicateAndEdit': string;
     'detail.close': string;
     'edit.title': string;
     'edit.save': string;
+    'new.duplicateTitle': string;
+    'new.archiveOriginal': string;
     'detail.prompt': string;
     'detail.description': string;
     'detail.execution': string;
@@ -120,6 +124,8 @@ export declare const zh: {
     'exec.permission.danger-full-access': string;
     'exec.model.default': string;
     'exec.model.unknown': string;
+    'exec.reuseSession': string;
+    'exec.reuseSessionHint': string;
     'detail.executionSettings': string;
     'exec.hint': string;
     'settings.title': string;

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

@@ -0,0 +1,22 @@
+/**
+ * Session-reuse rule (issue #1419): decides which task runs continue in the
+ * previous execution's conversation. Pure, so the fail-closed conditions stay
+ * unit-testable without a gateway.
+ */
+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 roster is known and that session is present and idle.
+ *
+ * An unknown roster (session/list unavailable) never reuses: minting a fresh
+ * conversation is always safe, prompting into a session we cannot see is not.
+ * @param task - the task about to run.
+ * @param idleSessionIds - ids the last roster saw as present and not running;
+ *   undefined when that roster is unknown.
+ * @returns the session id to continue in, or undefined for a fresh session.
+ */
+export declare function reusableSessionId(task: TaskRecord, idleSessionIds: ReadonlySet<string> | undefined): string | undefined;

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

@@ -124,6 +124,14 @@ export interface TaskRecord {
      * absent falls back to the host default (agent-default-model).
      */
     model?: string;
+    /**
+     * Whether later executions continue in the previous execution's session
+     * (issue #1419) instead of minting a fresh conversation per run. Absent or
+     * false keeps the historical one-session-per-execution behavior; the reuse
+     * itself only happens when that session is idle and still present (see
+     * {@link reusableSessionId}).
+     */
+    reuseSession?: boolean;
     /**
      * Frozen context snapshot for a continuation card; absent on plain tasks.
      * Sanitized before it enters the ledger (redaction, slash-command taint,
@@ -171,6 +179,8 @@ export interface NewTaskInput {
     permission?: TaskPermission;
     /** Optional pinned model for the execution session; absent = host default. */
     model?: string;
+    /** Reuse the previous execution's session for later runs (issue #1419). */
+    reuseSession?: 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

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'>> & {
+export type TaskUpdatePatch = Partial<Pick<TaskRecord, 'title' | 'description' | 'prompt' | 'workspaceId' | 'mode' | 'permission' | 'model' | 'reuseSession'>> & {
     freeze?: FreezeSnapshot & {
         redacted?: boolean;
     } | null;

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

@@ -53,6 +53,8 @@ export declare class HostTaskLedger {
     constructor(dir?: string, now?: () => number, options?: {
         sessionDefaultPermission?: TaskPermission;
     });
+    /** Remove leftover *.tmp-* files from previous crashes or interrupted writes. */
+    private cleanStaleTemporaryFiles;
     /** Revision + scheduler without any task cloning; feeds the SSE event frame. */
     summary(): {
         revision: number;

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

@@ -65,7 +65,25 @@ export declare class HostExecutionRunner {
     });
     private invoke;
     private stream;
-    launch(task: TaskRecord): Promise<string>;
+    /**
+     * Launch one execution. Without `options.reuseSessionId` a fresh session is
+     * created, renamed, pinned, and prompted (the historical contract). With it,
+     * the run continues in that existing session (issue #1419): the conversation
+     * keeps its title and history, the pinned permission/model are re-asserted so
+     * the task's execution contract still holds, and the prompt is queued.
+     * @param task - the task to run.
+     * @param options - optional session to continue in.
+     * @returns the session id the execution runs in.
+     */
+    launch(task: TaskRecord, options?: {
+        reuseSessionId?: string;
+    }): Promise<string>;
+    /**
+     * Re-assert the pinned execution contract on a session and queue the task
+     * prompt. Shared by the fresh-session and reuse paths so both apply exactly
+     * the same permission/model pins before the prompt.
+     */
+    private pinAndPrompt;
     listRunning(): Promise<{
         known: true;
         count: number;

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

@@ -15,6 +15,13 @@ export declare class TaskBoardHostService {
     private pollInFlight;
     private tickInFlight;
     private active;
+    /**
+     * Ids the last roster poll saw as present and idle; undefined while the
+     * roster is unknown. Session reuse (issue #1419) requires this positive
+     * evidence, so a launch before the first successful poll mints a fresh
+     * conversation instead of prompting into a session it cannot see.
+     */
+    private idleSessionIds;
     private preventIdleSleep;
     private lastPowerJson;
     private readonly now;
@@ -46,3 +53,14 @@ export declare class TaskBoardHostService {
     private syncPowerReasons;
     private emit;
 }
+/**
+ * Install stream error listeners on process.stderr and process.stdout so that
+ * transient write failures (e.g. ENOSPC when the disk is full, or EPIPE on a
+ * closed pipe) never emit unhandled 'error' events that kill the Node.js host process.
+ */
+export declare function installStreamErrorGuards(): void;
+/**
+ * Defensively log to console.error without letting stderr write failures
+ * (e.g. ENOSPC from SyncWriteStream on redirected logs) crash the host process.
+ */
+export declare function safeConsoleError(message: string, ...args: unknown[]): void;

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.17",
+  "version": "0.3.19",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",

package/src/client/board/NewTaskModal.tsx

@@ -6,27 +6,41 @@ import { useEffect, useState } from 'react'
 import type { BoardController } from '../../core/controller.ts'
 import { isValidCron, nextRunAtMs } from '../../core/schedule.ts'
 import { parseFreezeRequest } from '../../core/freeze-snapshot.ts'
-import { TASK_PERMISSIONS, type TaskPermission } from '../../core/tasks.ts'
+import { TASK_PERMISSIONS, type TaskPermission, type TaskRecord } from '../../core/tasks.ts'
 import { t, type TaskBoardKey } from '../locales.ts'
 import { SCHEDULE_PRESETS } from '../schedule-presets.ts'
 import { ModalShell, TaskContentFields } from './TaskForm.tsx'
 import css from '../board.module.css'
 
+export interface NewTaskModalProps {
+  controller: BoardController
+  onClose: () => void
+  /** Optional task template to clone/duplicate from. */
+  initialTask?: TaskRecord
+  /** Optional callback after successful duplication (e.g. to archive source). */
+  onDuplicateSuccess?: (sourceTaskId: string) => Promise<void>
+}
+
 /** New-task form overlay. */
-export function NewTaskModal({ controller, onClose }: { controller: BoardController; onClose: () => void }) {
-  const [title, setTitle] = useState('')
-  const [description, setDescription] = useState('')
-  const [prompt, setPrompt] = useState('')
-  const [workspaceId, setWorkspaceId] = useState('')
-  const [mode, setMode] = useState('')
-  const [permission, setPermission] = useState('')
-  const [model, setModel] = useState('')
-  const [scheduleEnabled, setScheduleEnabled] = useState(false)
-  const [scheduleCron, setScheduleCron] = useState('')
+export function NewTaskModal({ controller, onClose, initialTask, onDuplicateSuccess }: NewTaskModalProps) {
+  const isDuplicate = initialTask !== undefined
+  const [title, setTitle] = useState(initialTask?.title ?? '')
+  const [description, setDescription] = useState(initialTask?.description ?? '')
+  const [prompt, setPrompt] = useState(initialTask?.prompt ?? '')
+  const [workspaceId, setWorkspaceId] = useState(initialTask?.workspaceId ?? '')
+  const [mode, setMode] = useState(initialTask?.mode ?? '')
+  const [permission, setPermission] = useState(initialTask?.permission ?? '')
+  const [model, setModel] = useState(initialTask?.model ?? '')
+  const [reuseSession, setReuseSession] = useState(initialTask?.reuseSession ?? false)
+  const [scheduleEnabled, setScheduleEnabled] = useState(initialTask?.schedule?.enabled ?? false)
+  const [scheduleCron, setScheduleCron] = useState(initialTask?.schedule?.cron ?? '')
   const [scheduleError, setScheduleError] = useState<string | undefined>(undefined)
   const [freezeText, setFreezeText] = useState('')
   const [freezeError, setFreezeError] = useState<string | undefined>(undefined)
-  const [handoverText, setHandoverText] = useState('')
+  const [handoverText, setHandoverText] = useState(
+    initialTask?.handover?.references !== undefined ? initialTask.handover.references.join('\n') : '',
+  )
+  const [archiveOriginal, setArchiveOriginal] = useState(true)
   const [error, setError] = useState<string | undefined>(undefined)
   const [pending, setPending] = useState(false)
   const [options, setOptions] = useState(controller.getSnapshot().executionOptions)
@@ -78,6 +92,7 @@ export function NewTaskModal({ controller, onClose }: { controller: BoardControl
       mode: mode === '' ? undefined : mode,
       permission: permission === '' ? undefined : permission as TaskPermission,
       model: model === '' ? undefined : model,
+      ...(reuseSession ? { reuseSession: true } : {}),
       schedule: scheduleEnabled ? { enabled: true, cron: scheduleCron.trim() } : undefined,
     })
     if (task === undefined) {
@@ -85,6 +100,13 @@ export function NewTaskModal({ controller, onClose }: { controller: BoardControl
       setError(controller.getSnapshot().transportError ?? t('new.required'))
       return
     }
+    if (isDuplicate && archiveOriginal && initialTask !== undefined) {
+      if (onDuplicateSuccess !== undefined) {
+        await onDuplicateSuccess(initialTask.id)
+      } else {
+        await controller.archiveTask(initialTask.id)
+      }
+    }
     onClose()
   }
 
@@ -93,10 +115,12 @@ export function NewTaskModal({ controller, onClose }: { controller: BoardControl
     ? nextRunAtMs(scheduleCron, Date.now())
     : undefined
 
+  const modalTitle = isDuplicate ? t('new.duplicateTitle') : t('board.new')
+
   return (
     <ModalShell
-      ariaLabel={t('board.new')}
-      title={t('board.new')}
+      ariaLabel={modalTitle}
+      title={modalTitle}
       error={error}
       pending={pending}
       submitLabel={t('new.submit')}
@@ -197,6 +221,16 @@ export function NewTaskModal({ controller, onClose }: { controller: BoardControl
           </select>
         </label>
 
+        <label className={css.scheduleToggle}>
+          <input
+            type="checkbox"
+            checked={reuseSession}
+            onChange={event => { setReuseSession(event.target.checked) }}
+          />
+          <span>{t('exec.reuseSession')}</span>
+        </label>
+        <p className={css.detailText}>{t('exec.reuseSessionHint')}</p>
+
         <section className={css.detailSection}>
           <h4>{t('detail.schedule')}</h4>
           <label className={css.scheduleToggle}>
@@ -246,6 +280,16 @@ export function NewTaskModal({ controller, onClose }: { controller: BoardControl
             </>
           )}
         </section>
+        {isDuplicate && (
+          <label className={css.checkboxLabel} style={{ marginTop: '12px' }}>
+            <input
+              type="checkbox"
+              checked={archiveOriginal}
+              onChange={event => { setArchiveOriginal(event.target.checked) }}
+            />
+            <span>{t('new.archiveOriginal')}</span>
+          </label>
+        )}
     </ModalShell>
   )
 }