@modexagents/core 0.3.1

package/dist/index.d.ts

@@ -0,0 +1,1230 @@
+import { z } from 'zod';
+import Anthropic from '@anthropic-ai/sdk';
+
+declare const SCHEMA_VERSION = 0;
+declare const SkillSchema: z.ZodObject<{
+    slug: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    tags: z.ZodArray<z.ZodString, "many">;
+    source: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    slug: string;
+    name: string;
+    description: string;
+    tags: string[];
+    source: string;
+}, {
+    slug: string;
+    name: string;
+    description: string;
+    tags: string[];
+    source: string;
+}>;
+type Skill = z.infer<typeof SkillSchema>;
+declare const SkillsDocSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<0>;
+    skills: z.ZodArray<z.ZodObject<{
+        slug: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        tags: z.ZodArray<z.ZodString, "many">;
+        source: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        slug: string;
+        name: string;
+        description: string;
+        tags: string[];
+        source: string;
+    }, {
+        slug: string;
+        name: string;
+        description: string;
+        tags: string[];
+        source: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    schema_version: 0;
+    skills: {
+        slug: string;
+        name: string;
+        description: string;
+        tags: string[];
+        source: string;
+    }[];
+}, {
+    schema_version: 0;
+    skills: {
+        slug: string;
+        name: string;
+        description: string;
+        tags: string[];
+        source: string;
+    }[];
+}>;
+type SkillsDoc = z.infer<typeof SkillsDocSchema>;
+declare const ExtractedSkillSchema: z.ZodObject<Omit<{
+    slug: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    tags: z.ZodArray<z.ZodString, "many">;
+    source: z.ZodString;
+}, "source">, "strip", z.ZodTypeAny, {
+    slug: string;
+    name: string;
+    description: string;
+    tags: string[];
+}, {
+    slug: string;
+    name: string;
+    description: string;
+    tags: string[];
+}>;
+type ExtractedSkill = z.infer<typeof ExtractedSkillSchema>;
+declare const ExtractionResultSchema: z.ZodObject<{
+    skills: z.ZodArray<z.ZodObject<Omit<{
+        slug: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        tags: z.ZodArray<z.ZodString, "many">;
+        source: z.ZodString;
+    }, "source">, "strip", z.ZodTypeAny, {
+        slug: string;
+        name: string;
+        description: string;
+        tags: string[];
+    }, {
+        slug: string;
+        name: string;
+        description: string;
+        tags: string[];
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    skills: {
+        slug: string;
+        name: string;
+        description: string;
+        tags: string[];
+    }[];
+}, {
+    skills: {
+        slug: string;
+        name: string;
+        description: string;
+        tags: string[];
+    }[];
+}>;
+type ExtractionResult = z.infer<typeof ExtractionResultSchema>;
+
+/**
+ * Serialize a SkillsDoc to canonical SKILLS.md.
+ *
+ * Stability rules (load-bearing — later phases hash this output):
+ * - LF line endings, single trailing newline
+ * - Skills sorted ascending by slug (UTF-16 code units)
+ * - Tags sorted ascending, joined by ", "
+ * - Field order fixed: Name, Description, Tags, Source
+ * - Frontmatter limited to schema_version
+ */
+declare function serialize(doc: SkillsDoc): string;
+declare function buildDoc(skills: Skill[]): SkillsDoc;
+
+declare class ExtractionError extends Error {
+    readonly cause?: unknown;
+    constructor(message: string, cause?: unknown);
+}
+interface ExtractOptions {
+    source: string;
+    apiKey?: string;
+    model?: string;
+    maxTokens?: number;
+    client?: Anthropic;
+}
+declare function extractSkills(corpus: string, opts: ExtractOptions): Promise<Skill[]>;
+
+declare const DEFAULT_LOCK_TIMEOUT_MS = 10000;
+declare const DEFAULT_STALE_MS = 30000;
+declare class FileLockError extends Error {
+    constructor(message: string);
+}
+interface LockOptions {
+    timeoutMs?: number;
+    staleMs?: number;
+    now?: () => number;
+}
+declare function withFileLock<T>(targetPath: string, fn: () => Promise<T>, opts?: LockOptions): Promise<T>;
+
+declare const PROVENANCE_SCHEMA_VERSION = 1;
+declare const SOURCE_KINDS: readonly ["text", "markdown", "pdf", "epub", "web"];
+type SourceKind = (typeof SOURCE_KINDS)[number];
+declare const FeedInputSchema: z.ZodObject<{
+    source: z.ZodString;
+    source_url: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+    source_kind: z.ZodEnum<["text", "markdown", "pdf", "epub", "web"]>;
+    source_sha256: z.ZodString;
+    source_bytes: z.ZodNumber;
+    model: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    source: string;
+    model: string;
+    source_url: string | null;
+    source_kind: "text" | "markdown" | "pdf" | "epub" | "web";
+    source_sha256: string;
+    source_bytes: number;
+}, {
+    source: string;
+    model: string;
+    source_url: string | null;
+    source_kind: "text" | "markdown" | "pdf" | "epub" | "web";
+    source_sha256: string;
+    source_bytes: number;
+}>;
+declare const FeedOutputSchema: z.ZodObject<{
+    skills_added: z.ZodArray<z.ZodString, "many">;
+    skills_updated: z.ZodArray<z.ZodString, "many">;
+    skills_removed: z.ZodArray<z.ZodString, "many">;
+    skills_md_sha256: z.ZodString;
+    skills_md_bytes: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    skills_added: string[];
+    skills_updated: string[];
+    skills_removed: string[];
+    skills_md_sha256: string;
+    skills_md_bytes: number;
+}, {
+    skills_added: string[];
+    skills_updated: string[];
+    skills_removed: string[];
+    skills_md_sha256: string;
+    skills_md_bytes: number;
+}>;
+declare const AgentCreatedInputSchema: z.ZodObject<{
+    name: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+}, {
+    name: string;
+}>;
+declare const AgentCreatedOutputSchema: z.ZodObject<{
+    agent_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    agent_id: string;
+}, {
+    agent_id: string;
+}>;
+declare const BoundInputSchema: z.ZodObject<{
+    skills_md_sha256: z.ZodString;
+    aspiration_sha256s: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    skills_md_sha256: string;
+    aspiration_sha256s: string[];
+}, {
+    skills_md_sha256: string;
+    aspiration_sha256s: string[];
+}>;
+declare const BoundOutputSchema: z.ZodObject<{
+    registry_url: z.ZodString;
+    bound_at: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    registry_url: string;
+    bound_at: string;
+}, {
+    registry_url: string;
+    bound_at: string;
+}>;
+declare const AspirationAddedInputSchema: z.ZodObject<{
+    aspiration_sha256: z.ZodString;
+    aspiration_bytes: z.ZodNumber;
+    source: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    source: string;
+    aspiration_sha256: string;
+    aspiration_bytes: number;
+}, {
+    source: string;
+    aspiration_sha256: string;
+    aspiration_bytes: number;
+}>;
+declare const AspirationAddedOutputSchema: z.ZodObject<{
+    registry_url: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    registry_url: string;
+}, {
+    registry_url: string;
+}>;
+declare const FeedEntrySchema: z.ZodObject<{
+    kind: z.ZodLiteral<"feed">;
+    input: z.ZodObject<{
+        source: z.ZodString;
+        source_url: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+        source_kind: z.ZodEnum<["text", "markdown", "pdf", "epub", "web"]>;
+        source_sha256: z.ZodString;
+        source_bytes: z.ZodNumber;
+        model: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        source: string;
+        model: string;
+        source_url: string | null;
+        source_kind: "text" | "markdown" | "pdf" | "epub" | "web";
+        source_sha256: string;
+        source_bytes: number;
+    }, {
+        source: string;
+        model: string;
+        source_url: string | null;
+        source_kind: "text" | "markdown" | "pdf" | "epub" | "web";
+        source_sha256: string;
+        source_bytes: number;
+    }>;
+    output: z.ZodObject<{
+        skills_added: z.ZodArray<z.ZodString, "many">;
+        skills_updated: z.ZodArray<z.ZodString, "many">;
+        skills_removed: z.ZodArray<z.ZodString, "many">;
+        skills_md_sha256: z.ZodString;
+        skills_md_bytes: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        skills_added: string[];
+        skills_updated: string[];
+        skills_removed: string[];
+        skills_md_sha256: string;
+        skills_md_bytes: number;
+    }, {
+        skills_added: string[];
+        skills_updated: string[];
+        skills_removed: string[];
+        skills_md_sha256: string;
+        skills_md_bytes: number;
+    }>;
+    schema_version: z.ZodLiteral<1>;
+    seq: z.ZodNumber;
+    ts: z.ZodString;
+    prev: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+    entry_sha256: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    schema_version: 1;
+    kind: "feed";
+    input: {
+        source: string;
+        model: string;
+        source_url: string | null;
+        source_kind: "text" | "markdown" | "pdf" | "epub" | "web";
+        source_sha256: string;
+        source_bytes: number;
+    };
+    output: {
+        skills_added: string[];
+        skills_updated: string[];
+        skills_removed: string[];
+        skills_md_sha256: string;
+        skills_md_bytes: number;
+    };
+    seq: number;
+    ts: string;
+    prev: string | null;
+    entry_sha256: string;
+}, {
+    schema_version: 1;
+    kind: "feed";
+    input: {
+        source: string;
+        model: string;
+        source_url: string | null;
+        source_kind: "text" | "markdown" | "pdf" | "epub" | "web";
+        source_sha256: string;
+        source_bytes: number;
+    };
+    output: {
+        skills_added: string[];
+        skills_updated: string[];
+        skills_removed: string[];
+        skills_md_sha256: string;
+        skills_md_bytes: number;
+    };
+    seq: number;
+    ts: string;
+    prev: string | null;
+    entry_sha256: string;
+}>;
+declare const AgentCreatedEntrySchema: z.ZodObject<{
+    kind: z.ZodLiteral<"agent_created">;
+    input: z.ZodObject<{
+        name: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+    }, {
+        name: string;
+    }>;
+    output: z.ZodObject<{
+        agent_id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        agent_id: string;
+    }, {
+        agent_id: string;
+    }>;
+    schema_version: z.ZodLiteral<1>;
+    seq: z.ZodNumber;
+    ts: z.ZodString;
+    prev: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+    entry_sha256: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    schema_version: 1;
+    kind: "agent_created";
+    input: {
+        name: string;
+    };
+    output: {
+        agent_id: string;
+    };
+    seq: number;
+    ts: string;
+    prev: string | null;
+    entry_sha256: string;
+}, {
+    schema_version: 1;
+    kind: "agent_created";
+    input: {
+        name: string;
+    };
+    output: {
+        agent_id: string;
+    };
+    seq: number;
+    ts: string;
+    prev: string | null;
+    entry_sha256: string;
+}>;
+declare const BoundEntrySchema: z.ZodObject<{
+    kind: z.ZodLiteral<"bound">;
+    input: z.ZodObject<{
+        skills_md_sha256: z.ZodString;
+        aspiration_sha256s: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        skills_md_sha256: string;
+        aspiration_sha256s: string[];
+    }, {
+        skills_md_sha256: string;
+        aspiration_sha256s: string[];
+    }>;
+    output: z.ZodObject<{
+        registry_url: z.ZodString;
+        bound_at: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        registry_url: string;
+        bound_at: string;
+    }, {
+        registry_url: string;
+        bound_at: string;
+    }>;
+    schema_version: z.ZodLiteral<1>;
+    seq: z.ZodNumber;
+    ts: z.ZodString;
+    prev: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+    entry_sha256: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    schema_version: 1;
+    kind: "bound";
+    input: {
+        skills_md_sha256: string;
+        aspiration_sha256s: string[];
+    };
+    output: {
+        registry_url: string;
+        bound_at: string;
+    };
+    seq: number;
+    ts: string;
+    prev: string | null;
+    entry_sha256: string;
+}, {
+    schema_version: 1;
+    kind: "bound";
+    input: {
+        skills_md_sha256: string;
+        aspiration_sha256s: string[];
+    };
+    output: {
+        registry_url: string;
+        bound_at: string;
+    };
+    seq: number;
+    ts: string;
+    prev: string | null;
+    entry_sha256: string;
+}>;
+declare const AspirationAddedEntrySchema: z.ZodObject<{
+    kind: z.ZodLiteral<"aspiration_added">;
+    input: z.ZodObject<{
+        aspiration_sha256: z.ZodString;
+        aspiration_bytes: z.ZodNumber;
+        source: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        source: string;
+        aspiration_sha256: string;
+        aspiration_bytes: number;
+    }, {
+        source: string;
+        aspiration_sha256: string;
+        aspiration_bytes: number;
+    }>;
+    output: z.ZodObject<{
+        registry_url: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        registry_url: string;
+    }, {
+        registry_url: string;
+    }>;
+    schema_version: z.ZodLiteral<1>;
+    seq: z.ZodNumber;
+    ts: z.ZodString;
+    prev: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+    entry_sha256: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    schema_version: 1;
+    kind: "aspiration_added";
+    input: {
+        source: string;
+        aspiration_sha256: string;
+        aspiration_bytes: number;
+    };
+    output: {
+        registry_url: string;
+    };
+    seq: number;
+    ts: string;
+    prev: string | null;
+    entry_sha256: string;
+}, {
+    schema_version: 1;
+    kind: "aspiration_added";
+    input: {
+        source: string;
+        aspiration_sha256: string;
+        aspiration_bytes: number;
+    };
+    output: {
+        registry_url: string;
+    };
+    seq: number;
+    ts: string;
+    prev: string | null;
+    entry_sha256: string;
+}>;
+declare const ProvenanceEntrySchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+    kind: z.ZodLiteral<"feed">;
+    input: z.ZodObject<{
+        source: z.ZodString;
+        source_url: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+        source_kind: z.ZodEnum<["text", "markdown", "pdf", "epub", "web"]>;
+        source_sha256: z.ZodString;
+        source_bytes: z.ZodNumber;
+        model: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        source: string;
+        model: string;
+        source_url: string | null;
+        source_kind: "text" | "markdown" | "pdf" | "epub" | "web";
+        source_sha256: string;
+        source_bytes: number;
+    }, {
+        source: string;
+        model: string;
+        source_url: string | null;
+        source_kind: "text" | "markdown" | "pdf" | "epub" | "web";
+        source_sha256: string;
+        source_bytes: number;
+    }>;
+    output: z.ZodObject<{
+        skills_added: z.ZodArray<z.ZodString, "many">;
+        skills_updated: z.ZodArray<z.ZodString, "many">;
+        skills_removed: z.ZodArray<z.ZodString, "many">;
+        skills_md_sha256: z.ZodString;
+        skills_md_bytes: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        skills_added: string[];
+        skills_updated: string[];
+        skills_removed: string[];
+        skills_md_sha256: string;
+        skills_md_bytes: number;
+    }, {
+        skills_added: string[];
+        skills_updated: string[];
+        skills_removed: string[];
+        skills_md_sha256: string;
+        skills_md_bytes: number;
+    }>;
+    schema_version: z.ZodLiteral<1>;
+    seq: z.ZodNumber;
+    ts: z.ZodString;
+    prev: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+    entry_sha256: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    schema_version: 1;
+    kind: "feed";
+    input: {
+        source: string;
+        model: string;
+        source_url: string | null;
+        source_kind: "text" | "markdown" | "pdf" | "epub" | "web";
+        source_sha256: string;
+        source_bytes: number;
+    };
+    output: {
+        skills_added: string[];
+        skills_updated: string[];
+        skills_removed: string[];
+        skills_md_sha256: string;
+        skills_md_bytes: number;
+    };
+    seq: number;
+    ts: string;
+    prev: string | null;
+    entry_sha256: string;
+}, {
+    schema_version: 1;
+    kind: "feed";
+    input: {
+        source: string;
+        model: string;
+        source_url: string | null;
+        source_kind: "text" | "markdown" | "pdf" | "epub" | "web";
+        source_sha256: string;
+        source_bytes: number;
+    };
+    output: {
+        skills_added: string[];
+        skills_updated: string[];
+        skills_removed: string[];
+        skills_md_sha256: string;
+        skills_md_bytes: number;
+    };
+    seq: number;
+    ts: string;
+    prev: string | null;
+    entry_sha256: string;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"agent_created">;
+    input: z.ZodObject<{
+        name: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+    }, {
+        name: string;
+    }>;
+    output: z.ZodObject<{
+        agent_id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        agent_id: string;
+    }, {
+        agent_id: string;
+    }>;
+    schema_version: z.ZodLiteral<1>;
+    seq: z.ZodNumber;
+    ts: z.ZodString;
+    prev: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+    entry_sha256: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    schema_version: 1;
+    kind: "agent_created";
+    input: {
+        name: string;
+    };
+    output: {
+        agent_id: string;
+    };
+    seq: number;
+    ts: string;
+    prev: string | null;
+    entry_sha256: string;
+}, {
+    schema_version: 1;
+    kind: "agent_created";
+    input: {
+        name: string;
+    };
+    output: {
+        agent_id: string;
+    };
+    seq: number;
+    ts: string;
+    prev: string | null;
+    entry_sha256: string;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"bound">;
+    input: z.ZodObject<{
+        skills_md_sha256: z.ZodString;
+        aspiration_sha256s: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        skills_md_sha256: string;
+        aspiration_sha256s: string[];
+    }, {
+        skills_md_sha256: string;
+        aspiration_sha256s: string[];
+    }>;
+    output: z.ZodObject<{
+        registry_url: z.ZodString;
+        bound_at: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        registry_url: string;
+        bound_at: string;
+    }, {
+        registry_url: string;
+        bound_at: string;
+    }>;
+    schema_version: z.ZodLiteral<1>;
+    seq: z.ZodNumber;
+    ts: z.ZodString;
+    prev: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+    entry_sha256: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    schema_version: 1;
+    kind: "bound";
+    input: {
+        skills_md_sha256: string;
+        aspiration_sha256s: string[];
+    };
+    output: {
+        registry_url: string;
+        bound_at: string;
+    };
+    seq: number;
+    ts: string;
+    prev: string | null;
+    entry_sha256: string;
+}, {
+    schema_version: 1;
+    kind: "bound";
+    input: {
+        skills_md_sha256: string;
+        aspiration_sha256s: string[];
+    };
+    output: {
+        registry_url: string;
+        bound_at: string;
+    };
+    seq: number;
+    ts: string;
+    prev: string | null;
+    entry_sha256: string;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"aspiration_added">;
+    input: z.ZodObject<{
+        aspiration_sha256: z.ZodString;
+        aspiration_bytes: z.ZodNumber;
+        source: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        source: string;
+        aspiration_sha256: string;
+        aspiration_bytes: number;
+    }, {
+        source: string;
+        aspiration_sha256: string;
+        aspiration_bytes: number;
+    }>;
+    output: z.ZodObject<{
+        registry_url: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        registry_url: string;
+    }, {
+        registry_url: string;
+    }>;
+    schema_version: z.ZodLiteral<1>;
+    seq: z.ZodNumber;
+    ts: z.ZodString;
+    prev: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+    entry_sha256: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    schema_version: 1;
+    kind: "aspiration_added";
+    input: {
+        source: string;
+        aspiration_sha256: string;
+        aspiration_bytes: number;
+    };
+    output: {
+        registry_url: string;
+    };
+    seq: number;
+    ts: string;
+    prev: string | null;
+    entry_sha256: string;
+}, {
+    schema_version: 1;
+    kind: "aspiration_added";
+    input: {
+        source: string;
+        aspiration_sha256: string;
+        aspiration_bytes: number;
+    };
+    output: {
+        registry_url: string;
+    };
+    seq: number;
+    ts: string;
+    prev: string | null;
+    entry_sha256: string;
+}>]>;
+declare const KNOWN_ENTRY_KINDS: readonly ["feed", "agent_created", "bound", "aspiration_added"];
+type FeedEntry = z.infer<typeof FeedEntrySchema>;
+type AgentCreatedEntry = z.infer<typeof AgentCreatedEntrySchema>;
+type BoundEntry = z.infer<typeof BoundEntrySchema>;
+type AspirationAddedEntry = z.infer<typeof AspirationAddedEntrySchema>;
+type ProvenanceEntry = z.infer<typeof ProvenanceEntrySchema>;
+type EntryDraft = {
+    kind: 'feed';
+    input: z.input<typeof FeedInputSchema>;
+    output: z.input<typeof FeedOutputSchema>;
+    ts?: string;
+} | {
+    kind: 'agent_created';
+    input: z.input<typeof AgentCreatedInputSchema>;
+    output: z.input<typeof AgentCreatedOutputSchema>;
+    ts?: string;
+} | {
+    kind: 'bound';
+    input: z.input<typeof BoundInputSchema>;
+    output: z.input<typeof BoundOutputSchema>;
+    ts?: string;
+} | {
+    kind: 'aspiration_added';
+    input: z.input<typeof AspirationAddedInputSchema>;
+    output: z.input<typeof AspirationAddedOutputSchema>;
+    ts?: string;
+};
+declare class ProvenanceError extends Error {
+    constructor(message: string);
+}
+declare function computeEntryHash(entry: Omit<ProvenanceEntry, 'entry_sha256'>): string;
+declare function readChain(path: string): Promise<ProvenanceEntry[]>;
+declare function verifyChain(entries: readonly ProvenanceEntry[]): void;
+interface RecordEntryOptions {
+    path: string;
+    draft: EntryDraft;
+    ts?: string;
+    prev?: string | null;
+    seq?: number;
+    lock?: LockOptions;
+}
+declare function recordEntry(opts: RecordEntryOptions): Promise<ProvenanceEntry>;
+
+interface LoadedSource {
+    source: string;
+    source_url: string | null;
+    source_kind: SourceKind;
+    content: string;
+}
+declare class SourceError extends Error {
+    constructor(message: string);
+}
+
+declare function isWebUrl(target: string): boolean;
+declare function readSource(target: string): Promise<LoadedSource>;
+
+declare function normalizeUrl(input: string): string;
+
+interface ExpandOptions {
+    cwd?: string;
+}
+declare function expandPatterns(patterns: readonly string[], opts?: ExpandOptions): Promise<string[]>;
+
+declare const MODEL_ID = "claude-haiku-4-5-20251001";
+declare const EMIT_SKILLS_TOOL: {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: {
+            skills: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        slug: {
+                            type: string;
+                            pattern: string;
+                            maxLength: number;
+                            description: string;
+                        };
+                        name: {
+                            type: string;
+                            minLength: number;
+                            maxLength: number;
+                            description: string;
+                        };
+                        description: {
+                            type: string;
+                            minLength: number;
+                            maxLength: number;
+                            description: string;
+                        };
+                        tags: {
+                            type: string;
+                            minItems: number;
+                            maxItems: number;
+                            items: {
+                                type: string;
+                                pattern: string;
+                                maxLength: number;
+                            };
+                            description: string;
+                        };
+                    };
+                    required: string[];
+                    additionalProperties: boolean;
+                };
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+};
+declare const SYSTEM_PROMPT = "You are an extraction engine that reads a corpus and produces a structured set of distinct skills.\n\nA \"skill\" is a transferable, reusable practice or technique that a person could apply across contexts \u2014 not a fact, definition, story, or one-off opinion.\n\nFor every skill you identify, emit:\n- slug: kebab-case identifier matching ^[a-z0-9]+(-[a-z0-9]+)*$, unique within this output\n- name: short human-readable title (3-8 words; Title Case acceptable)\n- description: one paragraph (1-4 sentences), self-contained, written as a directly applicable instruction\n- tags: 1-6 kebab-case topical labels matching ^[a-z0-9]+(-[a-z0-9]+)*$\n\nQuality rules:\n- Only emit skills that are clearly supported by the corpus.\n- Do not invent skills to pad the list. Returning fewer high-quality skills is preferred to many vague ones.\n- Avoid near-duplicates. If two passages describe the same underlying technique, emit one skill.\n- Do not include source citations, page numbers, or quotes in the description.\n- The description must stand on its own; a reader who has not seen the corpus must be able to apply the skill.\n\nAlways respond by calling the emit_skills tool exactly once with the full result. Do not include any text outside the tool call.";
+
+declare class ParseSkillsError extends Error {
+    constructor(message: string);
+}
+declare function parseSkills(input: string): SkillsDoc;
+
+interface MergeResult {
+    merged: Skill[];
+    added: string[];
+    updated: string[];
+}
+declare function mergeSkills(existing: readonly Skill[], incoming: readonly Skill[]): MergeResult;
+
+type CanonicalJson = string | number | boolean | null | CanonicalJson[] | {
+    [key: string]: CanonicalJson;
+};
+declare class CanonicalJsonError extends Error {
+    constructor(message: string);
+}
+declare function canonicalize(value: CanonicalJson): string;
+
+interface FeedOptions {
+    model?: string;
+    baseDir?: string;
+    client?: unknown;
+    apiKey?: string;
+    ts?: string | (() => string);
+    loadSource?: (target: string) => Promise<LoadedSource>;
+    stdout?: NodeJS.WritableStream;
+    stderr?: NodeJS.WritableStream;
+}
+interface PerSourceResult {
+    target: string;
+    source: string;
+    added: string[];
+    updated: string[];
+    skillsMdSha256: string;
+    skillsMdBytes: number;
+    estimatedTokens: number;
+    warnedOverCap: boolean;
+}
+interface FeedResult {
+    agentId: string;
+    perSource: PerSourceResult[];
+}
+/**
+ * Run a batch of feeds: expand patterns, then for each resolved source
+ * sequentially read → extract → merge → write skills.md → append a feed
+ * entry to provenance.jsonl.
+ *
+ * Sequential is load-bearing: the provenance chain depends on a single
+ * writer per agent (see provenance.ts). Stop-on-first-error is fine
+ * because each source's provenance entry lands before the next runs, so
+ * partial progress is always durable.
+ *
+ * Crash-window note: writeSkillsAtomic happens before recordEntry. A crash
+ * (or kill -9) between the two leaves skills.md ahead of the chain by one
+ * feed. Recovery is benign — the next feed of the same source produces an
+ * identical-content merge (no-op) and a new chain entry, or, if the source
+ * differs, an "updated" entry. The chain stays valid; the on-disk skills.md
+ * is just slightly more current than the chain's last feed entry claims.
+ */
+declare function runFeed(agentId: string, patterns: readonly string[], opts?: FeedOptions): Promise<FeedResult>;
+declare function isFeedError(err: unknown): err is Error;
+
+interface AgentsCreateOptions {
+    name?: string;
+    baseDir?: string;
+    stdout?: NodeJS.WritableStream;
+}
+declare function runAgentsCreate(opts?: AgentsCreateOptions): Promise<string>;
+interface AgentsListOptions {
+    baseDir?: string;
+    stdout?: NodeJS.WritableStream;
+}
+declare function runAgentsList(opts?: AgentsListOptions): Promise<void>;
+
+interface LoginOptions {
+    registry?: string;
+    configDir?: string;
+    fetch?: typeof globalThis.fetch;
+    sleep?: (ms: number) => Promise<void>;
+    now?: () => number;
+    stdout?: NodeJS.WritableStream;
+    stderr?: NodeJS.WritableStream;
+}
+interface LoginResult {
+    registryUrl: string;
+}
+declare function runLogin(opts?: LoginOptions): Promise<LoginResult>;
+interface LogoutOptions {
+    configDir?: string;
+    stdout?: NodeJS.WritableStream;
+}
+declare function runLogout(opts?: LogoutOptions): Promise<void>;
+declare function isLoginError(err: unknown): err is Error;
+
+interface BindOptions {
+    baseDir?: string;
+    configDir?: string;
+    fetch?: typeof globalThis.fetch;
+    ts?: string;
+    stdout?: NodeJS.WritableStream;
+    stderr?: NodeJS.WritableStream;
+}
+interface BindResult {
+    agentId: string;
+    registryUrl: string;
+    skillsMdSha256: string;
+    boundAt: string;
+}
+/**
+ * Bind a local agent to the registry it was logged into.
+ *
+ * Ordering: the registry POST happens first; the local `bound` provenance
+ * entry and registry.json are written only on a 2xx. This keeps the local
+ * chain a subset of registry truth — a crash after a successful POST but
+ * before the local write is benign, because a re-run is a same-user re-bind
+ * (allowed by the registry) and simply records the entry then.
+ */
+declare function runBind(agentId: string, opts?: BindOptions): Promise<BindResult>;
+declare function isBindError(err: unknown): err is Error;
+
+interface AspirationsAddOptions {
+    baseDir?: string;
+    configDir?: string;
+    fetch?: typeof globalThis.fetch;
+    ts?: string;
+    stdout?: NodeJS.WritableStream;
+    stderr?: NodeJS.WritableStream;
+}
+interface AspirationsAddResult {
+    agentId: string;
+    registryUrl: string;
+    aspirationSha256: string;
+    source: string;
+}
+/**
+ * Append an aspiration to a bound agent.
+ *
+ * Append-only: there is deliberately no edit or delete operation — the
+ * registry rejects mutation and so does this surface by omission.
+ *
+ * Requires a prior bind: we check the local registry.json and fail fast with
+ * guidance rather than letting the registry return a 404.
+ *
+ * Ordering matches bind — POST first, record the `aspiration_added`
+ * provenance entry only on a 2xx.
+ */
+declare function runAspirationsAdd(agentId: string, mdFile: string, opts?: AspirationsAddOptions): Promise<AspirationsAddResult>;
+declare function isAspirationsError(err: unknown): err is Error;
+
+declare function isUserFacingError(err: unknown): err is Error;
+
+declare function estimateTokens(text: string): number;
+
+declare const CREDENTIALS_SCHEMA_VERSION = 1;
+declare const DEFAULT_REGISTRY_URL = "https://registry.modex.md";
+declare const CredentialsSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    access_token: z.ZodString;
+    registry_url: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    schema_version: 1;
+    registry_url: string;
+    access_token: string;
+}, {
+    schema_version: 1;
+    registry_url: string;
+    access_token: string;
+}>;
+type Credentials = z.infer<typeof CredentialsSchema>;
+declare class CredentialsError extends Error {
+    constructor(message: string);
+}
+declare function configDir(): string;
+declare function credentialsPath(dir?: string): string;
+declare function loadCredentials(dir?: string): Promise<Credentials | null>;
+declare function saveCredentials(credentials: Credentials, dir?: string): Promise<void>;
+declare function clearCredentials(dir?: string): Promise<void>;
+
+declare const REGISTRY_STATE_SCHEMA_VERSION = 1;
+declare const RegistryStateSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    registry_url: z.ZodString;
+    agent_id: z.ZodString;
+    bound_at: z.ZodString;
+    last_server_skills_md_sha256: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    schema_version: 1;
+    agent_id: string;
+    registry_url: string;
+    bound_at: string;
+    last_server_skills_md_sha256: string;
+}, {
+    schema_version: 1;
+    agent_id: string;
+    registry_url: string;
+    bound_at: string;
+    last_server_skills_md_sha256: string;
+}>;
+type RegistryState = z.infer<typeof RegistryStateSchema>;
+declare class RegistryStateError extends Error {
+    constructor(message: string);
+}
+declare function readRegistryState(path: string): Promise<RegistryState | null>;
+declare function writeRegistryState(path: string, state: RegistryState): Promise<void>;
+
+declare class RegistryError extends Error {
+    readonly status: number | null;
+    readonly code: string | null;
+    constructor(message: string, opts?: {
+        status?: number | null;
+        code?: string | null;
+    });
+}
+declare const DeviceCodeStartSchema: z.ZodObject<{
+    device_code: z.ZodString;
+    user_code: z.ZodString;
+    verify_url: z.ZodString;
+    expires_in: z.ZodNumber;
+    interval: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    device_code: string;
+    user_code: string;
+    verify_url: string;
+    expires_in: number;
+    interval: number;
+}, {
+    device_code: string;
+    user_code: string;
+    verify_url: string;
+    expires_in: number;
+    interval: number;
+}>;
+type DeviceCodeStart = z.infer<typeof DeviceCodeStartSchema>;
+declare const TokenResponseSchema: z.ZodUnion<[z.ZodObject<{
+    access_token: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    access_token: string;
+}, {
+    access_token: string;
+}>, z.ZodObject<{
+    error: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    error: string;
+}, {
+    error: string;
+}>]>;
+type TokenResponse = z.infer<typeof TokenResponseSchema>;
+interface BindRequest {
+    skills_md: string;
+    skills_md_sha256: string;
+    provenance_head_sha256: string;
+    aspiration_sha256s: string[];
+}
+declare const BindResponseSchema: z.ZodObject<{
+    skills_md_sha256: z.ZodString;
+    bound_at: z.ZodString;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    skills_md_sha256: z.ZodString;
+    bound_at: z.ZodString;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    skills_md_sha256: z.ZodString;
+    bound_at: z.ZodString;
+}, z.ZodTypeAny, "passthrough">>;
+type BindResponse = z.infer<typeof BindResponseSchema>;
+interface AspirationRequest {
+    sha256: string;
+    content: string;
+}
+declare const AspirationResponseSchema: z.ZodObject<{
+    created_at: z.ZodOptional<z.ZodString>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    created_at: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    created_at: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">>;
+type AspirationResponse = z.infer<typeof AspirationResponseSchema>;
+
+interface RegistryDeps {
+    fetch?: typeof globalThis.fetch;
+    sleep?: (ms: number) => Promise<void>;
+    now?: () => number;
+}
+declare function startDeviceCode(registryUrl: string, deps?: RegistryDeps): Promise<DeviceCodeStart>;
+interface PollDeps extends RegistryDeps {
+    onPending?: () => void;
+}
+declare function pollForToken(registryUrl: string, start: DeviceCodeStart, deps?: PollDeps): Promise<string>;
+declare function bindAgent(registryUrl: string, agentId: string, token: string, body: BindRequest, deps?: RegistryDeps): Promise<BindResponse>;
+declare function addAspiration(registryUrl: string, agentId: string, token: string, body: AspirationRequest, deps?: RegistryDeps): Promise<AspirationResponse>;
+
+declare const AGENT_CONFIG_SCHEMA_VERSION = 0;
+declare const DEFAULT_TOKEN_CAP_WARN_AT = 32000;
+declare const MODEX_DIR_NAME = ".modex";
+declare const AgentConfigSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<0>;
+    id: z.ZodString;
+    name: z.ZodString;
+    created_at: z.ZodString;
+    token_cap_warn_at: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    schema_version: 0;
+    id: string;
+    created_at: string;
+    token_cap_warn_at: number;
+}, {
+    name: string;
+    schema_version: 0;
+    id: string;
+    created_at: string;
+    token_cap_warn_at: number;
+}>;
+type AgentConfig = z.infer<typeof AgentConfigSchema>;
+interface AgentPaths {
+    dir: string;
+    configFile: string;
+    skillsFile: string;
+    provenanceFile: string;
+    registryFile: string;
+}
+interface AgentRecord {
+    config: AgentConfig;
+    paths: AgentPaths;
+}
+declare class AgentError extends Error {
+    constructor(message: string);
+}
+declare function writeSkillsAtomic(path: string, content: string): Promise<void>;
+interface CreateAgentOptions {
+    name?: string;
+    baseDir?: string;
+    id?: string;
+    ts?: string;
+    tokenCapWarnAt?: number;
+}
+declare function createAgent(opts?: CreateAgentOptions): Promise<AgentRecord>;
+declare function loadAgent(id: string, baseDir?: string): Promise<AgentRecord>;
+declare function listAgents(baseDir?: string): Promise<AgentRecord[]>;
+declare function readAgentSkills(skillsFile: string): Promise<{
+    slug: string;
+    name: string;
+    description: string;
+    tags: string[];
+    source: string;
+}[]>;
+
+export { AGENT_CONFIG_SCHEMA_VERSION, type AgentConfig, AgentConfigSchema, type AgentCreatedEntry, AgentCreatedEntrySchema, AgentError, type AgentPaths, type AgentRecord, type AgentsCreateOptions, type AgentsListOptions, type AspirationAddedEntry, AspirationAddedEntrySchema, type AspirationRequest, type AspirationResponse, type AspirationsAddOptions, type AspirationsAddResult, type BindOptions, type BindRequest, type BindResponse, type BindResult, type BoundEntry, BoundEntrySchema, CREDENTIALS_SCHEMA_VERSION, type CanonicalJson, CanonicalJsonError, type CreateAgentOptions, type Credentials, CredentialsError, CredentialsSchema, DEFAULT_LOCK_TIMEOUT_MS, DEFAULT_REGISTRY_URL, DEFAULT_STALE_MS, DEFAULT_TOKEN_CAP_WARN_AT, type DeviceCodeStart, EMIT_SKILLS_TOOL, type EntryDraft, type ExpandOptions, type ExtractOptions, type ExtractedSkill, ExtractedSkillSchema, ExtractionError, type ExtractionResult, ExtractionResultSchema, type FeedEntry, FeedEntrySchema, type FeedOptions, type FeedResult, FileLockError, KNOWN_ENTRY_KINDS, type LoadedSource, type LockOptions, type LoginOptions, type LoginResult, type LogoutOptions, MODEL_ID, MODEX_DIR_NAME, type MergeResult, PROVENANCE_SCHEMA_VERSION, ParseSkillsError, type PerSourceResult, type PollDeps, type ProvenanceEntry, ProvenanceEntrySchema, ProvenanceError, REGISTRY_STATE_SCHEMA_VERSION, type RecordEntryOptions, type RegistryDeps, RegistryError, type RegistryState, RegistryStateError, RegistryStateSchema, SCHEMA_VERSION, SOURCE_KINDS, SYSTEM_PROMPT, type Skill, SkillSchema, type SkillsDoc, SkillsDocSchema, SourceError, type SourceKind, type TokenResponse, addAspiration, bindAgent, buildDoc, canonicalize, clearCredentials, computeEntryHash, configDir, createAgent, credentialsPath, estimateTokens, expandPatterns, extractSkills, isAspirationsError, isBindError, isFeedError, isLoginError, isUserFacingError, isWebUrl, listAgents, loadAgent, loadCredentials, mergeSkills, normalizeUrl, parseSkills, pollForToken, readAgentSkills, readChain, readRegistryState, readSource, recordEntry, runAgentsCreate, runAgentsList, runAspirationsAdd, runBind, runFeed, runLogin, runLogout, saveCredentials, serialize, startDeviceCode, verifyChain, withFileLock, writeRegistryState, writeSkillsAtomic };