@evandu/super-pi 0.1.131 → 0.1.132

package/dist/server/http-server.js

@@ -10,8 +10,11 @@ import { checkDiskVersion } from "./version.js";
 import { gitBlame, gitDiff, gitLog, gitMutate, gitStatus } from "./git.js";
 import { computeFileDiff } from "./file-diff.js";
 import { verifyCapability } from "./capability.js";
+import { conversationWorkspace } from "./model-filter.js";
+import { describeSchedule } from "./scheduled-tasks.js";
 import { MAX_KNOWLEDGE_REQUEST_BYTES } from "./knowledge.js";
 import { MAX_DOCUMENT_REQUEST_BYTES } from "./application/document-service.js";
+import { MAX_FEISHU_REQUEST_BYTES } from "./application/feishu-service.js";
 import { MAX_WEB_REQUEST_BYTES } from "./web.js";
 import { MAX_TOOL_BODY_BYTES } from "./tool-registry.js";
 import { packageUpdateArgs } from "./update.js";
@@ -249,7 +252,12 @@ export function createHttpServer(options) {
         // not running. The global token is a server-wide secret; the capability is a per-conversation
         // one that only the Pi process of that conversation holds, so the exemption does not widen who
         // can reach the server - it only spares the one caller that already proves who it is.
-        if (requestPath !== "/api/memory/tool" && requestPath !== "/api/knowledge/tool" && requestPath !== "/api/documents/tool" && requestPath !== "/api/web/tool" && requestPath !== "/api/todos" && requestPath !== "/api/question" && (requestPath !== "/api/tools" || request.method !== "POST") && !requestPath.startsWith("/tools/") && !isAuthorized(request, accessToken)) {
+        //
+        // `/api/feishu/tool` is that shape once more. The Feishu credential is a company secret, so
+        // the endpoint that can spend it is exactly the one an agent's own turn can reach, and the
+        // management half (`/api/feishu/config`) stays behind the ordinary token AND the local-address
+        // predicate.
+        if (requestPath !== "/api/memory/tool" && requestPath !== "/api/knowledge/tool" && requestPath !== "/api/documents/tool" && requestPath !== "/api/web/tool" && requestPath !== "/api/feishu/tool" && requestPath !== "/api/todos" && requestPath !== "/api/scheduled-tasks" && requestPath !== "/api/question" && (requestPath !== "/api/tools" || request.method !== "POST") && !requestPath.startsWith("/tools/") && !isAuthorized(request, accessToken)) {
             response.writeHead(401, { "www-authenticate": "Bearer" }).end("Authentication required");
             return;
         }
@@ -805,6 +813,106 @@ export function createHttpServer(options) {
             }
             return;
         }
+        if (url.pathname === "/api/feishu/tool") {
+            if (!context.feishu) {
+                response.writeHead(503).end();
+                return;
+            }
+            if (request.method !== "POST") {
+                response.writeHead(405).end();
+                return;
+            }
+            const origin = request.headers.origin;
+            if (origin && origin !== url.origin) {
+                response.writeHead(403).end("Origin not allowed");
+                return;
+            }
+            try {
+                let raw = "", totalBytes = 0;
+                // The Markdown of a document rides in the request body, so the cap is the document cap.
+                for await (const chunk of request) {
+                    totalBytes += chunk.length;
+                    if (totalBytes > MAX_FEISHU_REQUEST_BYTES) {
+                        response.writeHead(413, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: "飞书请求过大" }));
+                        return;
+                    }
+                    raw += chunk;
+                }
+                const conversationId = String(request.headers["x-feishu-conversation"] ?? "");
+                // THE SAME PROOF THE DOCUMENT TOOLS USE: the request must carry the session's own
+                // capability, and the session must actually be running a turn. The Feishu credential is a
+                // company secret, so this endpoint is the only way to spend it.
+                const verdict = verifyCapability(conversationId, request.headers["x-feishu-capability"], { running: context.runService.isRunning(conversationId) });
+                if (!verdict.ok) {
+                    response.writeHead(403, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: verdict.message }));
+                    return;
+                }
+                const body = raw ? JSON.parse(raw) : {};
+                json(200, await context.feishu.tool(body));
+            }
+            catch (error) {
+                json(400, { error: error instanceof Error ? error.message : String(error) });
+            }
+            return;
+        }
+        /**
+         * THE FEISHU CONNECTION, as the settings panel sees it.
+         *
+         * A GET answers with what the official CLI can do right now: whether it is installed, whether
+         * it has an application, and whether a person has authorized it. It never answers with a
+         * credential - the CLI keeps those in the OS keychain, and this server never sees them.
+         *
+         * The address predicate is on the POSTs and not on the GET: connecting is a change to the
+         * machine, and the project's rule is that changes like this come from the local network.
+         * Reading whether the CLI is connected leaks nothing beyond what the panel already shows.
+         */
+        if (url.pathname === "/api/feishu/status") {
+            if (!context.feishu) {
+                response.writeHead(503).end();
+                return;
+            }
+            if (request.method !== "GET") {
+                json(405, { error: "这个接口只接受 GET 请求。" });
+                return;
+            }
+            json(200, await context.feishu.status());
+            return;
+        }
+        /**
+         * STARTS THE CONNECT FLOW, and finishes it.
+         *
+         * The first POST asks the CLI for a device code (or for it to register an application), and
+         * answers with the URL the person has to open. The second one hands the device code back to
+         * the CLI once they have authorized it, which is where the token is written - into the keychain,
+         * not into this server.
+         *
+         * The CLI's own documentation describes exactly this two-step shape for agents, and the two
+         * calls are separate endpoints because the person has to go and do something in between.
+         */
+        if (url.pathname === "/api/feishu/connect" || url.pathname === "/api/feishu/connect/complete") {
+            if (!context.feishu) {
+                response.writeHead(503).end();
+                return;
+            }
+            if (request.method !== "POST") {
+                json(405, { error: "这个接口只接受 POST 请求。" });
+                return;
+            }
+            if (!isLocalOrPrivateAddress(remote)) {
+                json(403, { error: "连接飞书账号只允许来自本机或局域网的请求。" });
+                return;
+            }
+            try {
+                const result = url.pathname.endsWith("/complete")
+                    ? await context.feishu.completeConnect()
+                    : await context.feishu.connect();
+                json(result.ok ? 200 : 400, result);
+            }
+            catch (error) {
+                json(400, { error: error instanceof Error ? error.message : String(error) });
+            }
+            return;
+        }
         if (url.pathname === "/api/shutdown") {
             if (request.method !== "POST" || !isLocalOrPrivateAddress(remote)) {
                 response.writeHead(403, { "content-type": "text/plain; charset=utf-8" }).end("Shutdown requires a loopback or private network POST");
@@ -1154,6 +1262,109 @@ export function createHttpServer(options) {
             }
             return;
         }
+        if (url.pathname === "/api/scheduled-tasks") {
+            // THE AGENT'S DOOR TO THE SCHEDULED TASKS, and the same shape as `/api/todos`: exempt from the
+            // global token because the caller proves itself with a per-conversation capability instead, and
+            // restricted to loopback or a private network for the same reason `/api/todos` is.
+            if (request.method !== "POST" || !isLocalOrPrivateAddress(remote)) {
+                response.writeHead(403, { "content-type": "text/plain; charset=utf-8" }).end("Scheduled task writes require a loopback or private network POST");
+                return;
+            }
+            let raw = "";
+            let totalBytes = 0;
+            for await (const chunk of request) {
+                totalBytes += chunk.length;
+                if (totalBytes > MAX_FILE_BYTES * 2) {
+                    response.writeHead(413, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: "请求体过大", code: "too_large" }));
+                    request.destroy();
+                    return;
+                }
+                raw += chunk;
+            }
+            const json = (status, body) => {
+                response.writeHead(status, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify(body));
+            };
+            try {
+                const body = JSON.parse(raw);
+                const conversationId = body.conversationId?.trim();
+                if (!conversationId)
+                    throw new Error("scheduled_task requires conversationId");
+                const verdict = runService.verifyPrimaryCapability(conversationId, body.capability);
+                if (!verdict.ok) {
+                    json(403, { error: verdict.message });
+                    return;
+                }
+                const service = context.scheduledTaskService;
+                if (!service) {
+                    json(503, { error: "定时任务功能在这个实例上没有启用。" });
+                    return;
+                }
+                // THE WORKSPACE IS THE CALLER'S, not the agent's choice. The conversation the turn belongs to
+                // decides where the task runs and what its defaults are; a task could otherwise be filed under
+                // a workspace its own author cannot see.
+                const workspaceId = conversationWorkspace(store.snapshot(), conversationId).id;
+                const action = (body.action ?? "create").trim();
+                if (action === "list") {
+                    json(200, { tasks: service.listForWorkspace(workspaceId) });
+                    return;
+                }
+                if (action === "create") {
+                    const task = await service.create({
+                        name: body.name,
+                        prompt: body.prompt,
+                        schedule: body.schedule,
+                        workspaceId,
+                        model: body.model ? { provider: body.model.provider, modelId: body.model.modelId, label: body.model.label ?? body.model.modelId } : null,
+                        agentId: body.agentId,
+                    }, "agent");
+                    json(200, { task, describe: describeSchedule(task.schedule) });
+                    return;
+                }
+                if (action === "update") {
+                    const id = body.id?.trim();
+                    if (!id)
+                        throw new Error("scheduled_task update requires an id");
+                    // THE TASK MUST BE THE CALLER'S TO CHANGE. A task runs in a workspace: it opens its
+                    // conversation there, uses that workspace's defaults and its tools. The caller cannot even
+                    // LIST another workspace's tasks (`list` is scoped), so it must not be able to change or
+                    // delete them either - and the refusal must not say "it exists, over there".
+                    service.requireForWorkspace(id, workspaceId);
+                    const task = await service.update(id, {
+                        name: body.name,
+                        prompt: body.prompt,
+                        schedule: body.schedule,
+                        // "NOT MENTIONED" AND "CLEARED" ARE DIFFERENT REQUESTS. The extension only sends the
+                        // fields the model actually wrote, so a model that changes the prompt and says nothing
+                        // about the model leaves the key ABSENT - and the service reads an absent model as
+                        // "keep what is there". Mapping absence to null made "not mentioned" mean "delete", so a
+                        // model the user had picked for this task was silently dropped and the task fell back to
+                        // the default model (measured by scripts/scheduled-task-scope.test.mjs, ledger
+                        // TEST-025). Every other field here already has this asymmetry right: name, prompt,
+                        // schedule and agentId are all "absent means unchanged".
+                        model: body.model === undefined
+                            ? undefined
+                            : (body.model ? { provider: body.model.provider, modelId: body.model.modelId, label: body.model.label ?? body.model.modelId } : null),
+                        agentId: body.agentId,
+                    });
+                    json(200, { task, describe: describeSchedule(task.schedule) });
+                    return;
+                }
+                if (action === "delete") {
+                    const id = body.id?.trim();
+                    if (!id)
+                        throw new Error("scheduled_task delete requires an id");
+                    service.requireForWorkspace(id, workspaceId);
+                    await service.remove(id);
+                    json(200, { deleted: id });
+                    return;
+                }
+                json(400, { error: "action 只能是 create、list、update 或 delete。" });
+            }
+            catch (error) {
+                json(400, { error: error instanceof Error ? error.message : "scheduled task request failed" });
+            }
+            return;
+        }
         if (url.pathname === "/api/question") {
             if (request.method !== "POST" || !isLocalOrPrivateAddress(remote)) {
                 response.writeHead(403).end();

package/dist/server/index.js

@@ -16,12 +16,14 @@ import { SubagentRunRecorder } from "./subagent-runs.js";
 import { WorkflowEngine } from "./workflow-engine.js";
 import { ExtensionUiService } from "./application/extension-ui-service.js";
 import { DocumentService } from "./application/document-service.js";
+import { FeishuService } from "./application/feishu-service.js";
 import { CatalogService } from "./application/catalog-service.js";
 import { ProviderService } from "./application/provider-service.js";
 import { ProviderRegistry } from "./providers.js";
 import { RunService } from "./application/run-service.js";
 import { FileChangeTracker } from "./file-changes.js";
 import { ConversationService } from "./application/conversation-service.js";
+import { ScheduledTaskService } from "./application/scheduled-task-service.js";
 import { WorkspaceService } from "./application/workspace-service.js";
 import { CommandHandler } from "./command-handler.js";
 import { TerminalService, terminalDisabledReason } from "./terminal.js";
@@ -107,6 +109,7 @@ await mkdir(uploadsDir, { recursive: true }).catch(() => { });
 const taskEndpoint = `http://${internalHost}:${port}/api/subagent/dispatch`;
 const execEndpoint = `http://${internalHost}:${port}/api/exec`;
 const todoEndpoint = `http://${internalHost}:${port}/api/todos`;
+const scheduledTaskEndpoint = `http://${internalHost}:${port}/api/scheduled-tasks`;
 const workflowEndpoint = `http://${internalHost}:${port}/api/workflow/run`;
 const questionEndpoint = `http://${internalHost}:${port}/api/question`;
 const toolsEndpoint = `http://${internalHost}:${port}/api/tools`;
@@ -133,7 +136,7 @@ const paths = {
 };
 const runtime = process.env.SUPER_PI_RUNTIME === "welcome"
     ? new WelcomeRuntime()
-    : new PiRpcRuntime(join(dataDir, "pi-sessions"), undefined, { dir: initialAgentDirs, promptDir: agentPromptDir }, { endpoint: taskEndpoint, execEndpoint, todoEndpoint, workflowEndpoint, questionEndpoint, toolsEndpoint, documentsEndpoint, uploadsDir });
+    : new PiRpcRuntime(join(dataDir, "pi-sessions"), undefined, { dir: initialAgentDirs, promptDir: agentPromptDir }, { endpoint: taskEndpoint, execEndpoint, todoEndpoint, workflowEndpoint, questionEndpoint, toolsEndpoint, documentsEndpoint, scheduledTaskEndpoint, uploadsDir });
 const broadcaster = new WsBroadcaster(() => store.snapshot());
 const memory = new ActiveMemory(join(dataDir, "memories"), store, runtime);
 process.env.SUPER_PI_MEMORY_ENDPOINT = `http://${internalHost}:${port}/api/memory/tool`;
@@ -151,6 +154,12 @@ if (runtime instanceof PiRpcRuntime)
 // capability on its own.
 const documentService = new DocumentService(store);
 process.env.SUPER_PI_DOCUMENTS_ENDPOINT = documentsEndpoint;
+// The Feishu tools. The credential belongs to the OFFICIAL CLI, which keeps it in the OS keychain,
+// so this service holds nothing but the CLI's address. The endpoint is published here the same way
+// the document one is: the Pi process of a turn reads it out of its environment, and the endpoint
+// verifies the session's capability on its own.
+const feishu = new FeishuService();
+process.env.SUPER_PI_FEISHU_ENDPOINT = `http://${internalHost}:${port}/api/feishu/tool`;
 const web = new WebService();
 process.env.SUPER_PI_WEB_ENDPOINT = `http://${internalHost}:${port}/api/web/tool`;
 const extensionUiService = new ExtensionUiService(broadcaster);
@@ -256,11 +265,20 @@ const terminalService = new TerminalService({
  */
 const execService = new ExecService((event) => broadcaster.broadcast(event), (sessionId, exitCode, stdout, stderr) => runService.enqueueExecResult(sessionId, exitCode, stdout, stderr));
 runService.setExecService(execService);
+/**
+ * THE SCHEDULED TASKS, and the clock that fires them.
+ *
+ * Constructed after the run service and the conversation service, because it drives both: a task that
+ * fires opens a conversation and sends a message into it, through exactly the path a person's own
+ * message takes.
+ */
+const scheduledTaskService = new ScheduledTaskService(store, runService, conversationService, broadcaster);
 const serverContext = {
     memory,
     knowledge,
     web,
     documentService,
+    feishu,
     paths,
     store,
     runtime,
@@ -273,6 +291,7 @@ const serverContext = {
     extensionUiService,
     catalogService,
     providerService,
+    scheduledTaskService,
     execService,
     toolRegistry,
     toolRunner,
@@ -283,7 +302,7 @@ const serverContext = {
     terminalEnabled: () => terminalService.enabled,
     terminalDisabledReason: () => terminalDisabledReason(),
 };
-const commandHandler = new CommandHandler(workspaceService, conversationService, runService, extensionUiService, catalogService, terminalService, rootDir, providerService);
+const commandHandler = new CommandHandler(workspaceService, conversationService, runService, extensionUiService, catalogService, terminalService, rootDir, providerService, scheduledTaskService);
 // ------------------------------------------------------------- Lifecycle & shutdown
 let shutdownPromise;
 async function closeHttpServer() {
@@ -302,6 +321,10 @@ async function shutdown(reason) {
         execService.closeAll();
         runService.abortAll();
         workflows.abortAll();
+        // The scheduler stops BEFORE the runs are waited for, so no new task starts while the server is
+        // closing. The runs already in flight are not aborted: a half-answered scheduled task is a real
+        // answer in a real conversation, and throwing it away to shut down faster would be the wrong trade.
+        await scheduledTaskService.stop();
         for (const c of store.snapshot().conversations) {
             extensionUiService.cancelPendingUi(c.id, "aborted");
         }
@@ -350,6 +373,10 @@ httpServer.listen(port, host, () => {
     const displayHost = host === "0.0.0.0" || host === "::" ? "127.0.0.1" : host;
     console.log(`Super Pi is running at http://${displayHost}:${port}`);
     logging.write("info", `listening on ${host}:${port} (pid ${process.pid})`);
+    // THE CLOCK STARTS WITH THE SERVER. A task whose moment passed while the server was down is fired
+    // once by the first sweep - the daily report the user asked for is still wanted when they come back,
+    // but seven of them are not.
+    scheduledTaskService.start();
     if (host === "0.0.0.0" || host === "::") {
         const lanIps = getLanIps();
         for (const ip of lanIps) {

package/dist/server/knowledge.js

@@ -1,6 +1,6 @@
 import { createHash, randomUUID } from "node:crypto";
 import { mkdir, readFile, readdir, rename, stat, unlink, writeFile } from "node:fs/promises";
-import { basename, extname, join } from "node:path";
+import { basename, extname, join, relative, sep } from "node:path";
 import { looksBinary, resolveInsideRoot } from "./files.js";
 import { documentFormatOf, DocumentError, extractText } from "./documents.js";
 /** 1 MB. Big enough for a design doc or a spec, small enough that chunking stays instant. */
@@ -406,7 +406,15 @@ export class KnowledgeBase {
             }
             if (info.size > MAX_DOCUMENT_BYTES)
                 throw new Error(`文件过大：${info.size} 字节超过 ${MAX_DOCUMENT_BYTES} 的上限`);
-            source = body.path.trim();
+            // THE DOCUMENT'S IDENTITY IS THE FILE, NOT THE SPELLING OF ITS PATH. `resolveInsideRoot` has
+            // already resolved the caller's path to a canonical one, so the identity is derived from THAT -
+            // the workspace-relative path - instead of from whatever string the caller typed. Taking the raw
+            // string made `./notes.md` and `notes.md` two different documents: re-importing the same file
+            // under another spelling added a second document, and the REPLACED version stayed in the index
+            // where the agent could still cite it (measured by
+            // scripts/knowledge-import-identity.test.mjs, ledger TEST-027). The contract says a file whose
+            // content changed is an update, keeping its id, and only one document per file may exist.
+            source = relative(workspace.path, absolute).split(sep).join("/");
             if (!title)
                 title = basename(absolute);
             if (documentFormat) {

package/dist/server/persistence/app-state-repository.d.ts

@@ -10,7 +10,19 @@ export type StateTransaction = {
     run: SubagentRun;
 } | {
     kind: "collections.replace";
-    values: Partial<Pick<AppState, "workflows" | "backgroundTasks">>;
+    values: Partial<Pick<AppState, "workflows" | "backgroundTasks" | "scheduledTasks">>;
+}
+/**
+ * Removes one collection row entirely.
+ *
+ * It exists because "this collection is empty" is stored as the ABSENCE of the key, not as an empty
+ * array: a fresh install must not claim the user considered a schedule and found none. A repository
+ * whose `collections.replace` can only write rows therefore cannot express "there are none" - it can
+ * only write `[]`, which is a different claim.
+ */
+ | {
+    kind: "collections.remove";
+    name: "workflows" | "backgroundTasks" | "scheduledTasks";
 } | {
     kind: "conversation.metadata";
     conversationId: string;

package/dist/server/persistence/sqlite-state-repository.js

@@ -118,6 +118,9 @@ export class SqliteStateRepository {
                 for (const [name, value] of Object.entries(transaction.values))
                     write.run(name, JSON.stringify(value));
             }
+            else if (transaction.kind === "collections.remove") {
+                this.db.prepare("DELETE FROM collections WHERE name=?").run(transaction.name);
+            }
             else if (transaction.kind === "conversation.messages") {
                 // A DIFF, NOT A REWRITE. This used to DELETE the conversation's rows and re-INSERT every
                 // message - stringified twice, once per table - on every single send, under

package/dist/server/pi-session.js

@@ -419,6 +419,9 @@ export function superPiExtensionPaths(repositoryRoot) {
         // whether to register anything: with no endpoint in its environment it returns without
         // registering a tool, so a runtime without a document endpoint mounts nothing harmful.
         join(repositoryRoot, "agents", "super-pi-documents", "index.ts"),
+        // The Feishu tools, mounted for every session on the same terms: the extension registers
+        // nothing without an endpoint in its environment.
+        join(repositoryRoot, "agents", "super-pi-feishu", "index.ts"),
     ];
     return paths.filter((path) => existsSync(path));
 }

package/dist/server/runtime.d.ts

@@ -517,6 +517,14 @@ export declare function taskExtensionPath(from?: string): string;
  * from `import.meta.dirname` reach the repository root both after `tsc -b` and under `tsx watch`.
  */
 export declare function documentExtensionPath(from?: string): string;
+/**
+ * The Feishu extension's file, resolved the same way the document extension's is.
+ *
+ * Named on both sides of the wire rather than imported by the extension, for the reason every one
+ * of these names is written out twice: `agents/` is loaded by Pi's module loader and `src/` by
+ * tsc, so a relative import across the two would resolve differently under each.
+ */
+export declare function feishuExtensionPath(from?: string): string;
 export declare class PiRpcRuntime implements AgentRuntime {
     private readonly sessionDir;
     /**
@@ -642,6 +650,8 @@ export declare class PiRpcRuntime implements AgentRuntime {
     private warnedMissingExtension;
     /** Latches the "the document extension is missing" warning, for the same reason. */
     private warnedMissingDocumentExtension;
+    /** Latches the "the Feishu extension is missing" warning, for the same reason. */
+    private warnedMissingFeishuExtension;
     /** Latches the "Pi's SDK is not installed" warning, for the same reason. */
     private warnedMissingSdk;
     /**
@@ -709,6 +719,7 @@ export declare class PiRpcRuntime implements AgentRuntime {
         questionEndpoint?: string;
         toolsEndpoint?: string;
         documentsEndpoint?: string;
+        scheduledTaskEndpoint?: string;
         uploadsDir?: string;
         sessionFactory?: PiSessionFactory;
         sessionMode?: "sdk" | "oneshot";
@@ -804,6 +815,16 @@ export declare class PiRpcRuntime implements AgentRuntime {
      * runtime with no document endpoint mounts nothing rather than a tool whose every call fails.
      */
     private documentExtensionArgs;
+    /**
+     * The Feishu extension's spawn argument.
+     *
+     * MOUNTED UNCONDITIONALLY, for the same reason the document tools are: the endpoint is the gate,
+     * and the extension registers nothing without it. The credential is NOT the gate - a user who
+     * has not configured an application yet still gets the tools, because the error those tools
+     * return is the one that tells the user what to do, and a tool that is simply absent cannot say
+     * anything at all.
+     */
+    private feishuExtensionArgs;
     /**
      * The five values the extension reads out of its own environment. See `task-tool.ts` for why they are
      * written out on both sides rather than imported.

package/dist/server/runtime.js

@@ -4,6 +4,7 @@ export { RpcChannel } from "./rpc-channel.js";
 import { randomUUID } from "node:crypto";
 import { KNOWLEDGE_IMPORT_TOOL_NAME, KNOWLEDGE_TOOL_NAME } from "./knowledge.js";
 import { DOCUMENT_READ_TOOL_NAME, DOCUMENT_WRITE_TOOL_NAME } from "./documents.js";
+import { FEISHU_READ_TOOL_NAME, FEISHU_WRITE_TOOL_NAME } from "./feishu-cli.js";
 import { WEB_FETCH_TOOL_NAME, WEB_SEARCH_TOOL_NAME } from "./web.js";
 import { existsSync } from "node:fs";
 import { mkdir, stat } from "node:fs/promises";
@@ -20,7 +21,7 @@ import { describeDeliveredUserMessage, describePiQueue, handleSessionEvent, Turn
 // paths recognise a delivery identically. Re-exported because they were part of this module's surface.
 export { describeDeliveredUserMessage, describePiQueue } from "./pi-session-events.js";
 import { createPiSession, createSdkCatalog, piSdkAvailable, resolveTranscriptFile, superPiExtensionPaths } from "./pi-session.js";
-import { TASK_CONVERSATION_ENV, TASK_DEPTH_ENV, TASK_ENDPOINT_ENV, TASK_EXEC_ENDPOINT_ENV, TASK_ROSTER_ENV, TASK_TOOL_NAME, TODO_ENDPOINT_ENV, TODO_TOOL_NAME, WORKFLOW_ENDPOINT_ENV, WORKFLOW_TOOL_NAME, RUN_ASYNC_TOOL_NAME, rosterPayload, } from "./task-tool.js";
+import { TASK_CONVERSATION_ENV, TASK_DEPTH_ENV, TASK_ENDPOINT_ENV, TASK_EXEC_ENDPOINT_ENV, TASK_ROSTER_ENV, TASK_TOOL_NAME, TODO_ENDPOINT_ENV, TODO_TOOL_NAME, SCHEDULED_TASK_ENDPOINT_ENV, SCHEDULED_TASK_TOOL_NAME, WORKFLOW_ENDPOINT_ENV, WORKFLOW_TOOL_NAME, RUN_ASYNC_TOOL_NAME, rosterPayload, } from "./task-tool.js";
 import { BLOCKING_UI_METHODS, EXTENSION_UI_METHODS, } from "./types.js";
 import { loadConversationImages } from "./upload.js";
 import { describeToolCall, describeToolCallArgs, describeToolCallInProgress, extractPartialResultText, extractToolResultText, readQuestionCall } from "./tool-calls.js";
@@ -248,6 +249,16 @@ export function taskExtensionPath(from = import.meta.dirname) {
 export function documentExtensionPath(from = import.meta.dirname) {
     return resolve(from, "../../agents/super-pi-documents/index.ts");
 }
+/**
+ * The Feishu extension's file, resolved the same way the document extension's is.
+ *
+ * Named on both sides of the wire rather than imported by the extension, for the reason every one
+ * of these names is written out twice: `agents/` is loaded by Pi's module loader and `src/` by
+ * tsc, so a relative import across the two would resolve differently under each.
+ */
+export function feishuExtensionPath(from = import.meta.dirname) {
+    return resolve(from, "../../agents/super-pi-feishu/index.ts");
+}
 /** Bridges a Pi session to Super Pi through Pi's documented JSONL RPC protocol. */
 /**
  * The tool's name as far as the stream has revealed it so far, or an empty string while the model is
@@ -368,6 +379,8 @@ export class PiRpcRuntime {
     warnedMissingExtension = false;
     /** Latches the "the document extension is missing" warning, for the same reason. */
     warnedMissingDocumentExtension = false;
+    /** Latches the "the Feishu extension is missing" warning, for the same reason. */
+    warnedMissingFeishuExtension = false;
     /** Latches the "Pi's SDK is not installed" warning, for the same reason. */
     warnedMissingSdk = false;
     /**
@@ -577,6 +590,28 @@ export class PiRpcRuntime {
         }
         return ["--extension", path];
     }
+    /**
+     * The Feishu extension's spawn argument.
+     *
+     * MOUNTED UNCONDITIONALLY, for the same reason the document tools are: the endpoint is the gate,
+     * and the extension registers nothing without it. The credential is NOT the gate - a user who
+     * has not configured an application yet still gets the tools, because the error those tools
+     * return is the one that tells the user what to do, and a tool that is simply absent cannot say
+     * anything at all.
+     */
+    feishuExtensionArgs() {
+        if (!process.env.SUPER_PI_FEISHU_ENDPOINT)
+            return [];
+        const path = feishuExtensionPath();
+        if (!existsSync(path)) {
+            if (!this.warnedMissingFeishuExtension) {
+                this.warnedMissingFeishuExtension = true;
+                console.warn(`PiRpcRuntime: ${path} does not exist, so the primary agent cannot read or write Feishu cloud documents.`);
+            }
+            return [];
+        }
+        return ["--extension", path];
+    }
     /**
      * The five values the extension reads out of its own environment. See `task-tool.ts` for why they are
      * written out on both sides rather than imported.
@@ -612,6 +647,7 @@ export class PiRpcRuntime {
             [TASK_CONVERSATION_ENV]: conversationId,
             [TASK_DEPTH_ENV]: "0",
             [TODO_ENDPOINT_ENV]: this.options.todoEndpoint ?? "",
+            [SCHEDULED_TASK_ENDPOINT_ENV]: this.options.scheduledTaskEndpoint ?? "",
             [WORKFLOW_ENDPOINT_ENV]: this.options.workflowEndpoint ?? "",
             SUPER_PI_QUESTION_ENDPOINT: this.options.questionEndpoint ?? "",
             SUPER_PI_TOOLS_ENDPOINT: this.options.toolsEndpoint ?? "",
@@ -623,6 +659,11 @@ export class PiRpcRuntime {
             SUPER_PI_DOCUMENTS_ENDPOINT: this.options.documentsEndpoint ?? "",
             SUPER_PI_DOCUMENTS_CONVERSATION: conversationId,
             SUPER_PI_WEB_ENDPOINT: process.env.SUPER_PI_WEB_ENDPOINT ?? "",
+            // The Feishu tools' endpoint and the conversation they act for. The CREDENTIAL is not here:
+            // it is the session's own capability, the same value the task dispatch uses, because a
+            // second credential for one session would be a second thing to rotate and to release.
+            SUPER_PI_FEISHU_ENDPOINT: process.env.SUPER_PI_FEISHU_ENDPOINT ?? "",
+            SUPER_PI_FEISHU_CONVERSATION: conversationId,
         };
     }
     /**
@@ -1055,7 +1096,7 @@ export class PiRpcRuntime {
      * because `toolFlags` treats an explicit false as outranking a host extra.
      */
     extensionToolNames() {
-        const names = [TASK_TOOL_NAME, TODO_TOOL_NAME, WORKFLOW_TOOL_NAME, RUN_ASYNC_TOOL_NAME, "question", "tool_register"];
+        const names = [TASK_TOOL_NAME, TODO_TOOL_NAME, WORKFLOW_TOOL_NAME, RUN_ASYNC_TOOL_NAME, SCHEDULED_TASK_TOOL_NAME, "question", "tool_register"];
         if (this.memory)
             names.push("memory", "skill_manage", "session_search");
         if (this.knowledge)
@@ -1067,6 +1108,12 @@ export class PiRpcRuntime {
         // would otherwise get a loaded-but-undeclared tool - broken with no error to explain it.
         if (this.options.documentsEndpoint)
             names.push(DOCUMENT_READ_TOOL_NAME, DOCUMENT_WRITE_TOOL_NAME);
+        // The Feishu tools are named whenever the endpoint is configured, for the same reason the
+        // document tools are: the endpoint is what decides whether the extension registers them, and
+        // an agent that declares `tools: {"*": false, read: true}` would otherwise get a
+        // loaded-but-undeclared tool - broken with no error to explain it.
+        if (process.env.SUPER_PI_FEISHU_ENDPOINT)
+            names.push(FEISHU_READ_TOOL_NAME, FEISHU_WRITE_TOOL_NAME);
         return names;
     }
     /**
@@ -1223,6 +1270,11 @@ export class PiRpcRuntime {
         const webExtension = resolve(import.meta.dirname, "../../agents/super-pi-web/index.ts");
         const webEnabled = !memoryReview && !knowledgeRerank && existsSync(webExtension) && !!process.env.SUPER_PI_WEB_ENDPOINT;
         const webArgs = webEnabled ? ["--extension", webExtension] : [];
+        // The Feishu tools are mounted for every ordinary turn, and NOT for a review or a rerank: a
+        // background reflection has no business reading a company's cloud documents, and a reranker
+        // must not be able to reach the tools it is ranking.
+        const feishuEnabled = !memoryReview && !knowledgeRerank && this.feishuExtensionArgs().length > 0;
+        const feishuArgs = feishuEnabled ? this.feishuExtensionArgs() : [];
         // The document tools are mounted for every ordinary turn, and NOT for a review or a rerank: a
         // background reflection has no business reading a PDF it was not asked about, and a reranker
         // must not be able to reach the tools it is ranking.
@@ -1232,7 +1284,7 @@ export class PiRpcRuntime {
         // conversation, so minting a second one for the same conversation would replace the first and
         // leave the task dispatch holding a token the server has already forgotten. Both the task
         // extension and the document extension therefore share this one value.
-        const oneShotCapability = (extensionArgs.length || documentsEnabled || webEnabled) ? mintCapability(conversation.id) : undefined;
+        const oneShotCapability = (extensionArgs.length || documentsEnabled || webEnabled || feishuEnabled) ? mintCapability(conversation.id) : undefined;
         // BOTH extension tools, or neither. Naming one while the other goes unmentioned would be a lie in a
         // different direction: Pi filters its registry through `--tools`, so an agent that declares
         // `tools: {"*": false, read: true}` gets whichever of the two is on this line and silently not the
@@ -1245,13 +1297,13 @@ export class PiRpcRuntime {
         // allowlist and naming a tool Pi has not registered would change the spawn line for every other
         // mode. The prompt asks for a bare JSON array and nothing else; if the model spends a turn on a
         // tool call anyway the reranker times out and falls back to the lexical order.
-        const agentArgs = memoryReview ? ["--no-extensions", "--no-skills", "--no-mcp", "--no-context-files", "--no-prompt-templates", "--tools", "memory,skill_manage,session_search"] : knowledgeRerank ? ["--no-extensions", "--no-skills", "--no-mcp", "--no-context-files", "--no-prompt-templates"] : await agentSpawnArgs(this.agents.promptDir, agent, { extraAllowedTools: [...(extensionArgs.length ? [TASK_TOOL_NAME, TODO_TOOL_NAME, WORKFLOW_TOOL_NAME, RUN_ASYNC_TOOL_NAME, "question", "tool_register"] : []), ...(memoryEnabled ? ["memory", "skill_manage", "session_search"] : []), ...(knowledgeEnabled ? [KNOWLEDGE_TOOL_NAME, KNOWLEDGE_IMPORT_TOOL_NAME] : []), ...(documentsEnabled ? [DOCUMENT_READ_TOOL_NAME, DOCUMENT_WRITE_TOOL_NAME] : []), ...(webEnabled ? [WEB_SEARCH_TOOL_NAME, WEB_FETCH_TOOL_NAME] : [])] });
+        const agentArgs = memoryReview ? ["--no-extensions", "--no-skills", "--no-mcp", "--no-context-files", "--no-prompt-templates", "--tools", "memory,skill_manage,session_search"] : knowledgeRerank ? ["--no-extensions", "--no-skills", "--no-mcp", "--no-context-files", "--no-prompt-templates"] : await agentSpawnArgs(this.agents.promptDir, agent, { extraAllowedTools: [...(extensionArgs.length ? [TASK_TOOL_NAME, TODO_TOOL_NAME, WORKFLOW_TOOL_NAME, RUN_ASYNC_TOOL_NAME, SCHEDULED_TASK_TOOL_NAME, "question", "tool_register"] : []), ...(memoryEnabled ? ["memory", "skill_manage", "session_search"] : []), ...(knowledgeEnabled ? [KNOWLEDGE_TOOL_NAME, KNOWLEDGE_IMPORT_TOOL_NAME] : []), ...(documentsEnabled ? [DOCUMENT_READ_TOOL_NAME, DOCUMENT_WRITE_TOOL_NAME] : []), ...(webEnabled ? [WEB_SEARCH_TOOL_NAME, WEB_FETCH_TOOL_NAME] : []), ...(feishuEnabled ? [FEISHU_READ_TOOL_NAME, FEISHU_WRITE_TOOL_NAME] : [])] });
         // Refused here, with the reason, rather than handed to the spawn: an ENOENT from `spawn` reads as
         // "the app is broken" and hides the one fact that matters, which is where it looked for Pi.
         if (!this.pi.found)
             throw new Error(this.pi.reason);
         // npm exposes global CLIs as .cmd shims on Windows; Node requires a shell to launch those shims.
-        const child = spawn(shellQuote(this.pi.command), ["--mode", "rpc", "--session-dir", this.sessionDir, "--session-id", conversation.id, ...extensionArgs, ...memoryArgs, ...knowledgeArgs, ...documentArgs, ...webArgs, ...agentArgs], {
+        const child = spawn(shellQuote(this.pi.command), ["--mode", "rpc", "--session-dir", this.sessionDir, "--session-id", conversation.id, ...extensionArgs, ...memoryArgs, ...knowledgeArgs, ...documentArgs, ...webArgs, ...feishuArgs, ...agentArgs], {
             cwd: childCwd,
             stdio: ["pipe", "pipe", "pipe"],
             shell: process.platform === "win32",
@@ -1259,7 +1311,7 @@ export class PiRpcRuntime {
             // every turn would silently replace the child's environment with whatever THIS process has at
             // spawn time. Inheriting is what an omitted `env` already does, so the two paths differ in nothing
             // but the four documented additions.
-            ...((extensionArgs.length || memoryEnabled || knowledgeEnabled || documentsEnabled || webEnabled) ? { env: { ...process.env, ...(oneShotCapability ? await this.oneShotExtensionEnv(conversation.id, oneShotCapability) : {}), ...(memoryEnabled ? {
+            ...((extensionArgs.length || memoryEnabled || knowledgeEnabled || documentsEnabled || webEnabled || feishuEnabled) ? { env: { ...process.env, ...(oneShotCapability ? await this.oneShotExtensionEnv(conversation.id, oneShotCapability) : {}), ...(memoryEnabled ? {
                         SUPER_PI_MEMORY_ENDPOINT: process.env.SUPER_PI_MEMORY_ENDPOINT,
                         SUPER_PI_MEMORY_TOKEN: memoryToken,
                         SUPER_PI_MEMORY_REVIEW: memoryReview ? "1" : "0",