@evandu/super-pi 0.1.131 → 0.1.132

package/dist/server/scheduled-tasks.d.ts

@@ -0,0 +1,101 @@
+import type { ModelSelection } from "./types.js";
+/**
+ * WHEN A SCHEDULED TASK RUNS.
+ *
+ * FOUR SHAPES, AND NOT A CRON EXPRESSION. A cron string would bring a parser, a timezone story and a
+ * daylight-saving story to a panel that runs on the same machine as the server - and the two shapes
+ * people actually ask for are "every N minutes" and "every day at HH:MM". The set is closed on purpose:
+ * a schedule that cannot be expressed here is not a schedule the panel can edit, and the panel is the
+ * only place a user can see what they are agreeing to.
+ *
+ * - `interval`: every N minutes. The interval is anchored on the last run, not on the wall clock, so a
+ *   task that takes four minutes to run does not slowly drift later every cycle.
+ * - `daily`: every day at a local `HH:MM`.
+ * - `weekly`: on the listed weekdays (0 = Sunday) at a local `HH:MM`.
+ * - `once`: at one instant. The task is finished after it fires.
+ *
+ * THE TIME IS LOCAL, not UTC and not a named zone, because the server and the panel are the same
+ * machine for every installation that exists. A "09:00" that means something different in the panel
+ * than in the scheduler would be the worst possible bug in this feature: it would fire at the wrong
+ * hour and look like it had fired at the right one.
+ */
+export type ScheduleSpec = {
+    kind: "interval";
+    everyMinutes: number;
+} | {
+    kind: "daily";
+    time: string;
+} | {
+    kind: "weekly";
+    weekdays: number[];
+    time: string;
+} | {
+    kind: "once";
+    at: number;
+};
+/**
+ * ONE SCHEDULED TASK: a prompt, a model to run it with, and when to run it.
+ *
+ * `conversationId` is the task's OWN conversation, created lazily on the first run. The task never runs
+ * in somebody else's conversation: a scheduled run that landed in the user's working session would
+ * interleave with what they were doing, and would change that session's model out from under it.
+ */
+export type ScheduledTask = {
+    id: string;
+    name: string;
+    /** The instruction, sent VERBATIM as the user message of the task's conversation. */
+    prompt: string;
+    /** The workspace the task belongs to: it decides the working directory and the defaults. */
+    workspaceId: string;
+    /** The task's own conversation, created on the first run. Absent until then. */
+    conversationId?: string;
+    /** Overrides the workspace's default agent. */
+    agentId?: string;
+    /** Overrides the workspace's default model. A `provider`/`modelId` PAIR, never half of one. */
+    model?: ModelSelection;
+    schedule: ScheduleSpec;
+    enabled: boolean;
+    /** When the task fires next, in epoch milliseconds. Absent for a finished one-shot task. */
+    nextRunAt?: number;
+    lastRunAt?: number;
+    lastRunStatus?: "completed" | "failed" | "skipped";
+    lastRunMessage?: string;
+    /** Whether a person or the agent created it. Both are editable by both. */
+    createdBy: "user" | "agent";
+    createdAt: number;
+    updatedAt: number;
+};
+/** The shortest interval a task may ask for. A one-minute floor is what makes a task a task. */
+export declare const MIN_INTERVAL_MINUTES = 1;
+/** The longest interval: a week. Anything longer is a calendar arrangement, not an interval. */
+export declare const MAX_INTERVAL_MINUTES: number;
+/**
+ * Reads a schedule out of whatever a caller sent, or explains why it cannot.
+ *
+ * THE SERVER OWNS THIS, and the extension on the other side of the wire deliberately does NOT have a
+ * copy of it. The extension hands over what the model wrote; this function decides what it means. A
+ * second implementation on the extension side would be a second opinion about the same wire, and the two
+ * would disagree the first time a model wrote a schedule in a shape one of them accepted and the other
+ * did not - with the model's mistake showing up as a server error it cannot explain.
+ */
+export declare function normalizeSchedule(raw: unknown): ScheduleSpec;
+/**
+ * WHEN THE TASK FIRES NEXT, given a moment to look forward from.
+ *
+ * `undefined` means "never again": a one-shot task whose moment has passed.
+ *
+ * The daily and weekly cases walk forward day by day in LOCAL time rather than adding 24 hours, so a
+ * schedule at 09:00 stays at 09:00 across a daylight-saving change instead of drifting to 08:00 or
+ * 10:00 for half the year.
+ */
+export declare function nextRunAt(spec: ScheduleSpec, from: number): number | undefined;
+/**
+ * THE SCHEDULE IN WORDS, for the panel and for the text the agent reads back.
+ *
+ * One implementation for both readers, because two descriptions of one schedule would eventually say
+ * two different things - and the agent's description is what the user is told when the agent says
+ * "I set up a daily task". If the two disagreed, the user would find out from the clock.
+ */
+export declare function describeSchedule(spec: ScheduleSpec): string;
+/** A moment as `YYYY-MM-DD HH:MM`, in local time. */
+export declare function formatMoment(ms: number): string;

package/dist/server/scheduled-tasks.js

@@ -0,0 +1,138 @@
+/** The shortest interval a task may ask for. A one-minute floor is what makes a task a task. */
+export const MIN_INTERVAL_MINUTES = 1;
+/** The longest interval: a week. Anything longer is a calendar arrangement, not an interval. */
+export const MAX_INTERVAL_MINUTES = 60 * 24 * 7;
+/**
+ * Reads a schedule out of whatever a caller sent, or explains why it cannot.
+ *
+ * THE SERVER OWNS THIS, and the extension on the other side of the wire deliberately does NOT have a
+ * copy of it. The extension hands over what the model wrote; this function decides what it means. A
+ * second implementation on the extension side would be a second opinion about the same wire, and the two
+ * would disagree the first time a model wrote a schedule in a shape one of them accepted and the other
+ * did not - with the model's mistake showing up as a server error it cannot explain.
+ */
+export function normalizeSchedule(raw) {
+    if (!raw || typeof raw !== "object")
+        throw new Error("周期必须是一个对象：{\"kind\":\"interval\",\"everyMinutes\":30} 这样写。");
+    const value = raw;
+    const kind = typeof value.kind === "string" ? value.kind.trim() : "";
+    if (kind === "interval") {
+        const everyMinutes = Number(value.everyMinutes);
+        if (!Number.isFinite(everyMinutes) || !Number.isInteger(everyMinutes))
+            throw new Error("每隔 N 分钟需要一个整数分钟数。");
+        if (everyMinutes < MIN_INTERVAL_MINUTES || everyMinutes > MAX_INTERVAL_MINUTES) {
+            throw new Error(`间隔分钟数要在 ${MIN_INTERVAL_MINUTES} 到 ${MAX_INTERVAL_MINUTES} 之间。`);
+        }
+        return { kind: "interval", everyMinutes };
+    }
+    if (kind === "daily")
+        return { kind: "daily", time: normalizeTime(value.time) };
+    if (kind === "weekly") {
+        const weekdays = normalizeWeekdays(value.weekdays);
+        return { kind: "weekly", weekdays, time: normalizeTime(value.time) };
+    }
+    if (kind === "once") {
+        const at = Number(value.at);
+        if (!Number.isFinite(at) || at <= 0)
+            throw new Error("一次性任务需要一个触发时刻（毫秒时间戳）。");
+        return { kind: "once", at };
+    }
+    throw new Error("周期只能是 interval（每隔 N 分钟）、daily（每天）、weekly（每周）或 once（仅一次）。");
+}
+/** `HH:MM`, twenty-four hour, leading zero or not. The only time shape this feature accepts. */
+function normalizeTime(raw) {
+    if (typeof raw !== "string")
+        throw new Error("触发时刻要写成 \"HH:MM\"，比如 \"09:00\"。");
+    const match = /^(\d{1,2}):(\d{2})$/.exec(raw.trim());
+    if (!match)
+        throw new Error("触发时刻要写成 \"HH:MM\"，比如 \"09:00\"。");
+    const hours = Number(match[1]);
+    const minutes = Number(match[2]);
+    if (hours > 23 || minutes > 59)
+        throw new Error("触发时刻不是一个真实的时间。");
+    return `${String(hours).padStart(2, "0")}:${String(minutes).padStart(2, "0")}`;
+}
+/** The weekdays of a weekly schedule, sorted and deduplicated. An empty list means every day. */
+function normalizeWeekdays(raw) {
+    if (!Array.isArray(raw))
+        throw new Error("每周任务需要给出星期几，比如 [1,3] 表示周一和周三。");
+    const days = Array.from(new Set(raw.map((item) => Number(item)).filter((item) => Number.isInteger(item) && item >= 0 && item <= 6)));
+    if (!days.length)
+        throw new Error("每周任务至少要有一天。");
+    return days.sort((a, b) => a - b);
+}
+/**
+ * WHEN THE TASK FIRES NEXT, given a moment to look forward from.
+ *
+ * `undefined` means "never again": a one-shot task whose moment has passed.
+ *
+ * The daily and weekly cases walk forward day by day in LOCAL time rather than adding 24 hours, so a
+ * schedule at 09:00 stays at 09:00 across a daylight-saving change instead of drifting to 08:00 or
+ * 10:00 for half the year.
+ */
+export function nextRunAt(spec, from) {
+    if (spec.kind === "interval")
+        return from + spec.everyMinutes * 60_000;
+    if (spec.kind === "once")
+        return spec.at > from ? spec.at : undefined;
+    if (spec.kind === "daily")
+        return nextDailyAt(spec.time, from);
+    return nextWeeklyAt(spec.weekdays, spec.time, from);
+}
+/** The next moment at `HH:MM` strictly after `from`, in local time. */
+function nextDailyAt(time, from) {
+    const [hours, minutes] = time.split(":").map(Number);
+    const candidate = new Date(from);
+    candidate.setHours(hours, minutes, 0, 0);
+    if (candidate.getTime() <= from)
+        candidate.setDate(candidate.getDate() + 1);
+    return candidate.getTime();
+}
+/**
+ * The next moment at `HH:MM` on one of `weekdays`, strictly after `from`, in local time.
+ *
+ * At most eight days are examined, which covers every weekday list including an empty one: an empty
+ * list means "every day", and the daily case is a special case of it.
+ */
+function nextWeeklyAt(weekdays, time, from) {
+    const days = weekdays.length ? weekdays : [0, 1, 2, 3, 4, 5, 6];
+    const [hours, minutes] = time.split(":").map(Number);
+    for (let offset = 0; offset <= 7; offset += 1) {
+        const candidate = new Date(from);
+        candidate.setDate(candidate.getDate() + offset);
+        candidate.setHours(hours, minutes, 0, 0);
+        if (candidate.getTime() <= from)
+            continue;
+        if (days.includes(candidate.getDay()))
+            return candidate.getTime();
+    }
+    // Unreachable: within eight days every weekday in a full week comes round. The fallback keeps the
+    // function total rather than returning `undefined` for a shape that cannot happen.
+    return nextDailyAt(time, from);
+}
+/**
+ * THE SCHEDULE IN WORDS, for the panel and for the text the agent reads back.
+ *
+ * One implementation for both readers, because two descriptions of one schedule would eventually say
+ * two different things - and the agent's description is what the user is told when the agent says
+ * "I set up a daily task". If the two disagreed, the user would find out from the clock.
+ */
+export function describeSchedule(spec) {
+    if (spec.kind === "interval")
+        return `每隔 ${spec.everyMinutes} 分钟`;
+    if (spec.kind === "daily")
+        return `每天 ${spec.time}`;
+    if (spec.kind === "weekly")
+        return `每周${spec.weekdays.map(weekdayName).join("、")} ${spec.time}`;
+    return `仅一次：${formatMoment(spec.at)}`;
+}
+/** 0 = Sunday, which is what `Date.getDay()` says. */
+function weekdayName(day) {
+    return ["日", "一", "二", "三", "四", "五", "六"][day] ?? "?";
+}
+/** A moment as `YYYY-MM-DD HH:MM`, in local time. */
+export function formatMoment(ms) {
+    const date = new Date(ms);
+    const pad = (value) => String(value).padStart(2, "0");
+    return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}`;
+}

package/dist/server/server-context.d.ts

@@ -42,6 +42,14 @@ export interface ServerContext {
     web?: import("./web.js").WebService;
     /** The agent-facing document tools. Optional so the server can start without them. */
     documentService?: import("./application/document-service.js").DocumentService;
+    /**
+     * THE FEISHU TOOLS.
+     *
+     * Optional because the credential may be missing, not because the feature may be missing: the
+     * service is always constructed, and a call made before the credential is configured is refused
+     * with the message that says what to do - which a missing service could not say.
+     */
+    feishu?: import("./application/feishu-service.js").FeishuService;
     paths: ServerPaths;
     store: Store;
     runtime: AgentRuntime;
@@ -55,6 +63,14 @@ export interface ServerContext {
     catalogService: CatalogService;
     /** The providers a person added through the settings window. */
     providerService: ProviderService;
+    /**
+     * The scheduled tasks and the clock behind them.
+     *
+     * In the context because TWO layers need it: the command handler routes the panel's five commands
+     * into it, and the HTTP layer exposes the agent-facing endpoint that lets a running turn create a
+     * task of its own.
+     */
+    scheduledTaskService?: import("./application/scheduled-task-service.js").ScheduledTaskService;
     execService: ExecService;
     toolRegistry: ToolRegistry;
     toolRunner: ToolRunner;

package/dist/server/store.d.ts

@@ -1,5 +1,6 @@
 import type { AppStateRepository } from "./persistence/app-state-repository.js";
 import { defaultJsonStatePath } from "./persistence/json-state-repository.js";
+import type { ScheduledTask } from "./scheduled-tasks.js";
 import type { WorkflowRun } from "./workflow.js";
 import type { AppState, Conversation, Message, MessageDelivery, MessageImage, ModelSelection, SubagentRun, SubagentRunUpdate, TodoItem, ToolCallQuestion, ToolCallArg, ToolCallBlock, ToolResultSummary, Workspace } from "./types.js";
 /** Mints the id a forked conversation will have, BEFORE its Pi transcript exists.
@@ -45,6 +46,14 @@ export declare const SUBAGENT_RUN_RETENTION = 100;
  * request that needed several specialists rather than a unit of work.
  */
 export declare const WORKFLOW_RETENTION = 50;
+/**
+ * How many scheduled tasks are kept.
+ *
+ * A task is a standing arrangement, not a record of something that happened, so the bound here is much
+ * looser than the run retention: a person who keeps a daily task for a year has one task, and the
+ * hundredth is already a sign that the list is being used as a log rather than as a list of intentions.
+ */
+export declare const SCHEDULED_TASK_RETENTION = 100;
 /**
  * Everything a revert decided, before anything is changed.
  *
@@ -688,6 +697,27 @@ export declare class Store {
     setBackgroundTask(summary: AppState["backgroundTasks"][number]): Promise<void>;
     removeBackgroundTask(id: string): Promise<void>;
     clearBackgroundTasks(): Promise<void>;
+    /**
+     * Writes a scheduled task - new or changed - and persists it.
+     *
+     * ONE METHOD FOR BOTH, because the two are the same write. A task that has not run and a task that
+     * has run are the same kind of thing with different field values, and splitting them into
+     * "create" and "update" would leave the caller to decide which of two paths a given change takes -
+     * which is exactly the kind of decision that ends up made twice, differently, in two places.
+     *
+     * The value is cloned on the way in and on the way out, like every other store method that hands a
+     * record back: the caller mutates its own copy freely, and the copy on disk is the copy that was
+     * written.
+     */
+    setScheduledTask(task: ScheduledTask): Promise<ScheduledTask>;
+    /**
+     * Removes a scheduled task, and persists the removal.
+     *
+     * AN EMPTY LIST IS STORED AS ABSENCE, for the same reason `setTodos` stores an empty todo list as
+     * the absence of the key: a state file that says "scheduledTasks: []" claims the user considered a
+     * schedule and found none, and a fresh install has never considered anything.
+     */
+    removeScheduledTask(id: string): Promise<void>;
     /**
      * Applies the fields a run's life can change, and nothing else.
      *

package/dist/server/store.js

@@ -245,6 +245,27 @@ function trimWorkflows(workflows) {
     }
     workflows.splice(0, workflows.length, ...workflows.filter((plan) => !doomed.has(plan.id)));
 }
+/**
+ * How many scheduled tasks are kept.
+ *
+ * A task is a standing arrangement, not a record of something that happened, so the bound here is much
+ * looser than the run retention: a person who keeps a daily task for a year has one task, and the
+ * hundredth is already a sign that the list is being used as a log rather than as a list of intentions.
+ */
+export const SCHEDULED_TASK_RETENTION = 100;
+/** Evicts the OLDEST scheduled tasks once there are more than `SCHEDULED_TASK_RETENTION`. */
+function trimScheduledTasks(tasks) {
+    const excess = tasks.length - SCHEDULED_TASK_RETENTION;
+    if (excess <= 0)
+        return;
+    const doomed = new Set();
+    for (const task of [...tasks].sort((a, b) => a.createdAt - b.createdAt)) {
+        if (doomed.size >= excess)
+            break;
+        doomed.add(task.id);
+    }
+    tasks.splice(0, tasks.length, ...tasks.filter((task) => !doomed.has(task.id)));
+}
 /**
  * Why a plan the previous process left `running` is stopped rather than resumed, in the same spirit and
  * for the same audience as `ORPHANED_RUN_ERROR`.
@@ -576,9 +597,15 @@ export class Store {
             // it is repaired again on every single boot - and until it is, anything reading the file sees the
             // un-normalised shape rather than the one the store is actually running on.
             const defaulted = ["workspaces", "conversations", "subagentRuns"].filter((key) => !Array.isArray(state[key])).length > 0
-                || !Array.isArray(state.backgroundTasks);
+                || !Array.isArray(state.backgroundTasks)
+                || (state.scheduledTasks !== undefined && !Array.isArray(state.scheduledTasks));
             if (!Array.isArray(state.backgroundTasks))
                 state.backgroundTasks = [];
+            // A scheduled-task list that is not a list is not a list of tasks. The key is dropped rather than
+            // coerced, so a corrupted file reads as "this install has no scheduled tasks" - the same thing a
+            // fresh install reads - instead of crashing the panel on every poll.
+            if (state.scheduledTasks !== undefined && !Array.isArray(state.scheduledTasks))
+                delete state.scheduledTasks;
             // Every sweep runs before the store is constructed, so a single persist below publishes them together.
             // Reconciling them in separate writes would put a file on disk in which one kind of orphan was fixed
             // and the other was not - a half-repaired state that still needs a second restart to finish.
@@ -1970,6 +1997,50 @@ export class Store {
         this.state.backgroundTasks = [];
         await this.persistCollections("backgroundTasks");
     }
+    /**
+     * Writes a scheduled task - new or changed - and persists it.
+     *
+     * ONE METHOD FOR BOTH, because the two are the same write. A task that has not run and a task that
+     * has run are the same kind of thing with different field values, and splitting them into
+     * "create" and "update" would leave the caller to decide which of two paths a given change takes -
+     * which is exactly the kind of decision that ends up made twice, differently, in two places.
+     *
+     * The value is cloned on the way in and on the way out, like every other store method that hands a
+     * record back: the caller mutates its own copy freely, and the copy on disk is the copy that was
+     * written.
+     */
+    async setScheduledTask(task) {
+        if (!this.state.scheduledTasks)
+            this.state.scheduledTasks = [];
+        const stored = structuredClone(task);
+        const index = this.state.scheduledTasks.findIndex((item) => item?.id === stored.id);
+        if (index < 0)
+            this.state.scheduledTasks.push(stored);
+        else
+            this.state.scheduledTasks[index] = stored;
+        trimScheduledTasks(this.state.scheduledTasks);
+        await this.persistCollections("scheduledTasks");
+        return structuredClone(stored);
+    }
+    /**
+     * Removes a scheduled task, and persists the removal.
+     *
+     * AN EMPTY LIST IS STORED AS ABSENCE, for the same reason `setTodos` stores an empty todo list as
+     * the absence of the key: a state file that says "scheduledTasks: []" claims the user considered a
+     * schedule and found none, and a fresh install has never considered anything.
+     */
+    async removeScheduledTask(id) {
+        if (!this.state.scheduledTasks)
+            return;
+        const remaining = this.state.scheduledTasks.filter((item) => item?.id !== id);
+        if (remaining.length === this.state.scheduledTasks.length)
+            return;
+        if (remaining.length)
+            this.state.scheduledTasks = remaining;
+        else
+            delete this.state.scheduledTasks;
+        await this.persistCollections("scheduledTasks");
+    }
     /**
      * Applies the fields a run's life can change, and nothing else.
      *
@@ -2063,7 +2134,15 @@ export class Store {
             await this.persist();
     }
     async persistCollections(key) {
-        await this.persistTransaction({ kind: "collections.replace", values: { [key]: structuredClone(this.state[key]) } });
+        const value = this.state[key];
+        // A collection that is EMPTY is absent from the state, and an absent collection has no row to
+        // write. The row is removed instead, because a repository that can only write rows would have to
+        // store `[]` - which is a different claim from "the user never made one".
+        if (value === undefined) {
+            await this.persistTransaction({ kind: "collections.remove", name: key });
+            return;
+        }
+        await this.persistTransaction({ kind: "collections.replace", values: { [key]: structuredClone(value) } });
     }
     async persistMetadata(conversationId) {
         const { messages: _messages, ...metadata } = this.requireConversation(conversationId);

package/dist/server/task-tool.d.ts

@@ -173,6 +173,24 @@ export declare const TODO_TOOL_NAME = "todowrite";
  * tool then refuses in words instead of posting somewhere that does not exist.
  */
 export declare const TODO_ENDPOINT_ENV = "SUPER_PI_TODO_ENDPOINT";
+/**
+ * The name the model calls to manage the SCHEDULED TASKS.
+ *
+ * `scheduled_task`, with an underscore, because this is not one of OpenCode's tools and there is no
+ * prior name to match. The name says what it is: a task that runs on a schedule.
+ */
+export declare const SCHEDULED_TASK_TOOL_NAME = "scheduled_task";
+/**
+ * The endpoint the `scheduled_task` tool dials. Another name in the same wire, written out on both
+ * sides for the same reason `TODO_ENDPOINT_ENV` states: `agents/super-pi-task/core.ts` is loaded by
+ * Pi's module loader and this file by tsc, so the two copies have to agree by hand -
+ * `scripts/scheduled-task-tool.test.mjs` asserts that they do.
+ *
+ * A SEPARATE variable rather than a path derived from `TODO_ENDPOINT_ENV`, for the reason that one
+ * states: a Pi can legitimately have one and not the other, and a derived path could not tell those
+ * apart from a misconfiguration.
+ */
+export declare const SCHEDULED_TASK_ENDPOINT_ENV = "SUPER_PI_SCHEDULED_TASK_ENDPOINT";
 /**
  * How many todos may be stored, and how long one may be.
  *

package/dist/server/task-tool.js

@@ -230,6 +230,24 @@ export const TODO_TOOL_NAME = "todowrite";
  * tool then refuses in words instead of posting somewhere that does not exist.
  */
 export const TODO_ENDPOINT_ENV = "SUPER_PI_TODO_ENDPOINT";
+/**
+ * The name the model calls to manage the SCHEDULED TASKS.
+ *
+ * `scheduled_task`, with an underscore, because this is not one of OpenCode's tools and there is no
+ * prior name to match. The name says what it is: a task that runs on a schedule.
+ */
+export const SCHEDULED_TASK_TOOL_NAME = "scheduled_task";
+/**
+ * The endpoint the `scheduled_task` tool dials. Another name in the same wire, written out on both
+ * sides for the same reason `TODO_ENDPOINT_ENV` states: `agents/super-pi-task/core.ts` is loaded by
+ * Pi's module loader and this file by tsc, so the two copies have to agree by hand -
+ * `scripts/scheduled-task-tool.test.mjs` asserts that they do.
+ *
+ * A SEPARATE variable rather than a path derived from `TODO_ENDPOINT_ENV`, for the reason that one
+ * states: a Pi can legitimately have one and not the other, and a derived path could not tell those
+ * apart from a misconfiguration.
+ */
+export const SCHEDULED_TASK_ENDPOINT_ENV = "SUPER_PI_SCHEDULED_TASK_ENDPOINT";
 /**
  * How many todos may be stored, and how long one may be.
  *

package/dist/server/types.d.ts

@@ -5,6 +5,7 @@ export type ModelFilterRule = {
     label?: string;
 };
 import type { WorkflowRun } from "./workflow.js";
+import type { ScheduledTask } from "./scheduled-tasks.js";
 /**
  * The lifecycle states a `Conversation.status` moves through while a turn is in flight. `waiting` is the
  * gap between "prompt handed to the LLM" and "the first response token arrived" - holding it apart from
@@ -835,6 +836,7 @@ export type AppState = {
     backgroundTasks: BackgroundTaskSummary[];
     todosByConversation?: Record<string, TodoItem[]>;
     workflows?: WorkflowRun[];
+    scheduledTasks?: ScheduledTask[];
     customAgentDirs?: string[];
 };
 export type TodoItem = {
@@ -1372,6 +1374,60 @@ export type ClientCommandBody =
 /** Restarts the Super Pi server by spawning the same restart script used by the auto-updater. */
  | {
     type: "super_pi.restart";
+}
+/**
+ * A scheduled task is created.
+ *
+ * The schedule arrives as an opaque value and is validated on the SERVER, in the one place that owns
+ * what a schedule means. The browser cannot send a half-valid schedule, because it does not know
+ * what a half-valid schedule is; it sends the fields the panel collected and the server decides
+ * whether they describe a schedule.
+ */
+ | {
+    type: "scheduledTask.create";
+    name?: string;
+    prompt: string;
+    schedule: unknown;
+    workspaceId: string;
+    model?: ModelSelection | null;
+    agentId?: string | null;
+}
+/**
+ * A scheduled task is changed. Every field is optional, and the ones that are absent are the ones
+ * that do not change - a panel that sends the whole task back would fight the scheduler's own
+ * bookkeeping over `nextRunAt`, which is not the panel's to write.
+ */
+ | {
+    type: "scheduledTask.update";
+    id: string;
+    name?: string;
+    prompt?: string;
+    schedule?: unknown;
+    model?: ModelSelection | null;
+    agentId?: string | null;
+}
+/** A scheduled task is removed. Its conversation and the answers it produced stay. */
+ | {
+    type: "scheduledTask.delete";
+    id: string;
+}
+/**
+ * A scheduled task runs NOW, once, without touching its schedule.
+ *
+ * It is a separate command rather than a flag on `update` because it is a different act: `update`
+ * changes what the task IS, and this changes what the task DID. The one thing it shares with the
+ * clock is the run itself - it goes through the same path, so a manual run and a scheduled run
+ * behave identically.
+ */
+ | {
+    type: "scheduledTask.trigger";
+    id: string;
+}
+/** A scheduled task is turned on or off. */
+ | {
+    type: "scheduledTask.toggle";
+    id: string;
+    enabled: boolean;
 } | ({
     type: "extension.ui.answer";
     conversationId: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evandu/super-pi",
-  "version": "0.1.131",
+  "version": "0.1.132",
   "description": "Web control plane and companion for Pi",
   "license": "MIT",
   "type": "module",
@@ -39,9 +39,11 @@
     "start": "node dist/server/index.js",
     "restart:server": "node scripts/restart-server.mjs",
     "smoke": "npm run build && node scripts/smoke.mjs",
-    "check": "node scripts/run-check.mjs"
+    "check": "node scripts/run-check.mjs",
+    "test": "node scripts/test.mjs"
   },
   "check:logic": [
+    "scripts/test-runner.test.mjs",
     "scripts/stream-checkpoint.test.mjs",
     "scripts/stream-transport.test.mjs",
     "scripts/inline-thinking.test.mjs",
@@ -104,6 +106,7 @@
     "scripts/file-content-search.test.mjs",
     "scripts/file-diff-client.test.mjs",
     "scripts/editor-languages.test.mjs",
+    "scripts/editor-blame.test.mjs",
     "scripts/task-tool.test.mjs",
     "scripts/tool-register-env.test.mjs",
     "scripts/bg-task-zombie.test.mjs",
@@ -122,6 +125,8 @@
     "scripts/provider-pi-reads.test.mjs",
     "scripts/active-memory.test.mjs",
     "scripts/knowledge-base.test.mjs",
+    "scripts/knowledge-import-path.test.mjs",
+    "scripts/knowledge-import-identity.test.mjs",
     "scripts/tool-runner.test.mjs",
     "scripts/tool-runtime-api.test.mjs",
     "scripts/tool-sharing.test.mjs",
@@ -142,7 +147,11 @@
     "scripts/web-tools.test.mjs",
     "scripts/document-service.test.mjs",
     "scripts/document-block-parse.test.mjs",
-    "scripts/document-write-overwrite.test.mjs"
+    "scripts/document-write-overwrite.test.mjs",
+    "scripts/feishu.test.mjs",
+    "scripts/scheduled-tasks.test.mjs",
+    "scripts/scheduled-task-scope.test.mjs",
+    "scripts/scheduled-task-tool.test.mjs"
   ],
   "check:browser": [
     "scripts/interrupt-browser.test.mjs",
@@ -159,6 +168,7 @@
     "scripts/session-state-animation-browser.test.mjs",
     "scripts/agent-vis-card-browser.test.mjs",
     "scripts/queue-dock.test.mjs",
+    "scripts/scheduled-tasks-browser.test.mjs",
     "scripts/md-render-browser.test.mjs",
     "scripts/right-sidebar-browser.test.mjs",
     "scripts/sidebar-tools-browser.test.mjs",
@@ -166,6 +176,8 @@
     "scripts/session-context-menu-browser.test.mjs",
     "scripts/tool-call-blocks-browser.test.mjs",
     "scripts/files-tab-browser.test.mjs",
+    "scripts/editor-blame-browser.test.mjs",
+    "scripts/file-panel-external-poll-browser.test.mjs",
     "scripts/file-quickopen-browser.test.mjs",
     "scripts/file-content-search-browser.test.mjs",
     "scripts/file-changes-browser.test.mjs",
@@ -193,7 +205,8 @@
     "scripts/terminal-browser.test.mjs",
     "scripts/ux-polish-browser.test.mjs",
     "scripts/prompt-templates-browser.test.mjs",
-    "scripts/documents-browser.test.mjs"
+    "scripts/documents-browser.test.mjs",
+    "scripts/feishu-browser.test.mjs"
   ],
   "dependencies": {
     "@codemirror/commands": "^6.11.1",

package/dist/.super-pi-check-inputs.json

@@ -1,4 +0,0 @@
-{
-  "hash": "c85d384e9aa3d19ca66ffeaca847b723d939758d9bc25a1a02c4a4cac080f7b5",
-  "recordedAt": "2026-10-24T12:39:29.727Z"
-}