@fastagent-sh/fastagent 0.25.0 → 0.26.1

package/dist/harnesses/pi-durable/storage.js

@@ -33,8 +33,10 @@ export async function openLockedStorage(path, locking, holders) {
         return await SqliteStorage.open(adapter);
     }
     catch (error) {
-        // The connection only: the adapter's close checkpoints first, which a refused opener cannot do.
-        database.close();
+        // The connection only: the adapter's close checkpoints first, which a refused opener cannot do. Already closed
+        // when the storage refused the database itself (a schema it does not know), and closing it again would hide why.
+        if (database.isOpen)
+            database.close();
         if (error.errcode !== SQLITE_BUSY)
             throw error;
         const who = holders === undefined ? "" : `: ${holders} is running`;

package/dist/harnesses/pi-durable/wake.d.ts

@@ -1,4 +1,11 @@
 import { type Extension } from "@earendil-works/pi-durable";
 export declare const WAKE_EXTENSION = "fastagent.wake";
 export declare const WAKE_TOOLS: string[];
-export declare function wakeExtension(stateRoot: string, now?: () => Date): Extension;
+/**
+ * `ticking` says whether a clock fires the wake-ups kept in `stateRoot` now; a wake-up nothing would fire is refused.
+ * Without it, one always does: `dev`, `start` and AgentCore serve whatever they open.
+ */
+export declare function wakeExtension(stateRoot: string, options?: {
+    now?: () => Date;
+    ticking?: () => boolean;
+}): Extension;

package/dist/harnesses/pi-durable/wake.js

@@ -12,7 +12,14 @@ export const WAKE_TOOLS = ["wake", "unwake"];
 const said = (text) => ({ output: [{ type: "text", text }] });
 const refused = (text) => ({ output: [{ type: "text", text }], isError: true });
 const NOT_A_SESSION = "wake-ups belong to a session, and this conversation is not one (a subagent's): nothing would wake it.";
-export function wakeExtension(stateRoot, now = () => new Date()) {
+const NO_CLOCK = "nothing fires wake-ups for this agent now: the app that opened it does not serve it, so no clock runs. Do the " +
+    "work now, or say it cannot be scheduled.";
+/**
+ * `ticking` says whether a clock fires the wake-ups kept in `stateRoot` now; a wake-up nothing would fire is refused.
+ * Without it, one always does: `dev`, `start` and AgentCore serve whatever they open.
+ */
+export function wakeExtension(stateRoot, options = {}) {
+    const now = options.now ?? (() => new Date());
     return defineExtension({
         name: WAKE_EXTENSION,
         tools: [
@@ -37,6 +44,8 @@ export function wakeExtension(stateRoot, now = () => new Date()) {
                     }),
                 }),
                 execute: async (args, api, context) => {
+                    if (options.ticking?.() === false)
+                        return refused(NO_CLOCK);
                     if ((args.in === undefined) === (args.cron === undefined)) {
                         return refused("pass exactly one of `in` (one-shot) or `cron` (recurring).");
                     }

package/dist/http/contract.d.ts

@@ -464,6 +464,9 @@ declare const AgentHttpApi_base: HttpApi.HttpApi<"fastagent", HttpApiGroup.HttpA
     readonly event: Schema.String;
     readonly data: Schema.String;
 }>, never, never>, Schema.Never, {
+    readonly type: "message";
+    readonly message: Message;
+} | {
     readonly type: "entry";
     readonly entry: Entry;
 } | {
@@ -499,9 +502,6 @@ declare const AgentHttpApi_base: HttpApi.HttpApi<"fastagent", HttpApiGroup.HttpA
         readonly retryable: boolean;
         readonly details?: Schema.Json | undefined;
     };
-} | {
-    readonly type: "message";
-    readonly message: Message;
 } | {
     readonly type: string;
 }> | Schema.toCodecJson<typeof Message>, Schema.toCodecJson<Schema.decodeTo<Schema.declare<AgentError, AgentError>, Schema.Struct<{

package/dist/index.d.ts

@@ -1,13 +1,15 @@
 /**
  * The package's one entry (SPEC.md §8), besides each first-party channel's: the Agent API, opening an agent
- * directory and serving it, and what an author writes.
+ * directory and serving it, what a host embedding agents needs beside them (creating one, model credentials and
+ * sign-in), and what an author writes.
  */
 export type { Agent, AgentErrorData, AgentInfo, CompactOptions, ContentPart, CreateSessionOptions, EntriesOptions, Entry, ErrorCode, Json, ListOptions, Message, MessageKey, MessageStatus, MessageStreamEvent, ModelRef, Page, SendRequest, Session, SessionChanges, SessionEvent, SessionSettings, SessionStatus, ThinkingLevel, Tokens, Usage, WaitOptions, } from "./agent-api.ts";
 export { AgentError, LIMITS, hasEnded } from "./agent-api.ts";
 export { openAgent, type LocalAgent, type OpenAgentOptions, type ServeAgentOptions, } from "./harnesses/pi-durable/serve.ts";
 export type { Service } from "./service.ts";
-/** What `openAgent`'s `credentials` takes: where provider credentials are kept, pi-ai's. */
-export type { CredentialStore } from "@earendil-works/pi-ai";
+export { createAgent, type CreatedAgent } from "./authoring.ts";
+export { SignInCancelled, type Credential, type CredentialStore, type ProviderAuth, type SignInEvent, type SignInInteraction, type SignInMethod, type SignInOption, type SignInPrompt, type SignInRequest, type SignInResult, } from "./sign-in-api.ts";
+export { credentialFile, providerAuth, signIn, signInOptions } from "./harnesses/models/host.ts";
 export { defineAgent, defineSchedule, needs, type AgentConfig, type Needs, type SecretSpec, type SecretValues, } from "./harnesses/pi-durable/define.ts";
 export type { ScheduleConfig } from "./schedule/schedule.ts";
 export { defineChannel, type ChannelContext, type ChannelHandler, type ChannelModule, type ForkSource, type LongConnection, type LongConnectionChannelModule, type Routes, } from "./channel.ts";

package/dist/index.js

@@ -1,5 +1,8 @@
 export { AgentError, LIMITS, hasEnded } from "./agent-api.js";
 export { openAgent, } from "./harnesses/pi-durable/serve.js";
+export { createAgent } from "./authoring.js";
+export { SignInCancelled, } from "./sign-in-api.js";
+export { credentialFile, providerAuth, signIn, signInOptions } from "./harnesses/models/host.js";
 export { defineAgent, defineSchedule, needs, } from "./harnesses/pi-durable/define.js";
 export { defineChannel, } from "./channel.js";
 // What a channel reads a request with, answers with, and compares its platform's secret with (constant time).

package/dist/scaffold/add-channel.js

@@ -8,7 +8,7 @@ import { detectRuntime } from "../runtime.js";
 import { assertInsideAgentDir, exists } from "../paths.js";
 import { channelBundleFiles, channelTemplate } from "./templates.js";
 import { writeValues } from "../value-file.js";
-import { envExamplePath } from "../env.js";
+import { envExamplePath } from "../value-file.js";
 import { FEISHU_AGENT_SCOPES } from "../channels/feishu/setup-mode.js";
 import { slackBotScopes } from "../channels/slack/manifest.js";
 const AGENT_SCOPE_LIST = FEISHU_AGENT_SCOPES.map((entry) => entry.request).join(", ");

package/dist/schedule/cron.d.ts

@@ -18,7 +18,9 @@ export declare function cronError(cron: string, tz: string | undefined): string
  * A function of the expression alone, so a file's verdict never flips with the time it is read. Two consecutive
  * instants under 10 minutes apart are on one day or across one midnight, and the time-of-day fields repeat every day,
  * so two days of the time-of-day form (the day fields made `*`, in UTC) hold every such gap. That is conservative:
- * `0,55 0,23 * * 1` is refused for the 23:55 → 00:00 pair, though Tuesday never fires. A DST change only lengthens a
- * gap (croner fires a repeated hour once). A year field is refused, since what repeats every year does not need one.
+ * `0,55 0,23 * * 1` is refused for the 23:55 → 00:00 pair, though Tuesday never fires. A DST change can bring two
+ * instants closer once a year, which this does not refuse: an expression with several times runs both passes of the
+ * hour the autumn change repeats (`0,55 1 * * *` at 01:55 and, 5 minutes on, the second 01:00), and a schedule whose
+ * session is busy skips a fire anyway. A year field is refused, since what repeats every year does not need one.
  */
 export declare function recurringCronError(cron: string, tz: string | undefined): string | undefined;

package/dist/schedule/cron.js

@@ -45,8 +45,10 @@ const verdicts = new Map();
  * A function of the expression alone, so a file's verdict never flips with the time it is read. Two consecutive
  * instants under 10 minutes apart are on one day or across one midnight, and the time-of-day fields repeat every day,
  * so two days of the time-of-day form (the day fields made `*`, in UTC) hold every such gap. That is conservative:
- * `0,55 0,23 * * 1` is refused for the 23:55 → 00:00 pair, though Tuesday never fires. A DST change only lengthens a
- * gap (croner fires a repeated hour once). A year field is refused, since what repeats every year does not need one.
+ * `0,55 0,23 * * 1` is refused for the 23:55 → 00:00 pair, though Tuesday never fires. A DST change can bring two
+ * instants closer once a year, which this does not refuse: an expression with several times runs both passes of the
+ * hour the autumn change repeats (`0,55 1 * * *` at 01:55 and, 5 minutes on, the second 01:00), and a schedule whose
+ * session is busy skips a fire anyway. A year field is refused, since what repeats every year does not need one.
  */
 export function recurringCronError(cron, tz) {
     const key = `${cron}\u0000${tz ?? ""}`;

package/dist/schedule/eventbridge-cron.d.ts

@@ -6,9 +6,13 @@
  */
 /**
  * Translate a 5-field cron into EventBridge Scheduler's `cron(m h dom mon dow *)`, or say why it can't be. The two
- * fire on the same instants in the same zone, with one exception at a DST change: a local time the spring change
- * removes (02:30 in most of the US on that day) is skipped by EventBridge and run an hour later by croner, so such a
- * schedule runs once more a year on a resident host. A time the autumn change repeats runs once in both.
+ * fire on the same instants in the same zone, with two exceptions at a DST change, both on a resident host (croner):
+ * a local time the spring change removes (02:30 in most of the US on that day) is skipped by EventBridge and run by
+ * croner at the first valid time after the gap, and a schedule with several minutes or hours (every 15 minutes) runs
+ * both passes of the hour the autumn change repeats. EventBridge's documentation says a schedule "runs only once" when
+ * the clock goes back, which is read here as once per time: once for each of the four times of an every-15-minutes
+ * schedule. That reading is not tested against a live schedule. A single time in the repeated hour runs once in both.
+ * `?` is `*`, as croner reads it and as EventBridge means it ("any").
  */
 export declare function toEventBridgeCron(cron: string): {
     expression: string;

package/dist/schedule/eventbridge-cron.js

@@ -56,23 +56,24 @@ function mapDowField(dow) {
 }
 /**
  * Translate a 5-field cron into EventBridge Scheduler's `cron(m h dom mon dow *)`, or say why it can't be. The two
- * fire on the same instants in the same zone, with one exception at a DST change: a local time the spring change
- * removes (02:30 in most of the US on that day) is skipped by EventBridge and run an hour later by croner, so such a
- * schedule runs once more a year on a resident host. A time the autumn change repeats runs once in both.
+ * fire on the same instants in the same zone, with two exceptions at a DST change, both on a resident host (croner):
+ * a local time the spring change removes (02:30 in most of the US on that day) is skipped by EventBridge and run by
+ * croner at the first valid time after the gap, and a schedule with several minutes or hours (every 15 minutes) runs
+ * both passes of the hour the autumn change repeats. EventBridge's documentation says a schedule "runs only once" when
+ * the clock goes back, which is read here as once per time: once for each of the four times of an every-15-minutes
+ * schedule. That reading is not tested against a live schedule. A single time in the repeated hour runs once in both.
+ * `?` is `*`, as croner reads it and as EventBridge means it ("any").
  */
 export function toEventBridgeCron(cron) {
     const fields = cron.trim().split(/\s+/);
     if (fields.length !== 5) {
         return { error: `EventBridge supports 5-field cron only (got ${fields.length} fields)` };
     }
-    const [min, hour, dom, mon, dow] = fields;
+    // EventBridge takes `?` in the day fields only, and exactly one of them; croner reads it as `*` anywhere.
+    const [min, hour, dom, mon, dow] = fields.map((field) => (field === "?" ? "*" : field));
     if (/[L#]/i.test(dow) || /[L#]/i.test(dom)) {
         return { error: "L/# day forms don't translate to EventBridge numbering — set this schedule up manually" };
     }
-    // `?` FIRST, and not as a synonym for `*`.
-    if (dom === "?" || dow === "?") {
-        return { expression: `cron(${min} ${hour} * ${mon} ? *)` };
-    }
     if (dom !== "*" && dow !== "*") {
         return {
             error: "restricting BOTH day-of-month and day-of-week (cron OR semantics) is not expressible in EventBridge",

package/dist/sign-in-api.d.ts

@@ -0,0 +1,147 @@
+/**
+ * Model credentials and provider sign-in as an embedding host sees them: FastAgent's own types, so a host keeps the
+ * credentials where it chooses and runs a sign-in in its own UI without knowing the harness. Imports nothing; the
+ * functions over these types are in harnesses/models/host.ts.
+ */
+/** One provider's credential, kept by a {@link CredentialStore} whole, as it is given. */
+export type Credential = {
+    type: "api_key";
+    key?: string;
+    env?: Record<string, string>;
+} | {
+    type: "oauth";
+    access: string;
+    refresh: string;
+    expires: number;
+    [field: string]: unknown;
+};
+/**
+ * Where model credentials are kept, one per provider. `modify` is the only write, and it runs one at a time per
+ * provider (across processes, where the store can): an OAuth refresh happens inside it, and a rotated refresh token
+ * must never be used twice. A store it cannot read rejects; answering it as empty would let the next write replace
+ * every provider's credential.
+ */
+export interface CredentialStore {
+    /** The stored credential, possibly expired; undefined when the provider has none. */
+    read(provider: string): Promise<Credential | undefined>;
+    /** Which providers have a credential, and of what kind; never the secrets. */
+    list(): Promise<readonly {
+        provider: string;
+        type: Credential["type"];
+    }[]>;
+    /** `change` returns the new credential, or undefined to leave it as it is. Resolves with what is stored after. */
+    modify(provider: string, change: (current: Credential | undefined) => Promise<Credential | undefined>): Promise<Credential | undefined>;
+    delete(provider: string): Promise<void>;
+}
+export type SignInMethod = Credential["type"];
+/** One way to sign in to one provider, with what authenticates the provider now. */
+export interface SignInOption {
+    provider: string;
+    /** The provider's name: "OpenAI", "OpenAI Codex (legacy)". */
+    name: string;
+    method: SignInMethod;
+    /** What signing in this way is called: the provider's own label ("Sign in with ChatGPT"), else a generic one. */
+    label: string;
+    /** An account sign-in backed by a provider subscription. */
+    subscription: boolean;
+    /** Its key comes from the environment only: there is no sign-in to run. */
+    external: boolean;
+    /**
+     * What authenticates the provider now: a stored credential (`OAuth`, `stored credential`), else the environment
+     * (a variable such as `OPENAI_API_KEY`). One credential is stored per provider, so signing in with the other method
+     * replaces a stored one.
+     */
+    status?: {
+        type: SignInMethod;
+        source: string;
+    };
+    /** What in the environment authenticates the provider with nothing stored: what still answers after a sign-out. */
+    environment?: string;
+    /**
+     * Why checking the environment for the provider failed: `environment` is then unknown, and so is `status` when
+     * nothing is stored.
+     */
+    problem?: string;
+}
+/** A question a sign-in asks. `manual_code`: the address the browser ended on after signing in, or the code its page showed. */
+export type SignInPrompt = {
+    signal?: AbortSignal;
+} & ({
+    type: "text" | "secret" | "manual_code";
+    message: string;
+    placeholder?: string;
+} | {
+    type: "select";
+    message: string;
+    options: readonly {
+        id: string;
+        label: string;
+        description?: string;
+    }[];
+});
+/** What a sign-in tells the person: a page to open, a code to enter there, progress. */
+export type SignInEvent = {
+    type: "info";
+    message: string;
+    links?: readonly {
+        url: string;
+        label?: string;
+    }[];
+} | {
+    type: "progress";
+    message: string;
+} | {
+    type: "auth_url";
+    url: string;
+    instructions?: string;
+} | {
+    type: "device_code";
+    userCode: string;
+    verificationUri: string;
+    intervalSeconds?: number;
+    expiresInSeconds?: number;
+};
+/**
+ * How a sign-in reaches the person. `prompt` resolves with the answer (a select's option `id`); it rejects with
+ * {@link SignInCancelled} when the person backs out, which ends the sign-in with that error, and with any other error
+ * when asking failed, which fails the sign-in with it. A prompt's `signal` aborts when the sign-in no longer needs the
+ * answer, such as a `manual_code` question a browser callback answered first.
+ */
+export interface SignInInteraction {
+    signal?: AbortSignal;
+    prompt(prompt: SignInPrompt): Promise<string>;
+    notify(event: SignInEvent): void;
+}
+export interface SignInRequest {
+    credentials: CredentialStore;
+    provider: string;
+    method: SignInMethod;
+    interaction: SignInInteraction;
+    /**
+     * A stable id of this installation, which Sign in with ChatGPT requires. `credentialFile` keeps one beside its
+     * file; a store of the host's own passes it here.
+     */
+    deviceId?: string;
+}
+export interface SignInResult {
+    provider: string;
+    method: SignInMethod;
+    /** An API key is checked with one request before it is stored: accepted, or not decidable (stored). */
+    verified: "ok" | "unknown" | "n/a";
+}
+/** What a request to a provider authenticates with. */
+export interface ProviderAuth {
+    type: SignInMethod;
+    /** Where it comes from: `OAuth`, `stored credential`, an environment variable's name. */
+    source?: string;
+    /** The key or access token a request sends. */
+    apiKey?: string;
+    /** Headers a request sends, where the provider authenticates by them (an `Authorization` of its own). */
+    headers?: Record<string, string>;
+    /** Where the request goes, where the credential decides it (an enterprise endpoint). */
+    baseUrl?: string;
+}
+/** The person backed out of a sign-in, or its signal aborted: a decision, not a failure. Nothing was stored. */
+export declare class SignInCancelled extends Error {
+    name: string;
+}

package/dist/sign-in-api.js

@@ -0,0 +1,9 @@
+/**
+ * Model credentials and provider sign-in as an embedding host sees them: FastAgent's own types, so a host keeps the
+ * credentials where it chooses and runs a sign-in in its own UI without knowing the harness. Imports nothing; the
+ * functions over these types are in harnesses/models/host.ts.
+ */
+/** The person backed out of a sign-in, or its signal aborted: a decision, not a failure. Nothing was stored. */
+export class SignInCancelled extends Error {
+    name = "SignInCancelled";
+}

package/dist/tunnel.js

@@ -8,7 +8,8 @@ import { registerFeishuWebhook } from "./channels/feishu/register-webhook.js";
 import { registerSlackWebhook } from "./channels/slack/register-webhook.js";
 import { registerTelegramWebhook } from "./channels/telegram/register-webhook.js";
 import { pointChannelsAt, webhookKinds } from "./deploy/channel-ingress.js";
-import { dotEnvPath, loadDotEnv } from "./env.js";
+import { loadDotEnv } from "./env.js";
+import { dotEnvPath } from "./value-file.js";
 import { installProxyFetch } from "./proxy.js";
 import { AGENT_ENVIRONMENT_ENV, resolveStateRoot } from "./paths.js";
 import { log } from "./log.js";

package/dist/value-file.d.ts

@@ -1,3 +1,22 @@
+/** Parse .env content into key → value (the dialect above; last occurrence of a key wins). */
+export declare function parseEnvContent(content: string): Map<string, string>;
+/**
+ * READ a value file without entering it: the values as data, never `process.env`. This is how code reasons about an
+ * environment OTHER than its own — `deploy` resolves configuration in the environment being deployed, which this
+ * file declares, and merging it into the running process would put the two environments in one bag. A missing file
+ * is no values, which is normal.
+ */
+export declare function loadEnvValues(file: string): Map<string, string>;
+/** The agent's `.env` file: `<resolved secrets dir>/.env`. */
+export declare function dotEnvPath(agentDir: string, env?: NodeJS.ProcessEnv): string;
+/** The committable template: `<agentDir>/.secrets/.env.example`. */
+export declare function envExamplePath(agentDir: string): string;
+/**
+ * What the agent's value file ({@link dotEnvPath}) adds to this process's environment, read and not entered: each
+ * variable the process does not hold, as entering the file would set it. An agent opened in a process that runs
+ * others too reads its own values through this; one that a command entered (`dev`, `start`) adds nothing here.
+ */
+export declare function agentValues(agentDir: string): Record<string, string>;
 /** One variable to write: with a `value`, an active line; without one, a placeholder under its `hint`. */
 export interface ValueEntry {
     name: string;

package/dist/value-file.js

@@ -1,13 +1,69 @@
 /**
- * Writing the selected environment's value file (`.secrets/.env`, or `.secrets/production/.env` for a deployment):
- * what a command generates (a channel's secret, the Agent API's key) goes in as an active `NAME=value` line, a value
- * already set stays, and the secrets directory fastagent made carries its own `.gitignore`.
+ * The selected environment's value file (`.secrets/.env`, or `.secrets/production/.env` for a deployment), read and
+ * written; entering it into `process.env` is env.ts's. Read as data: what it declares, and what it adds to an agent's
+ * environment. Written: what a command generates (a channel's secret, the Agent API's key) goes in as an active
+ * `NAME=value` line, a value already set stays, and the secrets directory fastagent made carries its own `.gitignore`.
  */
+import { readFileSync } from "node:fs";
 import { appendFile, mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
-import { dotEnvPath, parseEnvContent } from "./env.js";
-import { SECRETS_DIRNAME, SECRET_FILE_MODE, exists } from "./paths.js";
+import { SECRETS_DIRNAME, SECRET_FILE_MODE, exists, resolveSecretsDir } from "./paths.js";
 import { baseTemplate } from "./scaffold/templates.js";
+/** Parse .env content into key → value (the dialect above; last occurrence of a key wins). */
+export function parseEnvContent(content) {
+    const parsed = new Map();
+    for (const raw of content.split("\n")) {
+        const line = raw.trim();
+        if (!line || line.startsWith("#"))
+            continue;
+        const eq = line.indexOf("=");
+        if (eq < 1)
+            continue; // no `=`, or an empty key
+        const key = line.slice(0, eq).trim();
+        let value = line.slice(eq + 1).trim();
+        const quote = value[0];
+        if ((quote === '"' || quote === "'") && value.at(-1) === quote)
+            value = value.slice(1, -1);
+        parsed.set(key, value); // in-file: last occurrence wins (Map overwrite)
+    }
+    return parsed;
+}
+/**
+ * READ a value file without entering it: the values as data, never `process.env`. This is how code reasons about an
+ * environment OTHER than its own — `deploy` resolves configuration in the environment being deployed, which this
+ * file declares, and merging it into the running process would put the two environments in one bag. A missing file
+ * is no values, which is normal.
+ */
+export function loadEnvValues(file) {
+    try {
+        return parseEnvContent(readFileSync(file, "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return new Map();
+        throw error;
+    }
+}
+/** The agent's `.env` file: `<resolved secrets dir>/.env`. */
+export function dotEnvPath(agentDir, env = process.env) {
+    return join(resolveSecretsDir(agentDir, env), ".env");
+}
+/** The committable template: `<agentDir>/.secrets/.env.example`. */
+export function envExamplePath(agentDir) {
+    return join(agentDir, SECRETS_DIRNAME, ".env.example");
+}
+/**
+ * What the agent's value file ({@link dotEnvPath}) adds to this process's environment, read and not entered: each
+ * variable the process does not hold, as entering the file would set it. An agent opened in a process that runs
+ * others too reads its own values through this; one that a command entered (`dev`, `start`) adds nothing here.
+ */
+export function agentValues(agentDir) {
+    const values = {};
+    for (const [key, value] of loadEnvValues(dotEnvPath(agentDir)))
+        if (!(key in process.env))
+            values[key] = value;
+    return values;
+}
 /** What a command says when it wrote a secret into a secrets directory fastagent does not own and git may track. */
 export function unprotectedSecretsNote(dir) {
     return (`${dir} (FASTAGENT_SECRETS_DIR) now holds a secret and has no .gitignore — that directory is yours, so ` +

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fastagent-sh/fastagent",
-  "version": "0.25.0",
+  "version": "0.26.1",
   "description": "Vibe first. Then FastAgent: turn a local agent directory into a live service in your app, on Telegram, Slack, Feishu, or behind any channel.",
   "keywords": [
     "agent",
@@ -89,33 +89,33 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.6.0",
-    "@earendil-works/chord": "1.3.0",
-    "@earendil-works/pi-ai": "1.3.0",
-    "@earendil-works/pi-durable": "1.3.0",
+    "@earendil-works/chord": "1.4.0",
+    "@earendil-works/pi-ai": "1.4.0",
+    "@earendil-works/pi-durable": "1.4.0",
     "@effect/platform-bun": "^4.0.7",
     "@effect/platform-node": "^4.0.7",
-    "@larksuiteoapi/node-sdk": "^1.71.1",
+    "@larksuiteoapi/node-sdk": "^1.76.0",
     "@smithy/signature-v4": "^5.7.4",
-    "chokidar": "^5.0.0",
+    "chokidar": "^6.0.0",
     "commander": "^15.0.0",
-    "croner": "^10.0.1",
+    "croner": "^11.0.0",
     "effect": "^4.0.7",
     "giget": "^3.3.0",
-    "ignore": "^7.0.12",
+    "ignore": "^7.0.14",
     "proper-lockfile": "^4.1.2",
     "undici": "^8.6.0",
-    "yaml": "^2.9.0"
+    "yaml": "^2.9.1"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.5.15",
-    "@earendil-works/pi-coding-agent": "1.3.0",
-    "@hono/node-server": "^2.1.4",
+    "@biomejs/biome": "^2.6.4",
+    "@earendil-works/pi-coding-agent": "1.4.0",
+    "@hono/node-server": "^2.1.5",
     "@types/express": "^5.0.6",
     "@types/proper-lockfile": "^4.1.4",
-    "express": "^5.2.1",
-    "fastify": "^5.12.5",
-    "knip": "^6.41.0",
+    "express": "^5.3.0",
+    "fastify": "^5.12.7",
+    "knip": "^6.44.0",
     "typescript": "^7.0.2",
-    "vitest": "^5.0.3"
+    "vitest": "^5.0.5"
   }
 }