@fungi.computer/truffle 0.4.0 → 0.6.0

package/dist/private-local-schedules.d.ts

@@ -0,0 +1,84 @@
+import * as Schema from "effect/Schema";
+import { z } from "zod";
+import type { ShiitakeAgent } from "@fungi.computer/shiitake";
+/** Private service ingress, never a Team/member or machine-link request. */
+export declare const localScheduleListInputSchema: z.ZodObject<{
+    after: z.ZodOptional<z.ZodObject<{
+        agentId: z.ZodString;
+        kind: z.ZodUnion<readonly [z.ZodLiteral<"almanac">, z.ZodLiteral<"loop">]>;
+        after: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    invocationRoot: z.ZodString;
+}, z.core.$strict>;
+/** Private person-only mutation, distinct from the finite list request. */
+export declare const localScheduleControlInputSchema: z.ZodObject<{
+    invocationRoot: z.ZodString;
+    target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"almanac">;
+        agentId: z.ZodString;
+        scheduleId: z.ZodString & z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"loop">;
+        agentId: z.ZodString;
+        sessionId: z.ZodString & z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+        loopId: z.ZodString & z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>;
+/** Local directory pages reuse the schedule owner's decoder and retained state. */
+export declare const localSchedulePageSchema: Schema.Struct<{
+    readonly items: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly agentId: Schema.String;
+        readonly kind: Schema.Literal<"almanac">;
+        readonly schedule: Schema.Struct<{
+            readonly id: Schema.String;
+            readonly sessionId: Schema.String;
+            readonly prompt: Schema.String;
+            readonly cron: Schema.NullOr<Schema.Struct<{
+                readonly expression: Schema.String;
+                readonly timeZone: Schema.String;
+            }>>;
+            readonly nextDueAt: Schema.Int;
+            readonly state: Schema.Literals<readonly ["active", "paused", "cancelled", "finished"]>;
+            readonly lastCommandId: Schema.NullOr<Schema.String>;
+            readonly lastError: Schema.NullOr<Schema.String>;
+            readonly attempt: Schema.Int;
+        }>;
+    }>, Schema.Struct<{
+        readonly agentId: Schema.String;
+        readonly kind: Schema.Literal<"loop">;
+        readonly schedule: Schema.Struct<{
+            readonly sessionId: Schema.String;
+            readonly loopId: Schema.String;
+            readonly origin: Schema.Literals<readonly ["human", "model"]>;
+            readonly expiresAt: Schema.NullOr<Schema.Int>;
+            readonly prompt: Schema.String;
+            readonly mode: Schema.Literals<readonly ["self_paced", "fixed_interval"]>;
+            readonly cron: Schema.NullOr<Schema.Struct<{
+                readonly expression: Schema.String;
+                readonly timeZone: Schema.String;
+            }>>;
+            readonly state: Schema.Literals<readonly ["active", "paused", "finished", "failed", "cancelled"]>;
+            readonly commandId: Schema.String;
+            readonly reason: Schema.NullOr<Schema.String>;
+            readonly nextDueAt: Schema.NullOr<Schema.Int>;
+            readonly lastError: Schema.NullOr<Schema.String>;
+            readonly consecutiveFailures: Schema.Int;
+        }>;
+    }>]>>;
+    readonly unavailable: Schema.$Array<Schema.Struct<{
+        readonly agentId: Schema.String;
+        readonly reason: Schema.Literal<"owner_unavailable">;
+    }>>;
+    readonly next: Schema.NullOr<Schema.Struct<{
+        readonly agentId: Schema.String;
+        readonly kind: Schema.Literals<readonly ["almanac", "loop"]>;
+        readonly after: Schema.optionalKey<Schema.String>;
+    }>>;
+}>;
+export type LocalSchedulePage = typeof localSchedulePageSchema.Type;
+/** One bounded read, borrowing existing admitted Agent owners one at a time. */
+export declare function readLocalSchedulePage(agentIds: readonly string[], open: (agentId: string, signal: AbortSignal) => Promise<{
+    owner: Pick<ShiitakeAgent, "extensions">;
+    release: () => void;
+}>, input: z.output<typeof localScheduleListInputSchema>, signal: AbortSignal): Promise<LocalSchedulePage>;

package/dist/private-local-schedules.js

@@ -0,0 +1,65 @@
+import * as Schema from "effect/Schema";
+import { z } from "zod";
+import { agentScheduleListInputSchema, agentSchedulePageSchema, agentScheduleTargetSchema, readAgentSchedulePage, } from "@fungi.computer/shiitake-extensions/schedules";
+import { logEvent } from "./log-event.js";
+/** Private service ingress, never a Team/member or machine-link request. */
+export const localScheduleListInputSchema = z.strictObject({
+    invocationRoot: z.string().min(1),
+    ...agentScheduleListInputSchema.shape,
+});
+/** Private person-only mutation, distinct from the finite list request. */
+export const localScheduleControlInputSchema = z.strictObject({
+    invocationRoot: z.string().min(1),
+    target: agentScheduleTargetSchema,
+});
+/** Local directory pages reuse the schedule owner's decoder and retained state. */
+export const localSchedulePageSchema = Schema.Struct({
+    items: agentSchedulePageSchema.fields.items,
+    unavailable: Schema.Array(Schema.Struct({
+        agentId: Schema.String,
+        reason: Schema.Literal("owner_unavailable"),
+    })).check(Schema.isMaxLength(8)),
+    next: agentSchedulePageSchema.fields.next,
+});
+/** One bounded read, borrowing existing admitted Agent owners one at a time. */
+export async function readLocalSchedulePage(agentIds, open, input, signal) {
+    signal.throwIfAborted();
+    const candidates = agentIds
+        .filter((agentId) => input.after === undefined ? true : agentId >= input.after.agentId)
+        .sort();
+    const items = [];
+    const unavailable = [];
+    // Bound runtime fan-out even when many retained Agents have no schedules.
+    const owners = candidates.slice(0, 8);
+    for (const agentId of owners) {
+        signal.throwIfAborted();
+        try {
+            const { owner, release } = await open(agentId, signal);
+            try {
+                const limit = input.limit - items.length;
+                const pageInput = input.after?.agentId === agentId
+                    ? { limit, after: input.after }
+                    : { limit };
+                const page = await readAgentSchedulePage(agentId, owner, pageInput);
+                signal.throwIfAborted();
+                items.push(...page.items);
+                if (page.next !== null)
+                    return { items, unavailable, next: page.next };
+            }
+            finally {
+                release();
+            }
+        }
+        catch (cause) {
+            signal.throwIfAborted();
+            logEvent("schedule-directory.owner-unavailable", cause);
+            unavailable.push({ agentId, reason: "owner_unavailable" });
+        }
+    }
+    const unread = candidates.at(owners.length);
+    return {
+        items,
+        unavailable,
+        next: unread === undefined ? null : { agentId: unread, kind: "almanac" },
+    };
+}

package/dist/private-local-service-contract.d.ts

@@ -10,6 +10,7 @@ import type { ServiceDiagnosticsStatus } from "./private-local-service-log.js";
 import type { LocalSandboxStatus } from "./private-local-sandbox.js";
 import type { LocalPermissionMode } from "./private-local-permission-mode.js";
 import type { LocalUiAttachmentLifetime } from "./private-local-ui-attachment.js";
+import type { PrivateLocalScheduleCapability } from "./private-local-schedule-client.js";
 /** Live health, not the on-disk identity record or a cached connection snapshot. */
 export type PrivateLocalServiceStatus = Readonly<{
     /** The client-service wire contract this service speaks. */
@@ -102,6 +103,7 @@ export type PrivateLocalServiceRebind = Readonly<{
     service: PrivateLocalServiceStatus;
 }> | Readonly<{
     kind: "unavailable";
+    alive: boolean;
 }>;
 export type PrivateLocalSessionChoice = Readonly<{
     databasePath: string;
@@ -139,6 +141,8 @@ export type PrivateLocalSessionDiscovery = Readonly<{
 }>;
 /** Local process management stays outside the shared Session HTTP contract. */
 export type PrivateLocalServiceManager = Readonly<{
+    /** Explicit private person-only capability; never provided by a mesh/App grant. */
+    schedules: (invocationRoot: string) => PrivateLocalScheduleCapability;
     reload: (invocationRoot: string) => Promise<string>;
     /** Throws `LocalServiceUpdated` when a live service speaks another protocol. */
     status: () => Promise<PrivateLocalServiceStatus | undefined>;

package/dist/private-local-service-discovery.d.ts

@@ -4,7 +4,7 @@ export { sandboxStatusSchema } from "./private-local-sandbox.js";
  * The client-service wire contract. Bump it with any change an older client
  * cannot read; a running client then asks its window to restart.
  */
-export declare const privateLocalServiceProtocol = 4;
+export declare const privateLocalServiceProtocol = 5;
 /** This build's identity: the packed CLI's content hash, or `source` for a source run. */
 export declare function privateLocalServiceVersion(): string;
 /**
@@ -19,7 +19,7 @@ declare const serviceLifecycleSchema: z.ZodObject<{
     startedAt: z.ZodString;
 }, z.core.$loose>;
 declare const serviceRecordSchema: z.ZodObject<{
-    protocol: z.ZodLiteral<4>;
+    protocol: z.ZodLiteral<5>;
     baseUrl: z.ZodURL;
     version: z.ZodString;
     serviceId: z.ZodString & z.ZodType<import("@fungi.computer/cairn").CairnId<"local-service", "service", 1>, string, z.core.$ZodTypeInternals<import("@fungi.computer/cairn").CairnId<"local-service", "service", 1>, string>>;
@@ -29,7 +29,7 @@ declare const serviceRecordSchema: z.ZodObject<{
 export type ServiceRecord = z.infer<typeof serviceRecordSchema>;
 /** Mandatory live diagnostics; never written into the registration pointer. */
 export declare const liveServiceStatusSchema: z.ZodObject<{
-    protocol: z.ZodLiteral<4>;
+    protocol: z.ZodLiteral<5>;
     baseUrl: z.ZodURL;
     version: z.ZodString;
     serviceId: z.ZodString & z.ZodType<import("@fungi.computer/cairn").CairnId<"local-service", "service", 1>, string, z.core.$ZodTypeInternals<import("@fungi.computer/cairn").CairnId<"local-service", "service", 1>, string>>;

package/dist/private-local-service-discovery.js

@@ -17,7 +17,7 @@ export { sandboxStatusSchema } from "./private-local-sandbox.js";
  * The client-service wire contract. Bump it with any change an older client
  * cannot read; a running client then asks its window to restart.
  */
-export const privateLocalServiceProtocol = 4;
+export const privateLocalServiceProtocol = 5;
 /** This build's identity: the packed CLI's content hash, or `source` for a source run. */
 export function privateLocalServiceVersion() {
     return (z

package/dist/private-local-service-listener.js

@@ -1,5 +1,8 @@
 import { localFailureMetadata, logEvent } from "./log-event.js";
 import { bodyLimit } from "hono/body-limit";
+import { ShiitakeError } from "@fungi.computer/shiitake";
+import { toShiitakeErrorWire } from "@fungi.computer/shiitake/http";
+import { localScheduleControlInputSchema, localScheduleListInputSchema, } from "./private-local-schedules.js";
 import { enrollPrivateLocalMesh, localMeshJoinSchema, } from "./private-local-mesh-enrollment.js";
 import { createLocalMachineEnrollmentAccount, registerFungiAccountOwner, signOutOwnedFungiAccount, } from "./private-fungi-account.js";
 import { createServiceLogLifecycle, } from "./private-local-service-log.js";
@@ -103,6 +106,9 @@ readRecoveryManifest, root = capturePrivateLocalConfigRoot()) {
     const app = new Hono();
     app.onError((error, context) => {
         diagnostics.failure(localFailureMetadata("service.request", error));
+        if (error instanceof ShiitakeError &&
+            context.req.path.startsWith(`${prefix}/schedules/`))
+            return context.json(toShiitakeErrorWire(error), error.cause === "conflict" ? 409 : 400);
         if (error instanceof LocalStoreSchemaError)
             return context.json({
                 code: "store_schema_incompatible",
@@ -308,6 +314,9 @@ readRecoveryManifest, root = capturePrivateLocalConfigRoot()) {
                 archived: input.archived,
             }));
         });
+        app.post(`${prefix}/schedules/list`, bodyLimit({ maxSize: 32 * 1024 }), async (context) => context.json(await owners.schedules(localScheduleListInputSchema.parse(await context.req.json()), context.req.raw.signal)));
+        app.post(`${prefix}/schedules/pause`, bodyLimit({ maxSize: 32 * 1024 }), async (context) => context.json(await owners.pauseSchedule(localScheduleControlInputSchema.parse(await context.req.json()), context.req.raw.signal)));
+        app.post(`${prefix}/schedules/delete`, bodyLimit({ maxSize: 32 * 1024 }), async (context) => context.json(await owners.deleteSchedule(localScheduleControlInputSchema.parse(await context.req.json()), context.req.raw.signal)));
         app.post(`${prefix}/reload`, async (context) => {
             try {
                 const input = z

package/dist/private-local-service-owner.d.ts

@@ -3,10 +3,12 @@ import { type PrivateLocalConfigRoot } from "./private-local-config-root.js";
 import type { ServiceLogLifecycle } from "./private-local-service-log.js";
 import type { StopAllResult } from "./private-local-stop-all.js";
 import { type LocalExtensions } from "./local-extensions.js";
+import { z } from "zod";
 import type { PrivateLocalServiceSelection, PrivateLocalSessionCreation } from "./private-local-service-contract.js";
 import { openPrivateLocalRuntimeHost, type PrivateLocalRuntimeHost } from "./private-local-runtime-host.js";
 import type { LocalUiAttachment } from "./private-local-ui-attachment.js";
 import { createLocalMeshLinks } from "./private-local-mesh-links.js";
+import { localScheduleControlInputSchema, localScheduleListInputSchema } from "./private-local-schedules.js";
 export type LocalServiceRuntime = Pick<PrivateLocalRuntimeHost, "databasePath" | "agentId" | "name" | "getSession" | "effectiveModel" | "setModel" | "setArchived" | "setMode" | "sandboxStatus" | "pendingDelegation" | "assertModelReady" | "listSessions" | "createSession" | "deleteSession" | "extensions" | "prepareReload" | "bindSessionPath" | "acceptMail" | "readSettlement" | "idle" | "close">;
 export declare class LocalSessionPathConflict extends Error {
     readonly name = "LocalSessionPathConflict";
@@ -127,6 +129,134 @@ serviceNative?: () => NonNullable<Parameters<typeof openPrivateLocalRuntimeHost>
         } | undefined;
     }>;
     sweepIdle: () => Promise<void>;
+    schedules: (request: z.input<typeof localScheduleListInputSchema>, signal: AbortSignal) => Promise<{
+        readonly items: readonly ({
+            readonly agentId: string;
+            readonly kind: "almanac";
+            readonly schedule: {
+                readonly id: string;
+                readonly sessionId: string;
+                readonly prompt: string;
+                readonly cron: {
+                    readonly expression: string;
+                    readonly timeZone: string;
+                } | null;
+                readonly nextDueAt: number;
+                readonly state: "cancelled" | "active" | "paused" | "finished";
+                readonly lastCommandId: string | null;
+                readonly lastError: string | null;
+                readonly attempt: number;
+            };
+        } | {
+            readonly agentId: string;
+            readonly kind: "loop";
+            readonly schedule: {
+                readonly sessionId: string;
+                readonly loopId: string;
+                readonly origin: "human" | "model";
+                readonly expiresAt: number | null;
+                readonly prompt: string;
+                readonly mode: "self_paced" | "fixed_interval";
+                readonly cron: {
+                    readonly expression: string;
+                    readonly timeZone: string;
+                } | null;
+                readonly state: "cancelled" | "active" | "failed" | "paused" | "finished";
+                readonly commandId: string;
+                readonly reason: string | null;
+                readonly nextDueAt: number | null;
+                readonly lastError: string | null;
+                readonly consecutiveFailures: number;
+            };
+        })[];
+        readonly unavailable: readonly {
+            readonly agentId: string;
+            readonly reason: "owner_unavailable";
+        }[];
+        readonly next: {
+            readonly agentId: string;
+            readonly kind: "almanac" | "loop";
+            readonly after?: string;
+        } | null;
+    }>;
+    pauseSchedule: (request: z.input<typeof localScheduleControlInputSchema>, signal: AbortSignal) => Promise<{
+        readonly agentId: string;
+        readonly kind: "almanac";
+        readonly schedule: {
+            readonly id: string;
+            readonly sessionId: string;
+            readonly prompt: string;
+            readonly cron: {
+                readonly expression: string;
+                readonly timeZone: string;
+            } | null;
+            readonly nextDueAt: number;
+            readonly state: "cancelled" | "active" | "paused" | "finished";
+            readonly lastCommandId: string | null;
+            readonly lastError: string | null;
+            readonly attempt: number;
+        };
+    } | {
+        readonly agentId: string;
+        readonly kind: "loop";
+        readonly schedule: {
+            readonly sessionId: string;
+            readonly loopId: string;
+            readonly origin: "human" | "model";
+            readonly expiresAt: number | null;
+            readonly prompt: string;
+            readonly mode: "self_paced" | "fixed_interval";
+            readonly cron: {
+                readonly expression: string;
+                readonly timeZone: string;
+            } | null;
+            readonly state: "cancelled" | "active" | "failed" | "paused" | "finished";
+            readonly commandId: string;
+            readonly reason: string | null;
+            readonly nextDueAt: number | null;
+            readonly lastError: string | null;
+            readonly consecutiveFailures: number;
+        };
+    }>;
+    deleteSchedule: (request: z.input<typeof localScheduleControlInputSchema>, signal: AbortSignal) => Promise<{
+        readonly agentId: string;
+        readonly kind: "almanac";
+        readonly schedule: {
+            readonly id: string;
+            readonly sessionId: string;
+            readonly prompt: string;
+            readonly cron: {
+                readonly expression: string;
+                readonly timeZone: string;
+            } | null;
+            readonly nextDueAt: number;
+            readonly state: "cancelled" | "active" | "paused" | "finished";
+            readonly lastCommandId: string | null;
+            readonly lastError: string | null;
+            readonly attempt: number;
+        };
+    } | {
+        readonly agentId: string;
+        readonly kind: "loop";
+        readonly schedule: {
+            readonly sessionId: string;
+            readonly loopId: string;
+            readonly origin: "human" | "model";
+            readonly expiresAt: number | null;
+            readonly prompt: string;
+            readonly mode: "self_paced" | "fixed_interval";
+            readonly cron: {
+                readonly expression: string;
+                readonly timeZone: string;
+            } | null;
+            readonly state: "cancelled" | "active" | "failed" | "paused" | "finished";
+            readonly commandId: string;
+            readonly reason: string | null;
+            readonly nextDueAt: number | null;
+            readonly lastError: string | null;
+            readonly consecutiveFailures: number;
+        };
+    }>;
     archive: (request: Readonly<{
         invocationRoot: string;
         agentId: string;

package/dist/private-local-service-owner.js

@@ -17,13 +17,16 @@ import { z } from "zod";
 import * as Schema from "effect/Schema";
 import { selectionSchema } from "./private-local-service-discovery.js";
 import { createShiitakeHttpRoutes } from "@fungi.computer/shiitake/http";
+import { questionContract } from "@fungi.computer/shiitake-extensions/question";
 import { listPrivateLocalAgentStores, LocalStoreSchemaError, readPrivateLocalAgentProfile, readPrivateLocalSessionSummaries, isArchivedStore, unreadableStoreReason, } from "./private-local-session-discovery.js";
 import { createPrivateLocalSessionRequestId, openPrivateLocalRuntimeHost, resolvePrivateLocalCreateStore, } from "./private-local-runtime-host.js";
 import { parsePrivateLocalExecPath } from "./private-local-exec-path.js";
 import { createLocalMeshLinks, localMeshLinkKey, } from "./private-local-mesh-links.js";
 import { agentMailAddressSchema, machineAgentRequestSchema, machineDirectorySchema, } from "@fungi.computer/seam/machine-link-protocol";
-import { commandSettlementSchema } from "@fungi.computer/shiitake/fleet";
+import { commandSettlementSchema, settlementReadableBy, } from "@fungi.computer/shiitake/fleet";
 import { BirdDogMailSchema } from "@fungi.computer/bird-dog/effect";
+import { controlAgentScheduleWithContent } from "@fungi.computer/shiitake-extensions/schedules";
+import { localScheduleControlInputSchema, localScheduleListInputSchema, readLocalSchedulePage, } from "./private-local-schedules.js";
 export class LocalSessionPathConflict extends Error {
     name = "LocalSessionPathConflict";
     constructor() {
@@ -163,7 +166,7 @@ serviceNative, onExecApprovalDecision = () => undefined) {
                         return { status: "accepted", receipt: { sessionId } };
                     }
                     const facts = await admitted(owner, () => owner.readSettlement(operation.sessionId, operation.commandId));
-                    if (facts !== undefined && facts.acceptedSender !== actorAgentId)
+                    if (facts !== undefined && !settlementReadableBy(facts, actorAgentId))
                         return "refused";
                     return {
                         status: "accepted",
@@ -902,6 +905,62 @@ serviceNative, onExecApprovalDecision = () => undefined) {
                 throw new AgentArchiveRefused("archived", `Agent ${agentId} is archived; unarchive it to work with it`);
             throw new Error("Agent is outside this Local project");
         }
+        /**
+         * Run one sender-authenticated command on a child's question owner. Which
+         * Agent the item waits on is decided by the child's own store; this door
+         * only states who is calling.
+         */
+        async function callQuestionAsSender(target, senderAgentId, senderSessionId, command, commandInput, output, signal) {
+            ensureRunning();
+            signal.throwIfAborted();
+            const databasePath = (await targets(signal, "all")).get(target.agentId);
+            if (databasePath === undefined)
+                return outsideOrArchived(target.agentId, signal);
+            const { owner, release } = await admittedOwner(target.agentId, signal);
+            try {
+                return await admitted(owner, async () => Schema.decodeUnknownSync(output)(await owner
+                    .getSession(target.sessionId)
+                    .extension("botanical-session-question")
+                    .call(command, commandInput, {
+                    agentId: senderAgentId,
+                    sessionId: senderSessionId,
+                })));
+            }
+            finally {
+                release();
+            }
+        }
+        async function answerAsSender(input, senderAgentId, senderSessionId, signal) {
+            const decoded = await callQuestionAsSender(input, senderAgentId, senderSessionId, "answerAgent", {
+                askId: input.askId,
+                requestId: input.requestId,
+                answers: input.answers,
+            }, questionContract.commands.answerAgent.output, signal);
+            const { result } = decoded;
+            if (result.result === "accepted")
+                return result.commandId === undefined
+                    ? { status: "answered", via: result.via }
+                    : {
+                        status: "answered",
+                        via: result.via,
+                        commandId: result.commandId,
+                    };
+            if (result.result === "closed")
+                return { status: "closed", reason: result.status };
+            if (result.result === "refused")
+                return { status: "refused", reason: result.reason };
+            return { status: "not_found" };
+        }
+        async function escalateAsSender(input, senderAgentId, senderSessionId, signal) {
+            const decoded = await callQuestionAsSender(input, senderAgentId, senderSessionId, "escalateAgent", { askId: input.itemId }, questionContract.commands.escalateAgent.output, signal);
+            if (decoded.result === "escalated")
+                return { status: "escalated", to: decoded.to };
+            if (decoded.result === "closed")
+                return { status: "closed", reason: decoded.status };
+            if (decoded.result === "refused")
+                return { status: "refused", reason: decoded.reason };
+            return { status: "not_found" };
+        }
         /**
          * The first command still queued or running on any of an Agent's Sessions,
          * so an archive can name it rather than cancel it.
@@ -977,7 +1036,10 @@ serviceNative, onExecApprovalDecision = () => undefined) {
             }
         }
         return {
+            targets,
             owner: admittedOwner,
+            answer: answerAsSender,
+            escalate: escalateAsSender,
             archive: (request, signal) => setArchived(request, true, signal),
             unarchive: (request, signal) => setArchived(request, false, signal),
             list: async (signal, options) => {
@@ -1307,6 +1369,29 @@ serviceNative, onExecApprovalDecision = () => undefined) {
         scheduleWakes();
         await saveRecovery();
     }
+    /** Private person-only schedule discovery, never the Agent or mesh directory. */
+    async function schedules(request, signal) {
+        ensureRunning();
+        signal.throwIfAborted();
+        const input = localScheduleListInputSchema.parse(request);
+        const root = await realpath(input.invocationRoot);
+        const control = directory(root);
+        const agents = [...(await control.targets(signal, "all")).keys()];
+        return readLocalSchedulePage(agents, (agentId, requestSignal) => control.owner(agentId, requestSignal, true), input, signal);
+    }
+    async function controlSchedule(request, action, signal) {
+        ensureRunning();
+        signal.throwIfAborted();
+        const input = localScheduleControlInputSchema.parse(request);
+        const root = await realpath(input.invocationRoot);
+        const { owner, release } = await directory(root).owner(input.target.agentId, signal, true);
+        try {
+            return await controlAgentScheduleWithContent(owner, input.target, action);
+        }
+        finally {
+            release();
+        }
+    }
     /** A person archives or restores any Agent of one project folder. */
     async function archive(request, signal) {
         const control = directory(await realpath(request.invocationRoot));
@@ -1462,6 +1547,9 @@ serviceNative, onExecApprovalDecision = () => undefined) {
         effectiveModel,
         sandboxStatus,
         sweepIdle,
+        schedules,
+        pauseSchedule: (request, signal) => controlSchedule(request, "pause", signal),
+        deleteSchedule: (request, signal) => controlSchedule(request, "delete", signal),
         archive,
         stopAll,
         restore,

package/dist/private-local-service.d.ts

@@ -1,3 +1,6 @@
+export type { PrivateLocalScheduleCapability } from "./private-local-schedule-client.js";
+export type { AgentScheduleRow, AgentScheduleTarget, } from "@fungi.computer/shiitake-extensions/schedules";
+export type { LocalSchedulePage } from "./private-local-schedules.js";
 export { LocalSandboxUnavailable } from "./private-local-containment.js";
 export type { StopAllResult } from "./private-local-stop-all.js";
 export { LocalAgentSelectionAmbiguous, LocalSessionPathConflict, } from "./private-local-service-owner.js";

package/dist/private-local-service.js

@@ -1,5 +1,6 @@
 import { FungiMcpSelectionConflict } from "./private-fungi-mcp-selection.js";
 import { logEvent } from "./log-event.js";
+import { createPrivateLocalScheduleCapability } from "./private-local-schedule-client.js";
 import { readBoundedResponse } from "./private-bounded-response.js";
 import { LocalSandboxUnavailable, sandboxUnavailableReasonSchema, } from "./private-local-containment.js";
 export { LocalSandboxUnavailable } from "./private-local-containment.js";
@@ -466,7 +467,13 @@ export function createPrivateLocalServiceManager(options = {}) {
                 // stopped it decides when it returns.
                 const ready = await status();
                 if (ready === undefined)
-                    return { kind: "unavailable" };
+                    return {
+                        kind: "unavailable",
+                        // The discovery owner's process-lifetime lease distinguishes an
+                        // overloaded listener from a stopped service without guessing
+                        // from the failed HTTP probe or an error message.
+                        alive: await serviceOwnerIsLive(selectedDirectory),
+                    };
                 accept(ready);
                 const again = await postSelection("select", {
                     invocationRoot: input.invocationRoot,
@@ -507,6 +514,7 @@ export function createPrivateLocalServiceManager(options = {}) {
         snapshot: z.unknown(),
     });
     return {
+        schedules: (invocationRoot) => createPrivateLocalScheduleCapability(invocationRoot, start),
         status,
         start,
         createSession: (creation, request) => openConnection("sessions", creation, request),

package/dist/private-local-session-discovery.d.ts

@@ -29,24 +29,29 @@ export declare class LocalStoreSchemaError extends Error {
     readonly name = "LocalStoreSchemaError";
     constructor(databasePath: string, options?: ErrorOptions);
 }
+export type PrivateLocalAgentProfile = ReturnType<typeof openAgentProfile>;
 /**
  * One Agent store's chosen display name, default model, whether it is
  * archived and the Agent that created it (absent when a human made it), read
- * without opening a host.
+ * without opening a host. Directory listings and the sub-agents footer read
+ * every store's profile on each call; an unchanged store file answers from
+ * memory instead of reopening SQLite (each Bun open/close also leaks native
+ * memory).
  */
-export declare function readPrivateLocalAgentProfile(path: string): {
+export declare function readPrivateLocalAgentProfile(path: string): PrivateLocalAgentProfile;
+declare function openAgentProfile(path: string): Readonly<{
     name: string | undefined;
     createdBy: string | null;
     archived: boolean;
     mode: "read-only" | "workspace" | "full-access";
-    writableFolders: string[];
+    writableFolders: readonly string[];
     folder: string;
     model: {
         readonly providerId: string;
         readonly modelId: string;
         readonly reasoning?: "high" | "low" | "max" | "medium" | "minimal" | "xhigh" | undefined;
     } | null;
-};
+}>;
 export declare function readPrivateLocalSessionSummaries(path: string): Promise<readonly LocalSummary[]>;
 /**
  * Discover existing folder sessions without opening or reconciling a host.
@@ -71,3 +76,4 @@ export declare function readPrivateLocalSessionDiscovery(invocationRoot: string,
 }>;
 /** Project the service-owned discovery into choices that resume through it. */
 export declare function projectPrivateLocalSessionDiscovery(discovered: Awaited<ReturnType<typeof readPrivateLocalSessionDiscovery>>, connect: PrivateLocalServiceManager["connect"]): PrivateLocalSessionDiscovery;
+export {};