@co0ontty/wand 4.94.0 → 4.95.0

package/dist/scheduled-task-agenda.d.ts

@@ -0,0 +1,20 @@
+import type { ScheduledTaskSummary } from "./scheduled-task-types.js";
+export interface AgendaGroup {
+    id: string;
+    title: string;
+    dateLabel: string;
+    active: boolean;
+    tasks: ScheduledTaskSummary[];
+}
+export declare function appointment(value: string, now: Date, timeZone: string): {
+    day: string;
+    time: string;
+    period: string;
+    dateLabel: string;
+    exact: string;
+};
+export declare function isScheduled(task: ScheduledTaskSummary): boolean;
+/** Upcoming details and agenda share exactly the same scheduling facts, independent of local filters. */
+export declare function nextTask(tasks: ScheduledTaskSummary[]): ScheduledTaskSummary | undefined;
+/** Calendar dates, not elapsed 24h blocks; a saved nextRunAt is never recalculated by the view. */
+export declare function groupAgenda(tasks: ScheduledTaskSummary[], now: Date, timeZone: string): AgendaGroup[];

package/dist/scheduled-task-agenda.js

@@ -0,0 +1,82 @@
+function dayParts(value, timeZone) {
+    const parts = new Intl.DateTimeFormat("en-CA", { timeZone, year: "numeric", month: "2-digit", day: "2-digit" }).formatToParts(value);
+    return ["year", "month", "day"].map(key => Number(parts.find(part => part.type === key).value));
+}
+function calendarDay(value, timeZone) {
+    const [year, month, day] = dayParts(value, timeZone);
+    return Date.UTC(year, month - 1, day) / 86_400_000;
+}
+export function appointment(value, now, timeZone) {
+    const date = new Date(value);
+    if (!Number.isFinite(date.getTime()))
+        return { day: "时间待确认", time: "—", period: "", dateLabel: "", exact: "计划时间不可用" };
+    const distance = calendarDay(date, timeZone) - calendarDay(now, timeZone);
+    const [year] = dayParts(date, timeZone), [currentYear] = dayParts(now, timeZone);
+    const weekday = new Intl.DateTimeFormat("zh-CN", { timeZone, weekday: "short" }).format(date);
+    const dateLabel = new Intl.DateTimeFormat("zh-CN", { timeZone, ...(year === currentYear ? {} : { year: "numeric" }), month: "long", day: "numeric" }).format(date);
+    const day = distance === 0 ? "今天" : distance === 1 ? "明天" : distance === 2 ? "后天" : distance > 2 && distance < 7 ? weekday : dateLabel;
+    const time = new Intl.DateTimeFormat("zh-CN", { timeZone, hour: "2-digit", minute: "2-digit", hourCycle: "h23" }).format(date);
+    const hour = Number(new Intl.DateTimeFormat("en-GB", { timeZone, hour: "2-digit", hourCycle: "h23" }).format(date));
+    const period = hour < 5 ? "凌晨" : hour < 12 ? "上午" : hour < 14 ? "中午" : hour < 18 ? "下午" : "晚上";
+    const exact = new Intl.DateTimeFormat("zh-CN", { timeZone, year: "numeric", month: "2-digit", day: "2-digit", hour: "2-digit", minute: "2-digit", hourCycle: "h23" }).format(date);
+    return { day, time, period, dateLabel: `${dateLabel} · ${weekday}`, exact };
+}
+export function isScheduled(task) {
+    return task.enabled && !task.cancelledAt && Boolean(task.nextRunAt);
+}
+function orderedTasks(tasks) {
+    return [...tasks].sort((a, b) => {
+        const left = isScheduled(a) ? Date.parse(a.nextRunAt) : NaN;
+        const right = isScheduled(b) ? Date.parse(b.nextRunAt) : NaN;
+        if (Number.isFinite(left) && Number.isFinite(right))
+            return left - right;
+        return Number.isFinite(left) ? -1 : Number.isFinite(right) ? 1 : 0;
+    });
+}
+/** Upcoming details and agenda share exactly the same scheduling facts, independent of local filters. */
+export function nextTask(tasks) {
+    return orderedTasks(tasks).find(task => isScheduled(task) && Number.isFinite(Date.parse(task.nextRunAt)));
+}
+/** Calendar dates, not elapsed 24h blocks; a saved nextRunAt is never recalculated by the view. */
+export function groupAgenda(tasks, now, timeZone) {
+    const groups = new Map();
+    for (const task of orderedTasks(tasks)) {
+        let id, title, dateLabel = "", active = false;
+        if (isScheduled(task)) {
+            const date = new Date(task.nextRunAt);
+            if (!Number.isFinite(date.getTime())) {
+                id = "unconfirmed";
+                title = "时间待确认";
+            }
+            else if (date.getTime() <= now.getTime()) {
+                id = "due";
+                title = "已到计划时间";
+                active = true;
+            }
+            else {
+                const description = appointment(task.nextRunAt, now, timeZone);
+                id = `day-${calendarDay(date, timeZone)}`;
+                title = description.day;
+                dateLabel = description.dateLabel;
+                active = true;
+            }
+        }
+        else if (!task.cancelledAt && task.nextRunAt && !task.enabled) {
+            id = "paused";
+            title = "已暂停";
+        }
+        else {
+            id = "finished";
+            title = "已结束";
+        }
+        let group = groups.get(id);
+        if (!group) {
+            group = { id, title, dateLabel, active, tasks: [] };
+            groups.set(id, group);
+        }
+        group.tasks.push(task);
+    }
+    const all = [...groups.values()];
+    return [...all.filter(group => group.active), ...all.filter(group => !group.active && group.id === "unconfirmed"),
+        ...all.filter(group => group.id === "paused"), ...all.filter(group => group.id === "finished")];
+}

package/dist/scheduled-task-calendar.d.ts

@@ -0,0 +1,37 @@
+import type { ScheduledTaskRunView, ScheduledTaskRunFactView, ScheduledTaskSummary } from "./scheduled-task-types.js";
+interface CalendarEntryBase {
+    key: string;
+    task: ScheduledTaskSummary;
+    at: string;
+    date: string;
+}
+export type CalendarEntry<T extends ScheduledTaskRunFactView = ScheduledTaskRunView> = CalendarEntryBase & ({
+    kind: "planned";
+    waiting: boolean;
+} | {
+    kind: "execution";
+    waiting: false;
+    run: T;
+});
+export interface CalendarProjection<T extends ScheduledTaskRunFactView = ScheduledTaskRunView> {
+    entries: CalendarEntry<T>[];
+    issues: string[];
+    truncated: boolean;
+}
+/** Future projections only: saved next trigger first, then the canonical calendar-time engine.
+ * Never infer past executions from the current recurrence rule. This does not schedule work. */
+export declare function calendarEntries<T extends ScheduledTaskRunFactView = ScheduledTaskRunView>(tasks: readonly ScheduledTaskSummary[], start: string, end: string, now: Date, displayZone: string, limit?: number): CalendarProjection<T>;
+/** Historical bars are immutable execution facts. Their actual claim time wins
+ * over a projected duplicate; old recurrences are never retroactively expanded. */
+export declare function calendarData<T extends ScheduledTaskRunFactView>(tasks: readonly ScheduledTaskSummary[], records: Readonly<Record<string, readonly T[]>>, start: string, end: string, now: Date, zone: string): CalendarProjection<T>;
+export interface WeekPosition<T extends ScheduledTaskRunFactView = ScheduledTaskRunView> {
+    entry: CalendarEntry<T>;
+    day: number;
+    minute: number;
+    lane: number;
+    lanes: number;
+}
+/** Lane collisions are based on readable marker height, NOT invented execution
+ * duration. Every marker remains anchored to its own exact wall-clock minute. */
+export declare function weekPositions<T extends ScheduledTaskRunFactView>(entries: readonly CalendarEntry<T>[], weekStart: string, zone: string, hourPixels?: number, markerHeight?: number): WeekPosition<T>[];
+export {};

package/dist/scheduled-task-calendar.js

@@ -0,0 +1,131 @@
+import { nextScheduledTime } from "./scheduled-task-time.js";
+import { isScheduled } from "./scheduled-task-agenda.js";
+import { dateKey } from "./scheduled-task-activity.js";
+/** Future projections only: saved next trigger first, then the canonical calendar-time engine.
+ * Never infer past executions from the current recurrence rule. This does not schedule work. */
+export function calendarEntries(tasks, start, end, now, displayZone, limit = 1000) {
+    const result = { entries: [], issues: [], truncated: false };
+    const lower = Date.parse(`${start}T00:00:00Z`) - 36 * 3_600_000;
+    const upper = Date.parse(`${end}T23:59:59Z`) + 36 * 3_600_000;
+    if (!Number.isFinite(lower) || !Number.isFinite(upper) || end < start || upper - lower > 70 * 86_400_000)
+        throw new Error("日历范围应限制在当前月的日期网格。");
+    limit = Number.isFinite(limit) ? Math.max(1, Math.min(1000, Math.trunc(limit))) : 1000;
+    const append = (task, at) => {
+        const date = dateKey(at, displayZone);
+        if (date < start || date > end)
+            return true;
+        if (result.entries.length >= limit) {
+            result.truncated = true;
+            return false;
+        }
+        result.entries.push({ kind: "planned", key: `plan:${task.id}:${Date.parse(at)}`, task, at, date, waiting: Date.parse(at) <= now.getTime() });
+        return true;
+    };
+    taskLoop: for (const task of tasks) {
+        if (!isScheduled(task))
+            continue;
+        if (!Number.isFinite(Date.parse(task.nextRunAt))) {
+            result.issues.push(`${task.title}：计划时间待确认`);
+            continue;
+        }
+        try {
+            let candidate = task.nextRunAt;
+            if (task.schedule.kind === "once") {
+                if (!append(task, candidate))
+                    break;
+                continue;
+            }
+            const cursor = Math.max(now.getTime(), lower);
+            if (Date.parse(candidate) < cursor) {
+                if (Date.parse(candidate) <= now.getTime() && !append(task, candidate))
+                    break;
+                candidate = nextScheduledTime(task.schedule, new Date(cursor));
+            }
+            // A single supported recurrence produces at most one future occurrence per
+            // local day. Bounded iteration also protects corrupt legacy input.
+            for (let count = 0; candidate && Date.parse(candidate) <= upper && count < 74; count++) {
+                if (!append(task, candidate))
+                    break taskLoop;
+                const next = nextScheduledTime(task.schedule, new Date(candidate));
+                if (next && Date.parse(next) <= Date.parse(candidate))
+                    throw new Error("计划未向后推进");
+                candidate = next;
+            }
+        }
+        catch {
+            result.issues.push(`${task.title}：暂时无法推算日程，请核对计划与时区`);
+        }
+    }
+    result.entries.sort((a, b) => Date.parse(a.at) - Date.parse(b.at));
+    return result;
+}
+/** Historical bars are immutable execution facts. Their actual claim time wins
+ * over a projected duplicate; old recurrences are never retroactively expanded. */
+export function calendarData(tasks, records, start, end, now, zone) {
+    const projected = calendarEntries(tasks, start, end, now, zone);
+    const known = new Set();
+    const actual = [];
+    for (const task of tasks)
+        for (const run of records[task.id] ?? []) {
+            if (!Number.isFinite(Date.parse(run.claimedAt)))
+                continue;
+            known.add(`${task.id}:${Date.parse(run.scheduledAt)}`);
+            const date = dateKey(run.claimedAt, zone);
+            if (date < start || date > end)
+                continue;
+            if (actual.length >= 1000) {
+                projected.truncated = true;
+                break;
+            }
+            actual.push({ kind: "execution", key: `run:${run.id}`, task, at: run.claimedAt, date, waiting: false, run });
+        }
+    const forecast = projected.entries.filter(entry => !known.has(`${entry.task.id}:${Date.parse(entry.at)}`));
+    const entries = [...actual, ...forecast].sort((a, b) => Date.parse(a.at) - Date.parse(b.at));
+    return { ...projected, entries: entries.slice(0, 1000), truncated: projected.truncated || entries.length > 1000 };
+}
+/** Lane collisions are based on readable marker height, NOT invented execution
+ * duration. Every marker remains anchored to its own exact wall-clock minute. */
+export function weekPositions(entries, weekStart, zone, hourPixels = 64, markerHeight = 44) {
+    const result = [];
+    const byDay = new Map();
+    for (const entry of entries) {
+        const day = Math.round((Date.parse(`${entry.date}T12:00:00Z`) - Date.parse(`${weekStart}T12:00:00Z`)) / 86_400_000);
+        if (day < 0 || day > 6)
+            continue;
+        const parts = new Intl.DateTimeFormat("en-GB", { timeZone: zone, hour: "2-digit", minute: "2-digit", hourCycle: "h23" }).formatToParts(new Date(entry.at));
+        const minute = Number(parts.find(part => part.type === "hour").value) * 60 + Number(parts.find(part => part.type === "minute").value);
+        const list = byDay.get(day) ?? [];
+        list.push({ entry, minute });
+        byDay.set(day, list);
+    }
+    for (const [day, items] of byDay) {
+        items.sort((a, b) => a.minute - b.minute);
+        let cluster = [], end = -1;
+        const flush = () => {
+            const lanes = [], positioned = [];
+            for (const item of cluster) {
+                const top = item.minute * hourPixels / 60;
+                let lane = lanes.findIndex(bottom => bottom <= top);
+                if (lane < 0)
+                    lane = lanes.length;
+                lanes[lane] = top + markerHeight;
+                positioned.push({ ...item, day, lane, lanes: 0 });
+            }
+            for (const item of positioned)
+                result.push({ ...item, lanes: lanes.length });
+        };
+        for (const item of items) {
+            const top = item.minute * hourPixels / 60;
+            if (cluster.length && top >= end) {
+                flush();
+                cluster = [];
+                end = -1;
+            }
+            cluster.push(item);
+            end = Math.max(end, top + markerHeight);
+        }
+        if (cluster.length)
+            flush();
+    }
+    return result;
+}

package/dist/scheduled-task-read-range.d.ts

@@ -0,0 +1,7 @@
+import type { ScheduledTaskReadRange } from "./scheduled-task-types.js";
+export declare function scheduledReadZone(value: unknown): string;
+export declare function scheduledReadRange(from: unknown, to: unknown, zone: unknown, limit?: number): ScheduledTaskReadRange;
+export declare function scheduledActivityRange(now: Date, zone: unknown): ScheduledTaskReadRange;
+/** Offset guard band lets SQLite use the normalized date index; exact IANA date
+ * filtering follows in the service, without approximating local days as 24h. */
+export declare function scheduledReadBounds(range: ScheduledTaskReadRange): [string, string];

package/dist/scheduled-task-read-range.js

@@ -0,0 +1,35 @@
+import { addDateDays, dateKey } from "./scheduled-task-activity.js";
+export function scheduledReadZone(value) {
+    if (typeof value !== "string" || value.length > 100)
+        throw new Error("请提供有效的显示时区。");
+    try {
+        new Intl.DateTimeFormat("en", { timeZone: value }).format();
+    }
+    catch {
+        throw new Error("请提供有效的显示时区。");
+    }
+    return value;
+}
+function dateOnly(value) {
+    if (typeof value !== "string" || !/^\d{4}-\d{2}-\d{2}$/.test(value)
+        || !Number.isFinite(Date.parse(`${value}T12:00:00Z`)) || new Date(`${value}T12:00:00Z`).toISOString().slice(0, 10) !== value)
+        throw new Error("日期须为有效的 YYYY-MM-DD。");
+    return value;
+}
+export function scheduledReadRange(from, to, zone, limit = 1000) {
+    const start = dateOnly(from), end = dateOnly(to), timeZone = scheduledReadZone(zone);
+    const days = (Date.parse(`${end}T12:00:00Z`) - Date.parse(`${start}T12:00:00Z`)) / 86_400_000;
+    if (days < 0 || days > 61)
+        throw new Error("日历一次最多读取 62 天。");
+    return { from: start, to: end, timeZone, complete: true, truncated: false, limit, invalidDates: 0 };
+}
+export function scheduledActivityRange(now, zone) {
+    const timeZone = scheduledReadZone(zone), today = dateKey(now, timeZone);
+    const weekday = (new Date(`${today}T12:00:00Z`).getUTCDay() + 6) % 7;
+    return { from: addDateDays(today, -weekday - 77), to: addDateDays(today, 6 - weekday), timeZone, complete: true, truncated: false, limit: 5000, invalidDates: 0 };
+}
+/** Offset guard band lets SQLite use the normalized date index; exact IANA date
+ * filtering follows in the service, without approximating local days as 24h. */
+export function scheduledReadBounds(range) {
+    return [new Date(Date.parse(`${range.from}T00:00:00Z`) - 36 * 3_600_000).toISOString(), new Date(Date.parse(`${range.to}T23:59:59Z`) + 36 * 3_600_000).toISOString()];
+}

package/dist/scheduled-task-service.d.ts

@@ -1,5 +1,5 @@
 import type { ConversationService } from "./conversation-service.js";
-import type { ScheduledTaskDetail, ScheduledTaskSummary } from "./scheduled-task-types.js";
+import type { ScheduledTaskDetail, ScheduledTaskRunView, ScheduledTaskSummary, ScheduledTaskCalendarResponse, ScheduledTaskActivityResponse } from "./scheduled-task-types.js";
 import type { WandStorage } from "./storage.js";
 import type { ProcessEvent, SessionSnapshot } from "./types.js";
 export declare class ScheduledTaskConflictError extends Error {
@@ -29,6 +29,11 @@ export declare class ScheduledTaskService {
     private summary;
     list(includeCancelled?: boolean): ScheduledTaskSummary[];
     get(id: string): ScheduledTaskDetail;
+    getRun(taskId: string, runId: string): ScheduledTaskRunView;
+    private fact;
+    private facts;
+    activity(id: string, timeZone: unknown): ScheduledTaskActivityResponse;
+    calendar(from: unknown, to: unknown, timeZone: unknown): ScheduledTaskCalendarResponse;
     create(value: unknown): ScheduledTaskSummary;
     update(id: string, value: unknown): ScheduledTaskSummary;
     private reconcile;

package/dist/scheduled-task-service.js

@@ -5,6 +5,9 @@ import { requireTeamEmployee } from "./ai-team-employee-binding.js";
 import { employeeConversationId } from "./conversation-types.js";
 import { getErrorMessage } from "./error-utils.js";
 import { nextScheduledTime, parseTaskSchedule } from "./scheduled-task-time.js";
+import { dateKey } from "./scheduled-task-activity.js";
+import { calendarData } from "./scheduled-task-calendar.js";
+import { scheduledActivityRange, scheduledReadBounds, scheduledReadRange } from "./scheduled-task-read-range.js";
 import { bodyObject } from "./server-request.js";
 import { resolveSessionCwd } from "./session-cwd.js";
 import { selectEmployeeCandidate } from "./silicon-employee-dispatch.js";
@@ -93,7 +96,7 @@ export class ScheduledTaskService {
         }
         const workspace = task.workspaceId ? this.deps.storage.getWorkspace(task.workspaceId) : null;
         const directory = this.executionDirectory(task);
-        const lastRun = this.deps.storage.listScheduledTaskRuns(task.id, 1)[0];
+        const lastRun = this.deps.storage.latestScheduledTaskRun(task.id);
         return { ...task, employeeName: employee?.name ?? "员工已不可用", employeeUnavailableReason,
             workspaceName: task.workspaceId ? workspace?.name ?? "项目已不可用" : "服务默认目录",
             workspaceCwd: directory.cwd, workspaceUnavailableReason: directory.error,
@@ -105,6 +108,63 @@ export class ScheduledTaskService {
     get(id) {
         return { task: this.summary(this.requireTask(id)), runs: this.deps.storage.listScheduledTaskRuns(id).map(run => this.runView(run)) };
     }
+    getRun(taskId, runId) {
+        this.requireTask(taskId);
+        const run = this.deps.storage.getScheduledTaskRun(runId);
+        if (!run || run.taskId !== taskId)
+            throw new ScheduledTaskNotFoundError("执行记录不存在。");
+        return this.runView(run);
+    }
+    fact(run) {
+        const view = this.runView(run);
+        const { id, taskId, scheduledAt, claimedAt, executionFinishedAt, executionOutcome, employeeId, workspaceId, cwd, state, executionStatus, sessionId } = view;
+        return { id, taskId, scheduledAt, claimedAt, executionFinishedAt, executionOutcome, employeeId, workspaceId, cwd, state, executionStatus, sessionId,
+            error: view.error && view.error.length > 8000 ? `${view.error.slice(0, 8000)}…（完整错误请查看本次记录或会话）` : view.error };
+    }
+    facts(range, taskId) {
+        const [from, to] = scheduledReadBounds(range);
+        const raw = this.deps.storage.listScheduledTaskRunFacts(from, to, taskId, range.limit + 1);
+        range.truncated = raw.length > range.limit;
+        range.invalidDates = this.deps.storage.countInvalidScheduledTaskRunDates(taskId);
+        range.complete = !range.truncated && range.invalidDates === 0;
+        return raw.slice(0, range.limit).filter(run => {
+            if (!Number.isFinite(Date.parse(run.claimedAt))) {
+                range.complete = false;
+                return false;
+            }
+            const day = dateKey(run.claimedAt, range.timeZone);
+            return day >= range.from && day <= range.to;
+        }).map(run => this.fact(run));
+    }
+    activity(id, timeZone) {
+        this.requireTask(id);
+        const now = this.now(), range = scheduledActivityRange(now, timeZone);
+        return { runs: this.facts(range, id), range, generatedAt: now.toISOString() };
+    }
+    calendar(from, to, timeZone) {
+        const now = this.now(), range = scheduledReadRange(from, to, timeZone);
+        const tasks = this.list(true), facts = this.facts(range);
+        const records = {};
+        for (const run of facts)
+            (records[run.taskId] ??= []).push(run);
+        const projection = calendarData(tasks, records, range.from, range.to, now, range.timeZone);
+        range.truncated ||= projection.truncated;
+        const taskIDs = new Set(tasks.map(task => task.id));
+        const orphaned = facts.filter(run => !taskIDs.has(run.taskId)).length;
+        range.complete &&= !range.truncated && orphaned === 0 && projection.issues.length === 0;
+        const issues = [...projection.issues];
+        if (range.truncated)
+            issues.push("历史或预计安排已达到读取上限，当前范围可能不完整，请缩小日期范围。");
+        if (range.invalidDates)
+            issues.push(`${range.invalidDates} 条旧记录时间待确认，未绘入日期格。`);
+        if (orphaned)
+            issues.push(`${orphaned} 条记录的原计划已不可用。`);
+        return { tasks, entries: projection.entries.map(({ task, ...entry }) => {
+                const parts = new Intl.DateTimeFormat("en-GB", { timeZone: range.timeZone, hour: "2-digit", minute: "2-digit", hourCycle: "h23" }).formatToParts(new Date(entry.at));
+                const minuteOfDay = Number(parts.find(part => part.type === "hour").value) * 60 + Number(parts.find(part => part.type === "minute").value);
+                return { ...entry, taskId: task.id, minuteOfDay };
+            }), range, generatedAt: now.toISOString(), issues };
+    }
     create(value) {
         const input = bodyObject(value);
         if (typeof input.requestId !== "string" || !/^[\w:-]{8,80}$/.test(input.requestId))

package/dist/scheduled-task-state.d.ts

@@ -3,7 +3,7 @@ import type { ScheduledTaskRun, ScheduledTaskRunView } from "./scheduled-task-ty
 import type { SessionSnapshot } from "./types.js";
 export declare function sessionActive(session: SessionSnapshot): boolean;
 /** Pure read projection; it never settles or replays a scheduled occurrence. */
-export declare function scheduledExecutionStatus(run: ScheduledTaskRun, receipt: ConversationReceipt | null, session: SessionSnapshot | null): ScheduledTaskRunView["executionStatus"];
+export declare function scheduledExecutionStatus(run: Pick<ScheduledTaskRun, "state" | "executionOutcome" | "executionFinishedAt">, receipt: ConversationReceipt | null, session: SessionSnapshot | null): ScheduledTaskRunView["executionStatus"];
 /** Settles only observed facts; missing/unknown acceptance never authorizes replay. */
 export declare function reconcileScheduledRun(run: ScheduledTaskRun, receipt: ConversationReceipt | null, session: SessionSnapshot | null, now: string, options: {
     recoverInactive: boolean;

package/dist/scheduled-task-types.d.ts

@@ -69,3 +69,41 @@ export interface ScheduledTaskDetail {
     task: ScheduledTaskSummary;
     runs: ScheduledTaskRunView[];
 }
+/** Bounded read projections deliberately exclude prompts, receipts and request IDs. */
+export type ScheduledTaskRunFactView = Pick<ScheduledTaskRunView, "id" | "taskId" | "scheduledAt" | "claimedAt" | "executionFinishedAt" | "executionOutcome" | "employeeId" | "workspaceId" | "cwd" | "state" | "error" | "executionStatus" | "sessionId">;
+export type ScheduledTaskRunFact = Omit<ScheduledTaskRun, "prompt">;
+export interface ScheduledTaskReadRange {
+    from: string;
+    to: string;
+    timeZone: string;
+    complete: boolean;
+    truncated: boolean;
+    limit: number;
+    invalidDates: number;
+}
+export type ScheduledCalendarItem = {
+    key: string;
+    taskId: string;
+    at: string;
+    date: string;
+    minuteOfDay: number;
+} & ({
+    kind: "planned";
+    waiting: boolean;
+} | {
+    kind: "execution";
+    waiting: false;
+    run: ScheduledTaskRunFactView;
+});
+export interface ScheduledTaskCalendarResponse {
+    tasks: ScheduledTaskSummary[];
+    entries: ScheduledCalendarItem[];
+    range: ScheduledTaskReadRange;
+    generatedAt: string;
+    issues: string[];
+}
+export interface ScheduledTaskActivityResponse {
+    runs: ScheduledTaskRunFactView[];
+    range: ScheduledTaskReadRange;
+    generatedAt: string;
+}

package/dist/server-asset-routes.js

@@ -63,8 +63,9 @@ export function registerAssetRoutes(app, deps) {
             res.status(404).type("text/plain").send("Browser module not found; reload the page after updating.");
             return;
         }
-        // The directory fingerprints the entire immutable module graph. Never
-        // substitute current bytes for a missing older module under its cached URL.
+        // Each directory fingerprints a module's static dependency component.
+        // Legacy whole-build directories remain readable from retained snapshots.
+        // Never substitute current bytes for a missing older immutable URL.
         res.setHeader("Cache-Control", "public, max-age=31536000, immutable");
         res.type("application/javascript").send(content);
     });

package/dist/server-conversation-organize-routes.d.ts

@@ -0,0 +1,4 @@
+import type { Express } from "express";
+import { type ConversationOrganizationDependencies } from "./conversation-organize-service.js";
+import type { WandStorage } from "./storage.js";
+export declare function registerConversationOrganizeRoutes(app: Express, storage: WandStorage, deps: ConversationOrganizationDependencies): void;

package/dist/server-conversation-organize-routes.js

@@ -0,0 +1,75 @@
+import { asyncRoute } from "./express-async.js";
+import { badRequest, conflict, notFound } from "./http-error.js";
+import { conversationOrganizationService } from "./conversation-organize-service.js";
+function scopeFrom(body, storage) {
+    if (body.mode !== undefined && body.mode !== "auto" && body.mode !== "all")
+        throw badRequest("请选择默认范围或所有工作会话。");
+    const ids = (value) => {
+        if (value === undefined)
+            return undefined;
+        if (!Array.isArray(value) || value.length > 500 || value.some(id => typeof id !== "string" || !id.trim()))
+            throw badRequest("会话/任务ID列表无效或超过500个。");
+        return [...new Set(value)];
+    };
+    const taskIds = ids(body.taskIds), sessionIds = ids(body.sessionIds);
+    let target;
+    if (body.target !== undefined) {
+        if (!body.target || typeof body.target !== "object" || Array.isArray(body.target) || taskIds || sessionIds)
+            throw badRequest("目录范围与多选范围不能混用。");
+        const value = body.target;
+        if (value.kind === "all")
+            target = { kind: "all" };
+        else if (value.kind === "workspace" && typeof value.workspaceId === "string" && storage.getWorkspace(value.workspaceId))
+            target = { kind: "workspace", workspaceId: value.workspaceId };
+        else if (value.kind === "directory" && typeof value.cwd === "string" && value.cwd.trim())
+            target = { kind: "directory", cwd: value.cwd };
+        else
+            throw badRequest("会话归类目录无效。");
+    }
+    if (!target && !taskIds?.length && !sessionIds?.length)
+        throw badRequest("请选择会话、任务或目录范围。");
+    return { mode: body.mode === "all" ? "all" : "auto", target, taskIds, sessionIds };
+}
+export function registerConversationOrganizeRoutes(app, storage, deps) {
+    const service = conversationOrganizationService(storage, deps);
+    app.post("/api/sessions/auto-organize", asyncRoute(async (req, res) => {
+        const body = (req.body ?? {});
+        if (body.action === "start") {
+            if (typeof body.token !== "string" || !body.token.trim() || body.force !== undefined && typeof body.force !== "boolean")
+                throw badRequest("确认令牌或执行参数无效。");
+            try {
+                res.status(202).json({ kind: "job", job: service.start(body.token, body.force === true) });
+            }
+            catch (error) {
+                throw conflict(error instanceof Error ? error.message : "会话归类预览已失效。");
+            }
+            return;
+        }
+        if (body.action !== undefined && body.action !== "preview")
+            throw badRequest("会话归类操作无效。");
+        try {
+            res.json({ kind: "preview", preview: service.prepare(scopeFrom(body, storage)) });
+        }
+        catch (error) {
+            throw badRequest(error instanceof Error ? error.message : "无法读取会话归类范围。");
+        }
+    }));
+    app.get("/api/sessions/auto-organize/by-token/:token", (req, res) => {
+        const job = storage.getConversationOrganizationJobByToken(req.params.token);
+        if (!job)
+            throw notFound("尚未找到该确认请求的已接受作业；不会自动重发。");
+        res.json({ job: service.get(job.id) ?? job });
+    });
+    app.get("/api/sessions/auto-organize/:id", (req, res) => {
+        const job = service.get(req.params.id);
+        if (!job)
+            throw notFound("归类作业不存在。");
+        res.json({ job });
+    });
+    app.post("/api/sessions/auto-organize/:id/cancel", (req, res) => {
+        const job = service.cancel(req.params.id);
+        if (!job)
+            throw notFound("归类作业不存在。");
+        res.json({ job });
+    });
+}

package/dist/server-conversation-routes.js

@@ -1,5 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { AiTeamConflictError } from "./ai-team-runner.js";
+import { parseConversationExecutionPreference } from "./conversation-execution-preference.js";
 import { asyncRoute } from "./express-async.js";
 import { bodyObject, sendRouteError, text } from "./server-request.js";
 import { badRequest, notFound } from "./http-error.js";
@@ -68,7 +69,7 @@ export function registerConversationRoutes(app, service) {
     post("/api/conversations", (_id, body) => service.createGroup(text(body.requestId), bodyObject(body.group)));
     post("/api/conversations/:id/invitations", (id, body) => service.invite(id, text(body.requestId), Number(body.memberVersion), bodyObject(body.group)));
     post("/api/conversations/:id/channel", (id, body) => service.prepare(id, text(body.requestId), text(body.cwd) || undefined));
-    post("/api/conversations/:id/messages", (id, body) => service.send(id, text(body.requestId), text(body.input), targetOf(body.target), text(body.cwd) || undefined));
+    post("/api/conversations/:id/messages", (id, body) => service.send(id, text(body.requestId), text(body.input), targetOf(body.target), text(body.cwd) || undefined, true, undefined, parseConversationExecutionPreference(body.executionPreference)));
     post("/api/conversations/:id/tasks", (id, body) => service.dispatch(id, text(body.requestId), {
         title: text(body.title), description: text(body.description), workspaceId: text(body.workspaceId), cwd: text(body.cwd) || undefined,
         memberVersion: body.memberVersion === undefined ? undefined : Number(body.memberVersion),

package/dist/server-employee-im-routes.d.ts

@@ -0,0 +1,9 @@
+import type { Express, RequestHandler } from "express";
+import type { EmployeeImService } from "./employee-im.js";
+import type { WandStorage } from "./storage.js";
+/** Credentials are admin-only, write-only and never part of employee list/detail responses. */
+export declare function registerEmployeeImRoutes(app: Express, deps: {
+    storage: WandStorage;
+    im: EmployeeImService;
+    requireAdmin: RequestHandler;
+}): void;

package/dist/server-employee-im-routes.js

@@ -0,0 +1,40 @@
+import { asyncRoute } from "./express-async.js";
+import { bodyObject } from "./server-request.js";
+import { EmployeeImConfigError } from "./employee-im-config.js";
+/** Credentials are admin-only, write-only and never part of employee list/detail responses. */
+export function registerEmployeeImRoutes(app, deps) {
+    const path = "/api/silicon-employees/:id/im";
+    app.use(path, (_req, res, next) => { res.setHeader("Cache-Control", "no-store"); next(); }, deps.requireAdmin, (req, res, next) => {
+        if (!deps.storage.getSiliconEmployeeDefinition(String(req.params.id))) {
+            res.status(404).json({ error: "员工不存在。" });
+            return;
+        }
+        next();
+    });
+    app.get(path, (req, res) => { res.json(deps.storage.getEmployeeImConfig(String(req.params.id))); });
+    app.put(path, (req, res) => {
+        try {
+            res.json(deps.storage.saveEmployeeImConfig(String(req.params.id), bodyObject(req.body)));
+        }
+        catch (error) {
+            // Validation errors never contain request values. Crypto/storage failures receive a fixed safe message.
+            const message = error instanceof EmployeeImConfigError
+                ? error.message : "IM 配置保存失败，请检查本机密钥与存储状态。";
+            res.status(400).json({ error: message });
+        }
+    });
+    app.post(`${path}/test`, asyncRoute(async (req, res) => {
+        const provider = bodyObject(req.body).provider;
+        if (provider !== "telegram" && provider !== "dingtalk") {
+            res.status(400).json({ error: "请选择 Telegram 或钉钉。" });
+            return;
+        }
+        try {
+            await deps.im.test(String(req.params.id), provider);
+            res.json({ ok: true });
+        }
+        catch {
+            res.status(502).json({ error: "测试消息发送未确认，请检查已保存的配置与网络；不会自动重发。" });
+        }
+    }));
+}

package/dist/server-employee-routes.js

@@ -30,7 +30,7 @@ export function employeeDraftAiOptions(storage, config, free) {
             command: provider === "qoder" ? "qodercli" : provider,
             selectedModel: null,
             thinkingEffort: config.defaultThinkingEffort,
-        }, config, hr, free), opsPersona: hr.prompt };
+        }, config, hr, free, { storage }), opsPersona: hr.prompt };
 }
 function sendEmployeeError(res, error, context) {
     const message = getErrorMessage(error, "硅基员工操作失败。");