@chainingintention/pi-web-cn 2.202610.5 → 2.202611.2

package/dist/pi-packages/scheduled-tasks/service.js

@@ -0,0 +1,178 @@
+// Generated from pi-packages/scheduled-tasks/service.ts. Do not edit directly.
+import { THINKING_LEVELS, text, validateTask } from "./domain.js";
+/** Transport-independent operations shared by the companion and read-only dashboard. */
+export class TaskService {
+    store;
+    scheduler;
+    validateTarget;
+    defaultTimezone;
+    now;
+    catalog;
+    constructor(store, scheduler, validateTarget, defaultTimezone, now, catalog) {
+        this.store = store;
+        this.scheduler = scheduler;
+        this.validateTarget = validateTarget;
+        this.defaultTimezone = defaultTimezone;
+        this.now = now;
+        this.catalog = catalog;
+    }
+    async request(operation, input, signal) {
+        const args = object(input ?? {});
+        switch (operation) {
+            case "targets": {
+                only(args, ["projectId"]);
+                const options = signal === undefined ? {} : { signal };
+                return args["projectId"] === undefined
+                    ? { projects: await this.catalog.projects.list(options) }
+                    : { workspaces: await this.catalog.workspaces.list(identifier(args, "projectId"), options) };
+            }
+            case "overview":
+                only(args, []);
+                return { defaultTimezone: this.defaultTimezone ?? null, tasks: this.store.listTasks().map((task) => ({
+                        ...taskSummary(task), latestExecution: executionSummary(this.store.executions(task.id, 1)[0]),
+                    })) };
+            case "inspect": {
+                only(args, ["taskId"]);
+                const id = identifier(args, "taskId");
+                return this.store.task(id);
+            }
+            case "history": {
+                only(args, ["taskId", "limit", "offset"]);
+                const taskId = args["taskId"] === undefined ? undefined : identifier(args, "taskId");
+                const limit = pageInteger(args["limit"] ?? 20, "limit", 1, 50);
+                const offset = pageInteger(args["offset"] ?? 0, "offset", 0, Number.MAX_SAFE_INTEGER);
+                const rows = this.store.executions(taskId, limit + 1, offset);
+                return { executions: rows.slice(0, limit).map(executionSummary), nextOffset: rows.length > limit ? offset + limit : null };
+            }
+            case "execution":
+                only(args, ["executionId"]);
+                return this.store.execution(identifier(args, "executionId"));
+            case "create": {
+                const task = parseDefinition(args, this.defaultTimezone, this.now());
+                await this.validateTarget(task);
+                return this.store.create(task, this.now());
+            }
+            case "update": {
+                only(args, ["taskId", "revision", "definition"]);
+                const task = parseDefinition(object(args["definition"]), this.defaultTimezone, this.now());
+                await this.validateTarget(task);
+                return this.store.update(identifier(args, "taskId"), revision(args), task, this.now());
+            }
+            case "pause":
+                only(args, ["taskId", "revision", "paused"]);
+                if (typeof args["paused"] !== "boolean")
+                    throw new Error("paused must be a boolean");
+                return this.store.setPaused(identifier(args, "taskId"), revision(args), args["paused"], this.now());
+            case "archive":
+                only(args, ["taskId", "revision"]);
+                return this.store.archive(identifier(args, "taskId"), revision(args), this.now());
+            case "delete":
+                only(args, ["taskId", "revision"]);
+                return this.scheduler.deleteTask(identifier(args, "taskId"), revision(args));
+            case "dispatch":
+                only(args, ["taskId"]);
+                return this.scheduler.dispatchManually(identifier(args, "taskId"));
+            case "report":
+                only(args, ["executionId", "outcome", "summary"]);
+                return this.store.report(identifier(args, "executionId"), text(args["outcome"], "outcome", 32), text(args["summary"], "summary", 16 * 1024), this.now());
+            default: throw new Error("Unknown scheduled tasks operation");
+        }
+    }
+}
+export function configuredTimezone(value) {
+    if (value === undefined)
+        return undefined;
+    const timezone = text(value, "defaultTimezone", 256);
+    new Intl.DateTimeFormat("en", { timeZone: timezone }).format();
+    return timezone;
+}
+function parseDefinition(args, defaultTimezone, now) {
+    only(args, ["name", "projectId", "workspaceId", "prompt", "timezone", "schedule", "contextPaths", "model", "thinkingLevel"]);
+    const timezone = args["timezone"] === undefined ? defaultTimezone : args["timezone"];
+    if (timezone === undefined)
+        throw new Error("No default timezone is configured. Ask the user for a timezone before creating or rescheduling a task.");
+    const schedule = object(args["schedule"]);
+    let parsedSchedule;
+    if (schedule["kind"] === "once") {
+        only(schedule, ["kind", "at"]);
+        parsedSchedule = { kind: "once", at: text(schedule["at"], "at", 256) };
+    }
+    else if (schedule["kind"] === "cron") {
+        only(schedule, ["kind", "expression"]);
+        parsedSchedule = { kind: "cron", expression: text(schedule["expression"], "expression", 256) };
+    }
+    else
+        throw new Error("Schedule kind must be once or cron");
+    const paths = args["contextPaths"] ?? [];
+    if (!Array.isArray(paths))
+        throw new Error("contextPaths must be an array");
+    return validateTask({
+        name: text(args["name"], "name", 512), projectId: identifier(args, "projectId"), workspaceId: identifier(args, "workspaceId"),
+        prompt: text(args["prompt"], "prompt", 48 * 1024), timezone: text(timezone, "timezone", 256),
+        schedule: parsedSchedule, contextPaths: paths.map((path) => text(path, "context path", 1024)),
+        ...(args["model"] === undefined ? {} : { model: text(args["model"], "model", 512) }),
+        ...(args["thinkingLevel"] === undefined ? {} : { thinkingLevel: parseThinkingLevel(args["thinkingLevel"]) }),
+    }, now);
+}
+function parseThinkingLevel(value) {
+    const level = THINKING_LEVELS.find((candidate) => candidate === value);
+    if (level === undefined)
+        throw new Error("Invalid thinkingLevel");
+    return level;
+}
+function object(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        throw new Error("Expected an input object");
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- Narrowed JSON transport object.
+    return value;
+}
+function only(args, allowed) {
+    if (Object.keys(args).some((key) => !allowed.includes(key)))
+        throw new Error("Unexpected input field");
+}
+function identifier(args, key) { return text(args[key], key, 512); }
+function revision(args) {
+    const value = args["revision"];
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1)
+        throw new Error("Expected a positive task revision");
+    return value;
+}
+function pageInteger(value, label, min, max) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < min || value > max) {
+        throw new Error(`${label} must be an integer from ${String(min)} to ${String(max)}`);
+    }
+    return value;
+}
+function taskSummary(task) {
+    return {
+        id: task.id, name: task.name, revision: task.revision, projectId: task.projectId, workspaceId: task.workspaceId,
+        schedule: task.schedule, timezone: task.timezone, paused: task.paused, archived: task.archived, nextDue: task.nextDue,
+        ...(task.model === undefined ? {} : { model: task.model }),
+        ...(task.thinkingLevel === undefined ? {} : { thinkingLevel: task.thinkingLevel }),
+    };
+}
+function executionSummary(execution) {
+    if (execution === undefined)
+        return null;
+    return {
+        id: execution.id, taskId: execution.taskId, task: taskSummary(execution.task), trigger: execution.trigger,
+        dueAt: execution.dueAt, createdAt: execution.createdAt, status: execution.status, sessionId: execution.sessionId,
+        dispatchError: execution.dispatchError, latestReport: execution.reports.at(-1) ?? null, notices: execution.notices,
+        ...(execution.model === undefined ? {} : { model: execution.model }),
+        ...(execution.thinkingLevel === undefined ? {} : { thinkingLevel: execution.thinkingLevel }),
+    };
+}
+/** Instructions are attributed in the ordinary initial message, not inferred from session activity. */
+export function dispatchPrompt(execution) {
+    return [
+        "This conversation was dispatched by the Scheduled agent tasks plugin.",
+        `Task ID: ${execution.taskId}; execution ID: ${execution.id}; task revision: ${String(execution.task.revision)}.`,
+        "Discover scheduled_tasks tools through tool_search or codemode searchTools. Retrieve this execution's context with scheduled_tasks_execution.",
+        "After doing the work, use scheduled_tasks_report to explicitly report completed or errored with a summary for this execution ID. You may correct an earlier report; reports never stop the conversation.",
+        "You have the same task-management authority as an ordinary session. Do not infer an execution outcome from session activity.",
+        ...(execution.task.contextPaths.length === 0 ? [] : [
+            `Read these workspace-relative shared context files before starting (their contents may have changed): ${JSON.stringify(execution.task.contextPaths)}`,
+        ]),
+        "", "Task instructions:", execution.task.prompt,
+    ].join("\n");
+}

package/dist/pi-packages/scheduled-tasks/skills/scheduled-tasks/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: scheduled-tasks
+description: Schedule agent work for later, create or change recurring tasks, pause or resume future scheduling, inspect task execution history, or explicitly report an outcome from a task-dispatched conversation in PI WEB.
+---
+
+# Scheduled agent tasks
+
+Discover the deferred `scheduled_tasks` tools with `tool_search` or codemode `searchTools`. Use `describeNamespace("scheduled_tasks")` for guidance and inspect each tool's schema before calling it. These tools require this package's enabled PI WEB backend on the session's machine; they do not use the browser's selected machine.
+
+- Start with `scheduled_tasks_overview` for tasks and the configured default timezone. Use `scheduled_tasks_targets` to list registered projects, then supply a project ID to list its workspaces. Do not substitute filesystem paths for IDs.
+- Translate the user's request into an initial prompt and either a one-off offset-bearing ISO timestamp or a five-field cron schedule. Store an explicit IANA timezone. If the user omitted it, use the configured default; if there is no default, ask rather than guessing. Resolve material schedule ambiguity before creating a task.
+- Preserve intent; do not plan execution. Task creation is transcription plus scheduling, not task execution or investigation. Keep the prompt close to the user's request. Do not add goals, deliverables, obligations, workflows, assessment criteria, limits, tools, files, documentation references, or other implementation choices unless the user explicitly requested them. Leave investigation and execution decisions to the dispatched agent. Ask before making assumptions that materially change the work.
+- Set optional `model` (provider/model ID) and `thinkingLevel` (`off`, `minimal`, `low`, `medium`, `high`, `xhigh`, `max`) only when requested. Omit either independently to use the session default. If the model is unavailable at dispatch, the scheduler falls back to the default model and records an execution notice. Unavailable thinking levels similarly fall back to the session default, with a notice. Inspect execution notices and effective selections in history or execution details. Do not remove or rewrite the requested task settings because one execution fell back.
+- Populate optional `contextPaths` only when the user explicitly asks to include files. Paths are workspace-relative; the dispatched agent reads their current contents, not snapshots.
+- Before creating a task or updating its definition, show the proposed name, exact prompt, schedule, timezone, target project/workspace, any context paths, and any model/thinking overrides; for updates, highlight what changes. Use `ask_user` to request explicit confirmation and wait for the answer before calling `scheduled_tasks_create` or `scheduled_tasks_update`. The initial request to schedule or change work is not confirmation of the proposed definition. Request confirmation again if substantive changes follow confirmation; harmless formatting or normalization that preserves meaning does not require renewed confirmation.
+- Inspect before edits. `scheduled_tasks_update` replaces the full definition and requires its current revision; preserve unchanged fields. Pause/resume, archive, and delete also require the current revision. A stale revision means inspect again, not overwrite blindly.
+- Pausing affects future scheduled dispatches only. Archiving also prevents manual dispatch. Neither affects existing conversations. A recurring task dispatches each occurrence independently, even when earlier executions have no outcome report.
+- `scheduled_tasks_delete` permanently removes an archived task, all definition revisions, execution records, and outcome reports. Reject deletion of a task that is not archived; archive it first and inspect its new revision before deleting. Existing conversations and transcripts are neither deleted nor stopped. Deletion rejects while a dispatch is still being admitted; wait and inspect again before retrying. Deleted executions no longer accept outcome reports.
+- Manual dispatch starts a normal independent conversation without consuming the next scheduled occurrence. Inspect history after a failed or uncertain launch; never blindly retry an ambiguous dispatch. There are no automatic retries after an uncertain launch; model/thinking fallback happens only after a typed rejection confirming that no initial prompt was submitted.
+- Use `scheduled_tasks_history` for paged records and `scheduled_tasks_execution` for the exact dispatched task revision, prompt, context references, conversation ID, requested and effective model/thinking selections, dispatch notices and all outcome corrections.
+
+## When dispatched from a task
+
+The initial message identifies your task and execution IDs. Retrieve your context with `scheduled_tasks_execution`, read any shared files, then do the requested work. You have the same task-management authority as any ordinary session; no extra plugin-specific approval applies.
+
+Explicitly call `scheduled_tasks_report` with your execution ID, `completed` or `errored`, and a useful summary when you have an outcome. You may correct an earlier report; all reports remain in history. If you are still working or waiting for an answer, leave the execution dispatched. Session idle/error/close signals do not determine its outcome. Reporting does not stop your conversation or disable future occurrences.
+
+## Availability
+
+The scheduler runs while its owning daemon is running, without a browser. It cannot wake the machine. After downtime it skips missed recurring occurrences and dispatches an overdue one-off once. Disabling the plugin stops future dispatches and preserves its SQLite tasks/history and existing conversations.

package/dist/pi-packages/scheduled-tasks/sqlite.js

@@ -0,0 +1,18 @@
+// Generated from pi-packages/scheduled-tasks/sqlite.ts. Do not edit directly.
+import { createRequire } from "node:module";
+/** Both supported runtimes provide SQLite; no native npm addon or external service is needed. */
+export function openSqlite(path) {
+    const require = createRequire(import.meta.url);
+    const bun = process.versions["bun"] !== undefined;
+    const loaded = require(bun ? "bun:sqlite" : "node:sqlite");
+    const name = bun ? "Database" : "DatabaseSync";
+    if (!isSqliteModule(loaded, name))
+        throw new Error("Runtime does not provide SQLite");
+    const Database = loaded[name];
+    if (Database === undefined)
+        throw new Error("SQLite constructor unavailable");
+    return new Database(path);
+}
+function isSqliteModule(value, name) {
+    return typeof value === "object" && value !== null && typeof Reflect.get(value, name) === "function";
+}

package/dist/pi-packages/scheduled-tasks/store.js

@@ -0,0 +1,230 @@
+// Generated from pi-packages/scheduled-tasks/store.ts. Do not edit directly.
+import { randomUUID } from "node:crypto";
+import { nextOccurrence, text, validateTask } from "./domain.js";
+import { openSqlite } from "./sqlite.js";
+/** The daemon activation owns one store. Every multi-record mutation is a local SQLite transaction. */
+export class TaskStore {
+    db;
+    id;
+    constructor(db, id = randomUUID) {
+        this.db = db;
+        this.id = id;
+        db.exec("PRAGMA foreign_keys = ON; PRAGMA journal_mode = WAL; PRAGMA busy_timeout = 5000;");
+        const version = db.prepare("PRAGMA user_version").get()?.["user_version"];
+        if (version !== 0 && version !== 1)
+            throw new Error("Unsupported scheduled tasks database version");
+        if (version === 0)
+            this.transaction(() => {
+                db.exec(`
+        CREATE TABLE tasks (id TEXT PRIMARY KEY, body TEXT NOT NULL);
+        CREATE TABLE revisions (
+          task_id TEXT NOT NULL REFERENCES tasks(id), revision INTEGER NOT NULL, body TEXT NOT NULL,
+          PRIMARY KEY (task_id, revision)
+        );
+        CREATE TABLE executions (
+          id TEXT PRIMARY KEY, task_id TEXT NOT NULL REFERENCES tasks(id),
+          occurrence TEXT UNIQUE, body TEXT NOT NULL
+        );
+        CREATE INDEX executions_task ON executions(task_id);
+        PRAGMA user_version = 1;
+      `);
+            });
+    }
+    static open(path) {
+        const db = openSqlite(path);
+        try {
+            return new TaskStore(db);
+        }
+        catch (error) {
+            db.close();
+            throw error;
+        }
+    }
+    close() { this.db.close(); }
+    listTasks() {
+        return this.db.prepare("SELECT body FROM tasks ORDER BY id").all().map((row) => decode(row));
+    }
+    task(id) {
+        const row = this.db.prepare("SELECT body FROM tasks WHERE id = ?").get(id);
+        if (row === undefined || row === null)
+            throw new Error("Task not found");
+        return decode(row);
+    }
+    revisions(taskId) {
+        return this.db.prepare("SELECT body FROM revisions WHERE task_id = ? ORDER BY revision").all(taskId).map((row) => decode(row));
+    }
+    create(input, now) {
+        const definition = validateTask(input, now);
+        const task = { ...definition, id: this.id(), revision: 1, paused: false, archived: false,
+            nextDue: nextOccurrence(definition, now), createdAt: now, updatedAt: now };
+        return this.transaction(() => {
+            this.db.prepare("INSERT INTO tasks (id, body) VALUES (?, ?)").run(task.id, JSON.stringify(task));
+            this.saveRevision(task);
+            return task;
+        });
+    }
+    update(id, revision, input, now) {
+        const definition = validateTask(input, now);
+        return this.change(id, revision, now, (task) => {
+            const scheduleChanged = JSON.stringify(definition.schedule) !== JSON.stringify(task.schedule) || definition.timezone !== task.timezone;
+            const updated = { ...task, ...definition, nextDue: scheduleChanged ? nextOccurrence(definition, now) : task.nextDue };
+            if (definition.model === undefined)
+                delete updated.model;
+            if (definition.thinkingLevel === undefined)
+                delete updated.thinkingLevel;
+            return updated;
+        });
+    }
+    setPaused(id, revision, paused, now) {
+        return this.change(id, revision, now, (task) => ({ ...task, paused,
+            nextDue: !paused && task.schedule.kind === "cron" ? nextOccurrence(task, now) : task.nextDue }));
+    }
+    archive(id, revision, now) {
+        return this.change(id, revision, now, (task) => ({ ...task, archived: true, nextDue: null }));
+    }
+    delete(id, revision) {
+        this.transaction(() => {
+            const task = this.task(id);
+            if (task.revision !== revision)
+                throw new Error("Task revision conflict; inspect the current task before deleting");
+            if (!task.archived)
+                throw new Error("Only archived tasks can be deleted; archive the task first");
+            this.db.prepare("DELETE FROM executions WHERE task_id = ?").run(id);
+            this.db.prepare("DELETE FROM revisions WHERE task_id = ?").run(id);
+            this.db.prepare("DELETE FROM tasks WHERE id = ?").run(id);
+        });
+    }
+    change(id, revision, now, change) {
+        return this.transaction(() => {
+            const old = this.task(id);
+            if (old.revision !== revision)
+                throw new Error("Task revision conflict; inspect the current task before editing");
+            if (old.archived)
+                throw new Error("Archived tasks cannot be modified");
+            const task = { ...change(old), revision: old.revision + 1, updatedAt: now };
+            this.saveTask(task);
+            this.saveRevision(task);
+            return task;
+        });
+    }
+    executions(taskId, limit = -1, offset = 0) {
+        const rows = taskId === undefined
+            ? this.db.prepare("SELECT body FROM executions ORDER BY rowid DESC LIMIT ? OFFSET ?").all(limit, offset)
+            : this.db.prepare("SELECT body FROM executions WHERE task_id = ? ORDER BY rowid DESC LIMIT ? OFFSET ?").all(taskId, limit, offset);
+        return rows.map(decodeExecution);
+    }
+    execution(id) {
+        const row = this.db.prepare("SELECT body FROM executions WHERE id = ?").get(id);
+        if (row === undefined || row === null)
+            throw new Error("Execution not found");
+        return decodeExecution(row);
+    }
+    /** Called once before starting scheduling. Never retries an interrupted launch. */
+    recover(now) {
+        this.transaction(() => {
+            for (const execution of this.executions()) {
+                if (execution.status === "dispatching") {
+                    this.saveExecution({ ...execution, status: "uncertain", dispatchError: "Daemon stopped before dispatch confirmation; not automatically retried" });
+                }
+            }
+            // Recurrences missed while stopped are skipped; overdue one-offs retain their due time.
+            for (const task of this.listTasks()) {
+                if (!task.archived && task.schedule.kind === "cron")
+                    this.saveTask({ ...task, nextDue: nextOccurrence(task, now) });
+            }
+        });
+    }
+    /** Durable reservation precedes all session side effects. A one-off is consumed even if launch fails. */
+    claim(taskId, trigger, now) {
+        return this.transaction(() => {
+            const task = this.task(taskId);
+            if (task.archived)
+                throw new Error("Archived tasks cannot be dispatched");
+            if (trigger === "scheduled" && (task.paused || task.nextDue === null || task.nextDue > now))
+                return null;
+            const dueAt = trigger === "scheduled" ? task.nextDue : now;
+            if (dueAt === null)
+                return null;
+            const occurrence = trigger === "scheduled" ? `${task.id}:${dueAt}` : null;
+            if (occurrence !== null) {
+                const existing = this.db.prepare("SELECT id FROM executions WHERE occurrence = ?").get(occurrence);
+                if (existing !== undefined && existing !== null)
+                    return null;
+            }
+            const execution = { id: this.id(), taskId, task, trigger, dueAt, createdAt: now,
+                status: "dispatching", sessionId: null, dispatchError: null, reports: [], notices: [] };
+            this.db.prepare("INSERT INTO executions (id, task_id, occurrence, body) VALUES (?, ?, ?, ?)")
+                .run(execution.id, taskId, occurrence, JSON.stringify(execution));
+            if (trigger === "scheduled")
+                this.saveTask({ ...task, nextDue: task.schedule.kind === "once" ? null : nextOccurrence(task, now) });
+            return execution;
+        });
+    }
+    recordNotices(id, notices) {
+        return this.mutateExecution(id, (execution) => ({ ...execution,
+            notices: [...execution.notices, ...notices] }));
+    }
+    confirmDispatch(id, sessionId, selection = {}) {
+        text(sessionId, "sessionId", 512);
+        return this.mutateExecution(id, (execution) => ({ ...execution, sessionId,
+            ...(selection.model === undefined ? {} : { model: selection.model }),
+            ...(selection.thinkingLevel === undefined ? {} : { thinkingLevel: selection.thinkingLevel }),
+            notices: [...execution.notices, ...(selection.notices ?? [])],
+            // An agent may explicitly report before the host's initial admission promise resolves.
+            status: execution.reports.length > 0 ? execution.status : "dispatched" }));
+    }
+    dispatchProblem(id, error, certainFailure) {
+        return this.mutateExecution(id, (execution) => ({ ...execution, dispatchError: error,
+            status: execution.reports.length > 0 ? execution.status : certainFailure ? "failed" : "uncertain" }));
+    }
+    report(id, outcome, summary, now) {
+        if (outcome !== "completed" && outcome !== "errored")
+            throw new Error("Unknown outcome");
+        text(summary, "summary", 16 * 1024);
+        return this.mutateExecution(id, (execution) => {
+            if (execution.status === "failed")
+                throw new Error("A rejected dispatch has no execution outcome to report");
+            return { ...execution, status: outcome, reports: [...execution.reports, { at: now, outcome, summary }] };
+        });
+    }
+    mutateExecution(id, mutate) {
+        return this.transaction(() => {
+            const execution = mutate(this.execution(id));
+            this.saveExecution(execution);
+            return execution;
+        });
+    }
+    saveTask(task) {
+        this.db.prepare("UPDATE tasks SET body = ? WHERE id = ?").run(JSON.stringify(task), task.id);
+    }
+    saveRevision(task) {
+        this.db.prepare("INSERT INTO revisions (task_id, revision, body) VALUES (?, ?, ?)").run(task.id, task.revision, JSON.stringify(task));
+    }
+    saveExecution(execution) {
+        this.db.prepare("UPDATE executions SET body = ? WHERE id = ?").run(JSON.stringify(execution), execution.id);
+    }
+    transaction(operation) {
+        this.db.exec("BEGIN IMMEDIATE");
+        try {
+            const value = operation();
+            this.db.exec("COMMIT");
+            return value;
+        }
+        catch (error) {
+            this.db.exec("ROLLBACK");
+            throw error;
+        }
+    }
+}
+function decodeExecution(row) {
+    const execution = decode(row);
+    // Version 1 ledgers predate notices; optional selection fields already represent defaults.
+    return { ...execution, notices: execution.notices ?? [] };
+}
+// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- The store owns the versioned schema and all JSON writes; callers select the table record type.
+function decode(row) {
+    if (typeof row["body"] !== "string")
+        throw new Error("Invalid scheduled tasks database record");
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- Only read plugin-owned records written by this schema version, not transport input.
+    return JSON.parse(row["body"]);
+}

package/dist/pi-packages/scheduled-tasks/vite.browser.config.mjs

@@ -0,0 +1,16 @@
+import { fileURLToPath } from "node:url";
+import { defineConfig } from "vite";
+
+// The browser-public root contains only the self-contained dashboard bundle.
+export default defineConfig({
+  build: {
+    emptyOutDir: true,
+    lib: {
+      entry: fileURLToPath(new URL("./browser/pi-web-plugin.ts", import.meta.url)),
+      formats: ["es"],
+      fileName: () => "pi-web-plugin.js",
+    },
+    target: "es2022",
+    minify: true,
+  },
+});

package/dist/pi-packages/scheduled-tasks/vite.companion.config.mjs

@@ -0,0 +1,17 @@
+import { fileURLToPath } from "node:url";
+import { defineConfig } from "vite";
+
+// Carry the public companion helper, but use Pi\'s host-provided SDK modules.
+export default defineConfig({
+  build: {
+    emptyOutDir: false,
+    lib: {
+      entry: fileURLToPath(new URL("./extensions/index.ts", import.meta.url)),
+      formats: ["es"],
+      fileName: () => "extensions/index.js",
+    },
+    rollupOptions: { external: ["@earendil-works/pi-ai", "@earendil-works/pi-coding-agent"] },
+    target: "es2022",
+    minify: false,
+  },
+});

package/dist/pi-packages/scheduled-tasks/vite.config.mjs

@@ -0,0 +1,17 @@
+import { fileURLToPath } from "node:url";
+import { defineConfig } from "vite";
+
+// Keep the server package installable without a second host or cron-parser copy.
+export default defineConfig({
+  build: {
+    emptyOutDir: false,
+    lib: {
+      entry: fileURLToPath(new URL("./server-plugin.ts", import.meta.url)),
+      formats: ["es"],
+      fileName: () => "server-plugin.js",
+    },
+    rollupOptions: { external: [/^node:/u] },
+    target: "node22",
+    minify: false,
+  },
+});

package/dist/pi-packages/session-naming/config.js

@@ -0,0 +1,78 @@
+// Generated from pi-packages/session-naming/config.ts. Do not edit directly.
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { homedir } from "node:os";
+// Compiled extensions must not resolve a second copy of the Pi SDK just to
+// locate configuration. Pi exposes this profile directory through its public env contract.
+export function sessionNamingAgentDir(env = process.env, home = homedir()) {
+    const configured = env["PI_CODING_AGENT_DIR"];
+    if (configured === undefined || configured === "")
+        return join(home, ".pi", "agent");
+    if (configured === "~")
+        return home;
+    if (configured.startsWith("~/") || configured.startsWith("~\\"))
+        return join(home, configured.slice(2));
+    return configured;
+}
+export function sessionNamingConfigPath(agentDir) {
+    return join(agentDir, "session-naming", "config.json");
+}
+/** Shared by the extension and hosts migrating previously stored tuning. */
+export function parseSessionNamingConfig(value) {
+    if (!isRecord(value)) {
+        throw new Error("Session naming config must be an object");
+    }
+    const record = value;
+    for (const key of Object.keys(record)) {
+        if (!["model", "maxTokens", "thinkingLevel", "timeoutMs"].includes(key)) {
+            throw new Error(`Unknown session naming config field: ${key}`);
+        }
+    }
+    const { model, maxTokens, thinkingLevel, timeoutMs } = record;
+    if (model !== undefined && (typeof model !== "string" || !/^[^/\s]+\/\S+$/.test(model))) {
+        throw new Error("Session naming model must be an exact provider/model-id");
+    }
+    if (maxTokens !== undefined && (typeof maxTokens !== "number" || !Number.isSafeInteger(maxTokens) || maxTokens < 1)) {
+        throw new Error("Session naming maxTokens must be a positive safe integer");
+    }
+    if (thinkingLevel !== undefined && !isThinkingLevel(thinkingLevel)) {
+        throw new Error("Session naming thinkingLevel must be a known thinking level");
+    }
+    if (timeoutMs !== undefined && (typeof timeoutMs !== "number" || !Number.isInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 2_147_483_647)) {
+        throw new Error("Session naming timeoutMs must be an integer from 1 to 2147483647");
+    }
+    return {
+        ...(model !== undefined ? { model } : {}),
+        ...(maxTokens !== undefined ? { maxTokens } : {}),
+        ...(thinkingLevel !== undefined ? { thinkingLevel } : {}),
+        ...(timeoutMs !== undefined ? { timeoutMs } : {}),
+    };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isThinkingLevel(value) {
+    return typeof value === "string" && ["off", "minimal", "low", "medium", "high", "xhigh", "max"].includes(value);
+}
+/** Environment tuning overrides file tuning field by field; neither supports a toggle. */
+export function resolveSessionNamingConfig(fileConfig = {}, overrideConfig = {}) {
+    return {
+        maxTokens: 24,
+        thinkingLevel: "minimal",
+        timeoutMs: 10_000,
+        ...parseSessionNamingConfig(fileConfig),
+        ...parseSessionNamingConfig(overrideConfig),
+    };
+}
+export async function loadSessionNamingConfig(agentDir, env = process.env) {
+    let file = {};
+    try {
+        file = JSON.parse(await readFile(sessionNamingConfigPath(agentDir), "utf8"));
+    }
+    catch (error) {
+        if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
+            throw error;
+    }
+    const override = env["PI_WEB_SESSION_NAMING"] === undefined ? {} : JSON.parse(env["PI_WEB_SESSION_NAMING"]);
+    return resolveSessionNamingConfig(file, override);
+}