@leuduan/lagent 0.0.0-stage → 44.0.0

package/dist/plugins/schedules/record.d.ts

@@ -0,0 +1,396 @@
+import { z } from 'zod';
+import type { PluginJournal } from '../../journal/index.js';
+import type { ExtensionRecord } from '../../records/journal.js';
+import type { DeepReadonly } from '../../util/json.js';
+/**
+ * What the journal keeps of a scheduled wake, on the thread it wakes, as `ext` rows of this plugin:
+ * its creation, with its due instant fixed then; its delivery (`fired`), whose write also queues the
+ * input; and its cancellation. Instants are epoch milliseconds.
+ */
+declare const ScheduleRowSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    op: z.ZodLiteral<"created">;
+    id: z.ZodString;
+    due_at: z.ZodNumber;
+    prompt: z.ZodString;
+    reason: z.ZodString;
+    time_zone: z.ZodString;
+    created_at: z.ZodNumber;
+    call_seq: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    op: z.ZodLiteral<"fired">;
+    id: z.ZodString;
+    input_id: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    op: z.ZodLiteral<"cancelled">;
+    id: z.ZodString;
+    reason: z.ZodString;
+}, z.core.$strict>], "op">;
+export type ScheduleRow = z.output<typeof ScheduleRowSchema>;
+export type ScheduleCreated = Extract<ScheduleRow, {
+    op: 'created';
+}>;
+export declare const scheduleRow: {
+    record: (value: {
+        op: "created";
+        id: string;
+        due_at: number;
+        prompt: string;
+        reason: string;
+        time_zone: string;
+        created_at: number;
+        call_seq: number | null;
+    } | {
+        op: "fired";
+        id: string;
+        input_id: string;
+    } | {
+        op: "cancelled";
+        id: string;
+        reason: string;
+    }) => ExtensionRecord;
+    parse: (value: {
+        op: "created";
+        id: string;
+        due_at: number;
+        prompt: string;
+        reason: string;
+        time_zone: string;
+        created_at: number;
+        call_seq: number | null;
+    } | {
+        op: "fired";
+        id: string;
+        input_id: string;
+    } | {
+        op: "cancelled";
+        id: string;
+        reason: string;
+    }) => {
+        op: "created";
+        id: string;
+        due_at: number;
+        prompt: string;
+        reason: string;
+        time_zone: string;
+        created_at: number;
+        call_seq: number | null;
+    } | {
+        op: "fired";
+        id: string;
+        input_id: string;
+    } | {
+        op: "cancelled";
+        id: string;
+        reason: string;
+    };
+    entry: (value: {
+        op: "created";
+        id: string;
+        due_at: number;
+        prompt: string;
+        reason: string;
+        time_zone: string;
+        created_at: number;
+        call_seq: number | null;
+    } | {
+        op: "fired";
+        id: string;
+        input_id: string;
+    } | {
+        op: "cancelled";
+        id: string;
+        reason: string;
+    }, options: import("../../journal/journal.js").AppendOptions) => {
+        type: "ext";
+        data: {
+            plugin: string;
+            instance_id: string;
+            kind: string;
+            version: number;
+            data: z.core.util.JSONType;
+        };
+        options: import("../../journal/journal.js").AppendOptions;
+    };
+    append(journal: PluginJournal, value: {
+        op: "created";
+        id: string;
+        due_at: number;
+        prompt: string;
+        reason: string;
+        time_zone: string;
+        created_at: number;
+        call_seq: number | null;
+    } | {
+        op: "fired";
+        id: string;
+        input_id: string;
+    } | {
+        op: "cancelled";
+        id: string;
+        reason: string;
+    }, options: import("../../journal/journal.js").AppendOptions): Promise<import("../../records/journal.js").JournalEvent<"ext">>;
+    read(event: import("../../records/journal.js").JournalEvent): {
+        op: "created";
+        id: string;
+        due_at: number;
+        prompt: string;
+        reason: string;
+        time_zone: string;
+        created_at: number;
+        call_seq: number | null;
+    } | {
+        op: "fired";
+        id: string;
+        input_id: string;
+    } | {
+        op: "cancelled";
+        id: string;
+        reason: string;
+    } | undefined;
+    contribution(message: {
+        role?: import("../../records/journal.js").InputRole;
+        content: string | readonly import("../../llm/content.js").ContentPartInput[];
+    }, value: {
+        op: "created";
+        id: string;
+        due_at: number;
+        prompt: string;
+        reason: string;
+        time_zone: string;
+        created_at: number;
+        call_seq: number | null;
+    } | {
+        op: "fired";
+        id: string;
+        input_id: string;
+    } | {
+        op: "cancelled";
+        id: string;
+        reason: string;
+    }, options?: {
+        sourceSeqs?: readonly import("../../records/journal.js").Seq[];
+    }): import("../../records/journal.js").StepContribution;
+    matchesSource(record: DeepReadonly<ExtensionRecord>): boolean;
+    rejection(reason: string, value: {
+        op: "created";
+        id: string;
+        due_at: number;
+        prompt: string;
+        reason: string;
+        time_zone: string;
+        created_at: number;
+        call_seq: number | null;
+    } | {
+        op: "fired";
+        id: string;
+        input_id: string;
+    } | {
+        op: "cancelled";
+        id: string;
+        reason: string;
+    }): {
+        decision: "reject";
+        reason: string;
+        source: ExtensionRecord;
+    };
+    readContribution: (event: import("../../records/journal.js").JournalEvent) => {
+        op: "created";
+        id: string;
+        due_at: number;
+        prompt: string;
+        reason: string;
+        time_zone: string;
+        created_at: number;
+        call_seq: number | null;
+    } | {
+        op: "fired";
+        id: string;
+        input_id: string;
+    } | {
+        op: "cancelled";
+        id: string;
+        reason: string;
+    } | undefined;
+    readSource: (source: DeepReadonly<ExtensionRecord> | null) => {
+        op: "created";
+        id: string;
+        due_at: number;
+        prompt: string;
+        reason: string;
+        time_zone: string;
+        created_at: number;
+        call_seq: number | null;
+    } | {
+        op: "fired";
+        id: string;
+        input_id: string;
+    } | {
+        op: "cancelled";
+        id: string;
+        reason: string;
+    } | undefined;
+    told: import("../../journal/projection.js").PluginProjection<import("../../services/extensionEvents.js").ToldNotices<{
+        op: "created";
+        id: string;
+        due_at: number;
+        prompt: string;
+        reason: string;
+        time_zone: string;
+        created_at: number;
+        call_seq: number | null;
+    } | {
+        op: "fired";
+        id: string;
+        input_id: string;
+    } | {
+        op: "cancelled";
+        id: string;
+        reason: string;
+    }>>;
+    projection<State>(fold: {
+        key: string;
+        init(): State;
+        apply(state: State, value: {
+            op: "created";
+            id: string;
+            due_at: number;
+            prompt: string;
+            reason: string;
+            time_zone: string;
+            created_at: number;
+            call_seq: number | null;
+        } | {
+            op: "fired";
+            id: string;
+            input_id: string;
+        } | {
+            op: "cancelled";
+            id: string;
+            reason: string;
+        }, event: import("../../records/journal.js").JournalEvent<"ext">): State;
+        onFork?: "inherit" | "reset";
+    }): import("../../journal/projection.js").PluginProjection<State>;
+};
+/** One scheduled wake as its rows leave it. */
+export type Schedule = {
+    readonly created: ScheduleCreated;
+    /** The input its delivery queued, once delivered. */
+    readonly delivered: string | null;
+    readonly cancelled: boolean;
+};
+/** Where a wake stands: `pending` until it fires, then `fired`, unless cancelled before or after. */
+export type ScheduleStatus = 'pending' | 'fired' | 'cancelled';
+export declare const scheduleStatus: (schedule: Schedule) => ScheduleStatus;
+/** A thread's scheduled wakes, by id. Resets at a fork's spawn row: a fork inherits none. */
+export declare const schedules: import("../../journal/projection.js").PluginProjection<Map<string, Schedule>>;
+/**
+ * What a thread contributes to its catalog entry: the earliest due instant among its pending wakes,
+ * `null` with none, so due work is found from the catalog without loading anything.
+ */
+export declare const nextWake: import("../../services/catalogContributions.js").ContributionDefinition<{
+    next_wake_at: number | null;
+}>;
+/**
+ * When `threadId` next needs a look: `null` for never, and for a thread whose entry cannot be read,
+ * which a later write of its summary corrects.
+ */
+export declare function nextWakeOf(journal: PluginJournal, threadId: string): number | null;
+declare const WakeSourceSchema: z.ZodObject<{
+    schedule_id: z.ZodString;
+    due_at: z.ZodNumber;
+    summary: z.ZodString;
+}, z.core.$strict>;
+export type ScheduledWake = z.output<typeof WakeSourceSchema>;
+/**
+ * The source of a delivered wake: the input a schedule queues on its thread. `summary` is one
+ * bounded line naming the schedule and its reason, for a host to show collapsed.
+ */
+export declare const scheduledWake: {
+    record: (value: {
+        schedule_id: string;
+        due_at: number;
+        summary: string;
+    }) => ExtensionRecord;
+    parse: (value: {
+        schedule_id: string;
+        due_at: number;
+        summary: string;
+    }) => {
+        schedule_id: string;
+        due_at: number;
+        summary: string;
+    };
+    entry: (value: {
+        schedule_id: string;
+        due_at: number;
+        summary: string;
+    }, options: import("../../journal/journal.js").AppendOptions) => {
+        type: "ext";
+        data: {
+            plugin: string;
+            instance_id: string;
+            kind: string;
+            version: number;
+            data: z.core.util.JSONType;
+        };
+        options: import("../../journal/journal.js").AppendOptions;
+    };
+    append(journal: PluginJournal, value: {
+        schedule_id: string;
+        due_at: number;
+        summary: string;
+    }, options: import("../../journal/journal.js").AppendOptions): Promise<import("../../records/journal.js").JournalEvent<"ext">>;
+    read(event: import("../../records/journal.js").JournalEvent): {
+        schedule_id: string;
+        due_at: number;
+        summary: string;
+    } | undefined;
+    contribution(message: {
+        role?: import("../../records/journal.js").InputRole;
+        content: string | readonly import("../../llm/content.js").ContentPartInput[];
+    }, value: {
+        schedule_id: string;
+        due_at: number;
+        summary: string;
+    }, options?: {
+        sourceSeqs?: readonly import("../../records/journal.js").Seq[];
+    }): import("../../records/journal.js").StepContribution;
+    matchesSource(record: DeepReadonly<ExtensionRecord>): boolean;
+    rejection(reason: string, value: {
+        schedule_id: string;
+        due_at: number;
+        summary: string;
+    }): {
+        decision: "reject";
+        reason: string;
+        source: ExtensionRecord;
+    };
+    readContribution: (event: import("../../records/journal.js").JournalEvent) => {
+        schedule_id: string;
+        due_at: number;
+        summary: string;
+    } | undefined;
+    readSource: (source: DeepReadonly<ExtensionRecord> | null) => {
+        schedule_id: string;
+        due_at: number;
+        summary: string;
+    } | undefined;
+    told: import("../../journal/projection.js").PluginProjection<import("../../services/extensionEvents.js").ToldNotices<{
+        schedule_id: string;
+        due_at: number;
+        summary: string;
+    }>>;
+    projection<State>(fold: {
+        key: string;
+        init(): State;
+        apply(state: State, value: {
+            schedule_id: string;
+            due_at: number;
+            summary: string;
+        }, event: import("../../records/journal.js").JournalEvent<"ext">): State;
+        onFork?: "inherit" | "reset";
+    }): import("../../journal/projection.js").PluginProjection<State>;
+};
+/** What a wake's source carries, when `source` is one; `undefined` for any other. For a host drawing it. */
+export declare const readScheduledWake: (source: DeepReadonly<ExtensionRecord> | null) => ScheduledWake | undefined;
+export {};

package/dist/plugins/schedules/service.d.ts

@@ -0,0 +1,120 @@
+import { Service, type Context } from '@leuduan/cordis';
+import { z } from 'zod';
+import type { AppendEntry } from '../../journal/index.js';
+import { type ScheduleStatus } from './record.js';
+declare module '@leuduan/cordis' {
+    interface Context {
+        /** Scheduled wakes of root threads (optional plugin). */
+        schedules: SchedulesService;
+    }
+}
+export declare const SchedulesConfigSchema: z.ZodObject<{
+    clock: z.ZodCustom<import("../../util/timers.js").Clock, import("../../util/timers.js").Clock>;
+    timeZone: z.ZodString;
+    maxDelayMs: z.ZodNumber;
+    maxPendingPerThread: z.ZodNumber;
+}, z.core.$strict>;
+export type SchedulesConfig = z.input<typeof SchedulesConfigSchema>;
+/** What a wake is asked for: when, what to deliver, and one line saying why, for the person. */
+export type ScheduleRequest = {
+    readonly when: {
+        readonly in_seconds: number;
+    } | {
+        readonly at: string;
+    };
+    readonly prompt: string;
+    readonly reason: string;
+};
+/** A wake as a host or a tool reports it. Instants are epoch milliseconds. */
+export type ScheduleInfo = {
+    readonly id: string;
+    readonly threadId: string;
+    readonly dueAt: number;
+    readonly timeZone: string;
+    readonly prompt: string;
+    readonly reason: string;
+    readonly status: ScheduleStatus;
+    /** A fired wake whose delivery is still queued: the conversation has not read it, and a cancel withdraws it. */
+    readonly unread: boolean;
+    readonly createdAt: number;
+};
+/** Why a wake was not created or cancelled, in words for the model or the person. */
+export declare class ScheduleRefusedError extends Error {
+    constructor(message: string);
+}
+export declare const ORIGIN_REFUSAL = "Scheduled wakes are for conversations a person talks to; an agent working for another agent cannot schedule one.";
+/** Why a wake is not created outside a person's turn. */
+export declare const PERSON_TURN_REFUSAL = "A scheduled wake can be created only in a turn a person started, not from a wake or a notice. Tell the person what to schedule, or ask them.";
+/** The wake a `schedule_wake` call creates: its id is the call, so a redispatch finds it. */
+export declare const scheduleIdOf: (callSeq: number) => string;
+/** The input id of a delivery: a redelivery queues nothing. */
+export declare const wakeInputId: (scheduleId: string) => string;
+/** An instant as the model and the person read it: ISO, in UTC, without empty milliseconds. */
+export declare const iso: (instant: number) => string;
+/**
+ * Scheduled wakes: at its due instant a wake delivers its prompt to the root thread that owns it,
+ * as sourced user input with a `fresh` cause, the `fired` record in the same write. A delivery and
+ * a cancel each decide inside their own write, which the journal orders: a cancel that commits
+ * first stops the delivery, and one that commits after it withdraws the delivery, keyed by the
+ * wake, in the same write. Due work is found from the catalog (`next_wake_at`) and kept on one timer queue; at
+ * startup it fires through a repair-only constraint registration. Reasons in `docs/records/schedules.md`.
+ */
+export declare class SchedulesService extends Service<SchedulesConfig> {
+    static inject: string[];
+    readonly config: z.output<typeof SchedulesConfigSchema>;
+    private readonly queue;
+    /** Wake checks, deliveries and cancels in flight, which shutdown waits for. */
+    private readonly inFlight;
+    private refreshed;
+    /** Set once startup's due work is done: rows arm the queue from then on. */
+    private armed;
+    /** Due checks that failed, by thread: the next is put off, not retried at once. */
+    private readonly retries;
+    private closed;
+    constructor(ctx: Context, config: SchedulesConfig);
+    /**
+     * Every wake of `threadId`, oldest first, whatever its status. Synchronous, by a caller that holds
+     * the thread, as `ctx.threads.view` is: a tool running on it, or a host retaining it.
+     */
+    list({ threadId }: {
+        readonly threadId: string;
+    }): ScheduleInfo[];
+    /**
+     * Creates a wake on root thread `threadId`, due within `maxDelayMs`; the per-thread cap and the
+     * due instant are checked again inside its write. `callSeq` is the `tool/call` creating it, whose
+     * redispatch returns the wake it made, whatever would be refused now; the host passes none.
+     * `requirePersonTurn` refuses it unless the thread's open turn has a person's authority, as the
+     * tool asks. Refusals throw {@link ScheduleRefusedError}.
+     */
+    create(threadId: string, request: ScheduleRequest, options?: {
+        readonly callSeq?: number;
+        readonly requirePersonTurn?: boolean;
+    }): Promise<ScheduleInfo>;
+    /**
+     * Cancels wake `id` of `threadId`: it does not fire, and a delivery still queued is withdrawn in
+     * the same write. Resolves with whether one was withdrawn. An unknown id is refused.
+     */
+    cancel(threadId: string, id: string, reason?: string): Promise<{
+        withdrawn: boolean;
+    }>;
+    /**
+     * The rows that cancel every pending wake of `threadId`, for a host's thread `cancel` to carry
+     * (`rows`): built inside that write, which clears the inbox, and so any queued delivery, itself.
+     */
+    cancelRows(threadId: string, reason?: string): AppendEntry<'ext'>[];
+    private thread;
+    /** The `created` row for `request`, its due instant checked against now; refusals throw. */
+    private createdRow;
+    /** Runs `task`, which shutdown waits for while it is in flight. */
+    private track;
+    /** Startup's due work, then arming: run at `start`, or at registration once started. */
+    private catchUp;
+    /** Sets the thread's timer entry from its catalog contribution, which is current when a row's subscriber runs. */
+    private arm;
+    /** Delivers whatever of `threadId`'s wakes is due now; in flight from its entry, so shutdown waits for its read too. */
+    private check;
+    private deliverDue;
+    /** Delivers wake `id`, unless a cancel or another delivery committed first. */
+    private fire;
+    private shutdown;
+}

package/dist/plugins/schedules/time.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Wall-clock times in a recorded IANA zone, computed through `Intl.DateTimeFormat` offsets, with no
+ * dependency. A local time inside a daylight-saving gap occurs at the gap's end, the first valid
+ * instant; a local time that repeats occurs once, at the earlier instant.
+ */
+/** Whether `zone` is an IANA time zone this runtime knows. */
+export declare function validZone(zone: string): boolean;
+/** A wall-clock time in some zone, minute precision. */
+export type LocalTime = {
+    readonly year: number;
+    readonly month: number;
+    readonly day: number;
+    readonly hour: number;
+    readonly minute: number;
+};
+/**
+ * The instant `local` occurs in `zone`: its earlier instant when it repeats, and the end of the gap
+ * when it falls inside one.
+ */
+export declare function instantOf(local: LocalTime, zone: string): number;
+/**
+ * An `at` time: an ISO date and time with an explicit offset (`Z`, `+02:00`), read as given, or
+ * without one, read in `zone`. `null` when it is not such a time, or names a date or time that does
+ * not exist on the calendar (month 13, 30 February, second 61).
+ */
+export declare function parseAt(text: string, zone: string): number | null;

package/dist/plugins/schedules/tools.d.ts

@@ -0,0 +1,6 @@
+import type { Tool } from '../../loop/index.js';
+export declare const scheduleWakeTool: Tool;
+export declare const listWakesTool: Tool;
+export declare const cancelWakeTool: Tool;
+/** The tools `schedules` registers, by name. */
+export declare const SCHEDULE_TOOLS: readonly ["schedule_wake", "list_wakes", "cancel_wake"];

package/dist/plugins/skills/discovery.d.ts

@@ -0,0 +1,83 @@
+import type { FileScope } from '../../services/confinement/files.js';
+export type SkillDocument = {
+    name: string;
+    directoryName: string;
+    path: string;
+    description: string;
+    whenToUse: string;
+    aliases: string[];
+    body: string;
+    frontmatter: Record<string, unknown>;
+};
+/** Splits a `SKILL.md` into its YAML frontmatter and body. */
+export declare function parseFrontmatter(text: string): {
+    frontmatter: Record<string, unknown>;
+    body: string;
+};
+/** Where a thread's own skills live, relative to its `cwd`, searched before the host's roots. */
+export declare const DEFAULT_WORKSPACE_SKILL_ROOTS: readonly string[];
+/**
+ * The user's own skill root under `home`, `<home>/.claude/skills`, for a host to pass as a root of
+ * its own: lagent never looks in a home directory by itself.
+ */
+export declare const userSkillRoots: (home: string) => string[];
+/** A thread's search order: its workspace roots under `cwd` first, then the host's absolute roots. */
+export declare function resolveSkillRoots(cwd: string, roots: {
+    readonly workspace: readonly string[];
+    readonly host: readonly string[];
+}): string[];
+/**
+ * A skill document that cannot be used as it is: not a regular file, too large, or its frontmatter does
+ * not parse. Never a refusal, a missing file or a stop: those are the facade's own errors.
+ */
+export declare class SkillDocumentError extends Error {
+    constructor(message: string, options?: ErrorOptions);
+}
+/**
+ * Reads the skill document at `path` through `files`, the verified handle and the policy of the
+ * operation it belongs to, which is the one way any skill file is read.
+ */
+export declare function readSkillDocument(files: FileScope, path: string, directoryName: string): Promise<SkillDocument>;
+/** A file or directory discovery skipped, and why. */
+export type SkippedSkill = {
+    readonly path: string;
+    readonly reason: string;
+};
+/**
+ * Walks the roots for `SKILL.md` files, through `files`; the first skill claiming a name or alias
+ * wins. A document that cannot be read or parsed, a directory that cannot be listed and a root the
+ * policy refuses are skipped and passed to `skipped`, so one broken skill never hides the others. A
+ * root that does not exist is not a problem. Nothing here touches the file system but through `files`.
+ */
+export declare function discoverSkills(files: FileScope, roots: readonly string[], skipped?: (skip: SkippedSkill) => void, signal?: AbortSignal): Promise<SkillDocument[]>;
+/**
+ * What one thread's activation found: the roots it searched from its `cwd`, and the skills in them,
+ * read under one policy (`identity`) at one state of the confinement (`epoch`). Content read under
+ * another is not delivered: see the `skill` tool and the listing.
+ */
+export type SkillCatalog = {
+    readonly workspaceRoot: string;
+    readonly roots: readonly string[];
+    readonly skills: readonly SkillDocument[];
+    /** How the facade it was read through judged reads (`FileScope.identity`). */
+    readonly identity: string;
+    /** `ConfinementService.epoch` before it was read. */
+    readonly epoch: number;
+    /** Why there is no catalog, when the operation it needed was refused; else `null`. */
+    readonly unavailable: string | null;
+};
+/**
+ * Searches the roots for a thread working in `cwd`, once, through `files`: everything after reads
+ * the result. What discovery skipped goes to `skipped`.
+ */
+export declare function prepareSkillCatalog(files: FileScope, cwd: string, roots: {
+    readonly workspace: readonly string[];
+    readonly host: readonly string[];
+}, noted: {
+    readonly identity: string;
+    readonly epoch: number;
+}, skipped?: (skip: SkippedSkill) => void, signal?: AbortSignal): Promise<SkillCatalog>;
+/** The catalog of a thread whose operation was refused: no skills, and why. */
+export declare const unavailableCatalog: (cwd: string, epoch: number, reason: string) => SkillCatalog;
+/** The catalog as the model reads it: one line per skill, paths relative to the workspace where inside it. */
+export declare function formatSkillListing({ skills, workspaceRoot, roots }: SkillCatalog): string;

package/dist/plugins/skills/index.d.ts

@@ -0,0 +1,31 @@
+import { type Plugin } from '@leuduan/cordis';
+import { z } from 'zod';
+export { DEFAULT_WORKSPACE_SKILL_ROOTS, userSkillRoots } from './discovery.js';
+export { SKILL_TOOL } from './tools.js';
+declare const SkillsConfigSchema: z.ZodObject<{
+    roots: z.ZodArray<z.ZodString>;
+    workspaceRoots: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    agents: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodLiteral<"global">, z.ZodLiteral<"all">]>>;
+    autoload: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export type SkillsConfig = z.input<typeof SkillsConfigSchema>;
+/**
+ * Filesystem-backed skills: the `skill` tool that loads one by name, and the prompt listing that
+ * tells an agent that may call it which are available. The roots outside a workspace are the host's,
+ * so the host mounts it, once, on the root, and a preset such as `codexPreset` grants the tool.
+ *
+ * A thread's activation gets the catalog of its `cwd` and keeps it for as long as it lives: the
+ * prompt listing, the tool's listing and its loads all read that one snapshot, skill bodies
+ * included, and nothing searches the filesystem while a prompt is rendered or a call runs. The
+ * roots are searched when an activation finds no live activation in the same workspace holding a
+ * catalog, which it otherwise shares; the last activation to hold one drops it, so a root mount
+ * serving several workspaces holds at most one catalog per workspace with a live activation. A
+ * document that cannot be read or parsed is skipped and reported once through `reportError`; it
+ * never fails an activation. Rebuild rule: an activation in a workspace no live activation holds
+ * searches again; `rebuildPrompt` re-renders from the current activation's catalog, so a skill added
+ * since is listed only once the workspace's activations have all gone and the thread is activated
+ * afresh (a configuration change, a release, a restart). A fork inherits its source's recorded
+ * prompt, listing included, while its own activation may hold a newer catalog, which its `skill`
+ * calls then read.
+ */
+export declare const skills: Plugin.Object<SkillsConfig>;

package/dist/plugins/skills/index.js

@@ -0,0 +1 @@
+import{a,b,c,d}from"../../chunks/2P47AHNK.js";import"../../chunks/VYMT4TXD.js";import"../../chunks/3UMZMPWW.js";import"../../chunks/34KW6VNQ.js";import"../../chunks/JFX2MXBA.js";import"../../chunks/S34ZA2R6.js";import"../../chunks/CUK7CGC7.js";import"../../chunks/BPRCULZH.js";import"../../chunks/FJLU4UH3.js";import"../../chunks/DDANMY45.js";import"../../chunks/BBCW2FZK.js";import"../../chunks/MMNNZCBO.js";import"../../chunks/G44LG6VL.js";import"../../chunks/D4PQP5MA.js";export{a as DEFAULT_WORKSPACE_SKILL_ROOTS,c as SKILL_TOOL,d as skills,b as userSkillRoots};

package/dist/plugins/skills/tools.d.ts

@@ -0,0 +1,11 @@
+import type { Tool } from '../../loop/index.js';
+import { type SkillCatalog } from './discovery.js';
+/** The tool's name, which a preset grants. */
+export declare const SKILL_TOOL = "skill";
+/**
+ * Loads filesystem-backed skills on demand; contents are returned only when asked for by name.
+ * `catalogOf` gives the calling thread's catalog, the one its activation prepared, so a call lists
+ * and loads what the prompt listed rather than searching again; `undefined` for a thread activated
+ * before the catalog's owner was mounted.
+ */
+export declare const skillTool: (catalogOf: (threadId: string) => SkillCatalog | undefined) => Tool;