@vauban-org/agent-sdk 1.0.0 → 1.2.0

package/dist/skills/markdown/schema.d.ts

@@ -0,0 +1,432 @@
+/**
+ * SKILL.md frontmatter schema — agentskills.io standard + Vauban extensions.
+ *
+ * Standard fields (agentskills.io spec):
+ *   - `name`         1-64 chars, kebab-case
+ *   - `description`  1-1024 chars
+ *   - `license`      free-text (optional)
+ *   - `compatibility` free-text (optional, e.g. "Requires STARKNET_RPC_URL")
+ *   - `allowed-tools` space-separated string, e.g. "Bash(curl:*) Bash(jq:*) Read"
+ *   - `metadata`     arbitrary k/v map (per spec — extension surface)
+ *
+ * Vauban extensions live UNDER `metadata` (spec-compliant — ignored gracefully
+ * by other agentskills.io-conforming tools). Namespaced as `vauban.*` keys
+ * for clarity:
+ *   - `metadata.vauban.tier`           "official" | "verified" | "unverified"
+ *   - `metadata.vauban.subagent`       agent id this skill belongs to
+ *   - `metadata.vauban.model-hint`     suggested LLM (forwarded to EconomyRouter)
+ *   - `metadata.vauban.proof.poseidon_hash`  hex
+ *   - `metadata.vauban.proof.tsa_token`      base64 RFC3161
+ *   - `metadata.vauban.proof.starknet_tx`    hex
+ *   - `metadata.vauban.biscuit.required_caps` array of capability strings
+ *   - `metadata.vauban.biscuit.max_scope`     "project" | "session" | "global"
+ *   - `metadata.vauban.audit_status`   "approved" | "review" | "rejected"
+ *
+ * Spec reference: https://agentskills.io/specification
+ * @see ADR-ECO-034 — skills TS↔MD coexistence
+ * @public
+ */
+import { z } from "zod";
+export declare const VaubanSkillTier: z.ZodEnum<["official", "verified", "unverified"]>;
+export type VaubanSkillTier = z.infer<typeof VaubanSkillTier>;
+export declare const VaubanBiscuitScope: z.ZodEnum<["project", "session", "global"]>;
+export type VaubanBiscuitScope = z.infer<typeof VaubanBiscuitScope>;
+export declare const VaubanAuditStatus: z.ZodEnum<["approved", "review", "rejected"]>;
+export type VaubanAuditStatus = z.infer<typeof VaubanAuditStatus>;
+export declare const SkillManifestSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    license: z.ZodOptional<z.ZodString>;
+    compatibility: z.ZodOptional<z.ZodString>;
+    "allowed-tools": z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        version: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        category: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        tags: z.ZodOptional<z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>>;
+        author: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        "env-required": z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        "env-mode": z.ZodOptional<z.ZodOptional<z.ZodEnum<["all", "at-least-one"]>>>;
+        vauban: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+            tier: z.ZodOptional<z.ZodOptional<z.ZodEnum<["official", "verified", "unverified"]>>>;
+            subagent: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            "model-hint": z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            proof: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+                poseidon_hash: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+                tsa_token: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+                starknet_tx: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+                anchored_at: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            }, "strict", z.ZodTypeAny, {
+                poseidon_hash?: string | undefined;
+                tsa_token?: string | undefined;
+                starknet_tx?: string | undefined;
+                anchored_at?: string | undefined;
+            }, {
+                poseidon_hash?: string | undefined;
+                tsa_token?: string | undefined;
+                starknet_tx?: string | undefined;
+                anchored_at?: string | undefined;
+            }>>>;
+            biscuit: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+                required_caps: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+                max_scope: z.ZodOptional<z.ZodOptional<z.ZodEnum<["project", "session", "global"]>>>;
+            }, "strict", z.ZodTypeAny, {
+                required_caps?: string[] | undefined;
+                max_scope?: "project" | "session" | "global" | undefined;
+            }, {
+                required_caps?: string[] | undefined;
+                max_scope?: "project" | "session" | "global" | undefined;
+            }>>>;
+            audit_status: z.ZodOptional<z.ZodOptional<z.ZodEnum<["approved", "review", "rejected"]>>>;
+            observability_metric: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        }, "strict", z.ZodTypeAny, {
+            tier?: "official" | "verified" | "unverified" | undefined;
+            subagent?: string | undefined;
+            "model-hint"?: string | undefined;
+            proof?: {
+                poseidon_hash?: string | undefined;
+                tsa_token?: string | undefined;
+                starknet_tx?: string | undefined;
+                anchored_at?: string | undefined;
+            } | undefined;
+            biscuit?: {
+                required_caps?: string[] | undefined;
+                max_scope?: "project" | "session" | "global" | undefined;
+            } | undefined;
+            audit_status?: "rejected" | "approved" | "review" | undefined;
+            observability_metric?: string | undefined;
+        }, {
+            tier?: "official" | "verified" | "unverified" | undefined;
+            subagent?: string | undefined;
+            "model-hint"?: string | undefined;
+            proof?: {
+                poseidon_hash?: string | undefined;
+                tsa_token?: string | undefined;
+                starknet_tx?: string | undefined;
+                anchored_at?: string | undefined;
+            } | undefined;
+            biscuit?: {
+                required_caps?: string[] | undefined;
+                max_scope?: "project" | "session" | "global" | undefined;
+            } | undefined;
+            audit_status?: "rejected" | "approved" | "review" | undefined;
+            observability_metric?: string | undefined;
+        }>>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        version: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        category: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        tags: z.ZodOptional<z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>>;
+        author: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        "env-required": z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        "env-mode": z.ZodOptional<z.ZodOptional<z.ZodEnum<["all", "at-least-one"]>>>;
+        vauban: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+            tier: z.ZodOptional<z.ZodOptional<z.ZodEnum<["official", "verified", "unverified"]>>>;
+            subagent: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            "model-hint": z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            proof: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+                poseidon_hash: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+                tsa_token: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+                starknet_tx: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+                anchored_at: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            }, "strict", z.ZodTypeAny, {
+                poseidon_hash?: string | undefined;
+                tsa_token?: string | undefined;
+                starknet_tx?: string | undefined;
+                anchored_at?: string | undefined;
+            }, {
+                poseidon_hash?: string | undefined;
+                tsa_token?: string | undefined;
+                starknet_tx?: string | undefined;
+                anchored_at?: string | undefined;
+            }>>>;
+            biscuit: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+                required_caps: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+                max_scope: z.ZodOptional<z.ZodOptional<z.ZodEnum<["project", "session", "global"]>>>;
+            }, "strict", z.ZodTypeAny, {
+                required_caps?: string[] | undefined;
+                max_scope?: "project" | "session" | "global" | undefined;
+            }, {
+                required_caps?: string[] | undefined;
+                max_scope?: "project" | "session" | "global" | undefined;
+            }>>>;
+            audit_status: z.ZodOptional<z.ZodOptional<z.ZodEnum<["approved", "review", "rejected"]>>>;
+            observability_metric: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        }, "strict", z.ZodTypeAny, {
+            tier?: "official" | "verified" | "unverified" | undefined;
+            subagent?: string | undefined;
+            "model-hint"?: string | undefined;
+            proof?: {
+                poseidon_hash?: string | undefined;
+                tsa_token?: string | undefined;
+                starknet_tx?: string | undefined;
+                anchored_at?: string | undefined;
+            } | undefined;
+            biscuit?: {
+                required_caps?: string[] | undefined;
+                max_scope?: "project" | "session" | "global" | undefined;
+            } | undefined;
+            audit_status?: "rejected" | "approved" | "review" | undefined;
+            observability_metric?: string | undefined;
+        }, {
+            tier?: "official" | "verified" | "unverified" | undefined;
+            subagent?: string | undefined;
+            "model-hint"?: string | undefined;
+            proof?: {
+                poseidon_hash?: string | undefined;
+                tsa_token?: string | undefined;
+                starknet_tx?: string | undefined;
+                anchored_at?: string | undefined;
+            } | undefined;
+            biscuit?: {
+                required_caps?: string[] | undefined;
+                max_scope?: "project" | "session" | "global" | undefined;
+            } | undefined;
+            audit_status?: "rejected" | "approved" | "review" | undefined;
+            observability_metric?: string | undefined;
+        }>>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        version: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        category: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        tags: z.ZodOptional<z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>>;
+        author: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        "env-required": z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        "env-mode": z.ZodOptional<z.ZodOptional<z.ZodEnum<["all", "at-least-one"]>>>;
+        vauban: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+            tier: z.ZodOptional<z.ZodOptional<z.ZodEnum<["official", "verified", "unverified"]>>>;
+            subagent: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            "model-hint": z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            proof: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+                poseidon_hash: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+                tsa_token: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+                starknet_tx: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+                anchored_at: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            }, "strict", z.ZodTypeAny, {
+                poseidon_hash?: string | undefined;
+                tsa_token?: string | undefined;
+                starknet_tx?: string | undefined;
+                anchored_at?: string | undefined;
+            }, {
+                poseidon_hash?: string | undefined;
+                tsa_token?: string | undefined;
+                starknet_tx?: string | undefined;
+                anchored_at?: string | undefined;
+            }>>>;
+            biscuit: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+                required_caps: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+                max_scope: z.ZodOptional<z.ZodOptional<z.ZodEnum<["project", "session", "global"]>>>;
+            }, "strict", z.ZodTypeAny, {
+                required_caps?: string[] | undefined;
+                max_scope?: "project" | "session" | "global" | undefined;
+            }, {
+                required_caps?: string[] | undefined;
+                max_scope?: "project" | "session" | "global" | undefined;
+            }>>>;
+            audit_status: z.ZodOptional<z.ZodOptional<z.ZodEnum<["approved", "review", "rejected"]>>>;
+            observability_metric: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        }, "strict", z.ZodTypeAny, {
+            tier?: "official" | "verified" | "unverified" | undefined;
+            subagent?: string | undefined;
+            "model-hint"?: string | undefined;
+            proof?: {
+                poseidon_hash?: string | undefined;
+                tsa_token?: string | undefined;
+                starknet_tx?: string | undefined;
+                anchored_at?: string | undefined;
+            } | undefined;
+            biscuit?: {
+                required_caps?: string[] | undefined;
+                max_scope?: "project" | "session" | "global" | undefined;
+            } | undefined;
+            audit_status?: "rejected" | "approved" | "review" | undefined;
+            observability_metric?: string | undefined;
+        }, {
+            tier?: "official" | "verified" | "unverified" | undefined;
+            subagent?: string | undefined;
+            "model-hint"?: string | undefined;
+            proof?: {
+                poseidon_hash?: string | undefined;
+                tsa_token?: string | undefined;
+                starknet_tx?: string | undefined;
+                anchored_at?: string | undefined;
+            } | undefined;
+            biscuit?: {
+                required_caps?: string[] | undefined;
+                max_scope?: "project" | "session" | "global" | undefined;
+            } | undefined;
+            audit_status?: "rejected" | "approved" | "review" | undefined;
+            observability_metric?: string | undefined;
+        }>>>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, "strict", z.ZodTypeAny, {
+    name: string;
+    description: string;
+    metadata?: z.objectOutputType<{
+        version: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        category: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        tags: z.ZodOptional<z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>>;
+        author: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        "env-required": z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        "env-mode": z.ZodOptional<z.ZodOptional<z.ZodEnum<["all", "at-least-one"]>>>;
+        vauban: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+            tier: z.ZodOptional<z.ZodOptional<z.ZodEnum<["official", "verified", "unverified"]>>>;
+            subagent: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            "model-hint": z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            proof: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+                poseidon_hash: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+                tsa_token: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+                starknet_tx: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+                anchored_at: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            }, "strict", z.ZodTypeAny, {
+                poseidon_hash?: string | undefined;
+                tsa_token?: string | undefined;
+                starknet_tx?: string | undefined;
+                anchored_at?: string | undefined;
+            }, {
+                poseidon_hash?: string | undefined;
+                tsa_token?: string | undefined;
+                starknet_tx?: string | undefined;
+                anchored_at?: string | undefined;
+            }>>>;
+            biscuit: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+                required_caps: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+                max_scope: z.ZodOptional<z.ZodOptional<z.ZodEnum<["project", "session", "global"]>>>;
+            }, "strict", z.ZodTypeAny, {
+                required_caps?: string[] | undefined;
+                max_scope?: "project" | "session" | "global" | undefined;
+            }, {
+                required_caps?: string[] | undefined;
+                max_scope?: "project" | "session" | "global" | undefined;
+            }>>>;
+            audit_status: z.ZodOptional<z.ZodOptional<z.ZodEnum<["approved", "review", "rejected"]>>>;
+            observability_metric: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        }, "strict", z.ZodTypeAny, {
+            tier?: "official" | "verified" | "unverified" | undefined;
+            subagent?: string | undefined;
+            "model-hint"?: string | undefined;
+            proof?: {
+                poseidon_hash?: string | undefined;
+                tsa_token?: string | undefined;
+                starknet_tx?: string | undefined;
+                anchored_at?: string | undefined;
+            } | undefined;
+            biscuit?: {
+                required_caps?: string[] | undefined;
+                max_scope?: "project" | "session" | "global" | undefined;
+            } | undefined;
+            audit_status?: "rejected" | "approved" | "review" | undefined;
+            observability_metric?: string | undefined;
+        }, {
+            tier?: "official" | "verified" | "unverified" | undefined;
+            subagent?: string | undefined;
+            "model-hint"?: string | undefined;
+            proof?: {
+                poseidon_hash?: string | undefined;
+                tsa_token?: string | undefined;
+                starknet_tx?: string | undefined;
+                anchored_at?: string | undefined;
+            } | undefined;
+            biscuit?: {
+                required_caps?: string[] | undefined;
+                max_scope?: "project" | "session" | "global" | undefined;
+            } | undefined;
+            audit_status?: "rejected" | "approved" | "review" | undefined;
+            observability_metric?: string | undefined;
+        }>>>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    license?: string | undefined;
+    compatibility?: string | undefined;
+    "allowed-tools"?: string | undefined;
+}, {
+    name: string;
+    description: string;
+    metadata?: z.objectInputType<{
+        version: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        category: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        tags: z.ZodOptional<z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>>;
+        author: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        "env-required": z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        "env-mode": z.ZodOptional<z.ZodOptional<z.ZodEnum<["all", "at-least-one"]>>>;
+        vauban: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+            tier: z.ZodOptional<z.ZodOptional<z.ZodEnum<["official", "verified", "unverified"]>>>;
+            subagent: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            "model-hint": z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            proof: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+                poseidon_hash: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+                tsa_token: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+                starknet_tx: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+                anchored_at: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            }, "strict", z.ZodTypeAny, {
+                poseidon_hash?: string | undefined;
+                tsa_token?: string | undefined;
+                starknet_tx?: string | undefined;
+                anchored_at?: string | undefined;
+            }, {
+                poseidon_hash?: string | undefined;
+                tsa_token?: string | undefined;
+                starknet_tx?: string | undefined;
+                anchored_at?: string | undefined;
+            }>>>;
+            biscuit: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+                required_caps: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+                max_scope: z.ZodOptional<z.ZodOptional<z.ZodEnum<["project", "session", "global"]>>>;
+            }, "strict", z.ZodTypeAny, {
+                required_caps?: string[] | undefined;
+                max_scope?: "project" | "session" | "global" | undefined;
+            }, {
+                required_caps?: string[] | undefined;
+                max_scope?: "project" | "session" | "global" | undefined;
+            }>>>;
+            audit_status: z.ZodOptional<z.ZodOptional<z.ZodEnum<["approved", "review", "rejected"]>>>;
+            observability_metric: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        }, "strict", z.ZodTypeAny, {
+            tier?: "official" | "verified" | "unverified" | undefined;
+            subagent?: string | undefined;
+            "model-hint"?: string | undefined;
+            proof?: {
+                poseidon_hash?: string | undefined;
+                tsa_token?: string | undefined;
+                starknet_tx?: string | undefined;
+                anchored_at?: string | undefined;
+            } | undefined;
+            biscuit?: {
+                required_caps?: string[] | undefined;
+                max_scope?: "project" | "session" | "global" | undefined;
+            } | undefined;
+            audit_status?: "rejected" | "approved" | "review" | undefined;
+            observability_metric?: string | undefined;
+        }, {
+            tier?: "official" | "verified" | "unverified" | undefined;
+            subagent?: string | undefined;
+            "model-hint"?: string | undefined;
+            proof?: {
+                poseidon_hash?: string | undefined;
+                tsa_token?: string | undefined;
+                starknet_tx?: string | undefined;
+                anchored_at?: string | undefined;
+            } | undefined;
+            biscuit?: {
+                required_caps?: string[] | undefined;
+                max_scope?: "project" | "session" | "global" | undefined;
+            } | undefined;
+            audit_status?: "rejected" | "approved" | "review" | undefined;
+            observability_metric?: string | undefined;
+        }>>>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    license?: string | undefined;
+    compatibility?: string | undefined;
+    "allowed-tools"?: string | undefined;
+}>;
+export type SkillManifest = z.infer<typeof SkillManifestSchema>;
+/**
+ * Resolve the Vauban tier from a manifest, defaulting to `unverified` per
+ * the trust-stratification rule: any skill without an explicit tier MUST be
+ * sandboxed as community-untrusted.
+ */
+export declare function resolveTier(manifest: SkillManifest): VaubanSkillTier;
+/**
+ * Parse the space-separated `allowed-tools` string into an array. Empty string
+ * returns []. Whitespace runs collapse. Examples:
+ *   "Bash(curl:*) Read"      → ["Bash(curl:*)", "Read"]
+ *   "Bash(curl:*)  Bash(jq)" → ["Bash(curl:*)", "Bash(jq)"]
+ */
+export declare function parseAllowedTools(manifest: SkillManifest): string[];
+//# sourceMappingURL=schema.d.ts.map

package/dist/skills/markdown/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/skills/markdown/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,eAAe,mDAAiD,CAAC;AAC9E,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D,eAAO,MAAM,kBAAkB,6CAA2C,CAAC;AAC3E,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEpE,eAAO,MAAM,iBAAiB,+CAA6C,CAAC;AAC5E,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AA2DlE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmBrB,CAAC;AAEZ,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAIhE;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,aAAa,GAAG,eAAe,CAEpE;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,aAAa,GAAG,MAAM,EAAE,CAInE"}

package/dist/skills/markdown/schema.js

@@ -0,0 +1,121 @@
+/**
+ * SKILL.md frontmatter schema — agentskills.io standard + Vauban extensions.
+ *
+ * Standard fields (agentskills.io spec):
+ *   - `name`         1-64 chars, kebab-case
+ *   - `description`  1-1024 chars
+ *   - `license`      free-text (optional)
+ *   - `compatibility` free-text (optional, e.g. "Requires STARKNET_RPC_URL")
+ *   - `allowed-tools` space-separated string, e.g. "Bash(curl:*) Bash(jq:*) Read"
+ *   - `metadata`     arbitrary k/v map (per spec — extension surface)
+ *
+ * Vauban extensions live UNDER `metadata` (spec-compliant — ignored gracefully
+ * by other agentskills.io-conforming tools). Namespaced as `vauban.*` keys
+ * for clarity:
+ *   - `metadata.vauban.tier`           "official" | "verified" | "unverified"
+ *   - `metadata.vauban.subagent`       agent id this skill belongs to
+ *   - `metadata.vauban.model-hint`     suggested LLM (forwarded to EconomyRouter)
+ *   - `metadata.vauban.proof.poseidon_hash`  hex
+ *   - `metadata.vauban.proof.tsa_token`      base64 RFC3161
+ *   - `metadata.vauban.proof.starknet_tx`    hex
+ *   - `metadata.vauban.biscuit.required_caps` array of capability strings
+ *   - `metadata.vauban.biscuit.max_scope`     "project" | "session" | "global"
+ *   - `metadata.vauban.audit_status`   "approved" | "review" | "rejected"
+ *
+ * Spec reference: https://agentskills.io/specification
+ * @see ADR-ECO-034 — skills TS↔MD coexistence
+ * @public
+ */
+import { z } from "zod";
+// ── Vauban metadata extension schemas ────────────────────────────────────────
+export const VaubanSkillTier = z.enum(["official", "verified", "unverified"]);
+export const VaubanBiscuitScope = z.enum(["project", "session", "global"]);
+export const VaubanAuditStatus = z.enum(["approved", "review", "rejected"]);
+const VaubanProofExtensionSchema = z
+    .object({
+    poseidon_hash: z
+        .string()
+        .regex(/^0x[0-9a-fA-F]+$/)
+        .optional(),
+    tsa_token: z.string().optional(),
+    starknet_tx: z
+        .string()
+        .regex(/^0x[0-9a-fA-F]+$/)
+        .optional(),
+    anchored_at: z.string().datetime().optional(),
+})
+    .strict()
+    .partial();
+const VaubanBiscuitExtensionSchema = z
+    .object({
+    required_caps: z.array(z.string()).optional(),
+    max_scope: VaubanBiscuitScope.optional(),
+})
+    .strict()
+    .partial();
+const VaubanExtensionSchema = z
+    .object({
+    tier: VaubanSkillTier.optional(),
+    subagent: z.string().optional(),
+    "model-hint": z.string().optional(),
+    proof: VaubanProofExtensionSchema.optional(),
+    biscuit: VaubanBiscuitExtensionSchema.optional(),
+    audit_status: VaubanAuditStatus.optional(),
+    observability_metric: z.string().optional(),
+})
+    .strict()
+    .partial();
+// ── Generic metadata (per agentskills.io: arbitrary k/v) ─────────────────────
+const StandardMetadataKnownKeys = z
+    .object({
+    version: z.string().optional(),
+    category: z.string().optional(),
+    tags: z.union([z.string(), z.array(z.string())]).optional(),
+    author: z.string().optional(),
+    "env-required": z.string().optional(),
+    "env-mode": z.enum(["all", "at-least-one"]).optional(),
+    vauban: VaubanExtensionSchema.optional(),
+})
+    .partial();
+const MetadataSchema = StandardMetadataKnownKeys.passthrough();
+// ── Top-level SKILL.md frontmatter schema ────────────────────────────────────
+const KEBAB_CASE = /^[a-z0-9][a-z0-9-]*$/;
+export const SkillManifestSchema = z
+    .object({
+    name: z
+        .string()
+        .min(1, "name must be 1-64 chars")
+        .max(64, "name must be 1-64 chars")
+        .regex(KEBAB_CASE, "name must be kebab-case (lowercase, digits, hyphens)"),
+    description: z
+        .string()
+        .min(1, "description must be 1-1024 chars")
+        .max(1024, "description must be 1-1024 chars"),
+    license: z.string().optional(),
+    compatibility: z.string().optional(),
+    "allowed-tools": z.string().optional(),
+    metadata: MetadataSchema.optional(),
+})
+    .strict();
+// ── Helpers ───────────────────────────────────────────────────────────────────
+/**
+ * Resolve the Vauban tier from a manifest, defaulting to `unverified` per
+ * the trust-stratification rule: any skill without an explicit tier MUST be
+ * sandboxed as community-untrusted.
+ */
+export function resolveTier(manifest) {
+    return manifest.metadata?.vauban?.tier ?? "unverified";
+}
+/**
+ * Parse the space-separated `allowed-tools` string into an array. Empty string
+ * returns []. Whitespace runs collapse. Examples:
+ *   "Bash(curl:*) Read"      → ["Bash(curl:*)", "Read"]
+ *   "Bash(curl:*)  Bash(jq)" → ["Bash(curl:*)", "Bash(jq)"]
+ */
+export function parseAllowedTools(manifest) {
+    const raw = manifest["allowed-tools"];
+    if (!raw)
+        return [];
+    return raw.split(/\s+/).filter((s) => s.length > 0);
+}
+//# sourceMappingURL=schema.js.map

package/dist/skills/markdown/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../../src/skills/markdown/schema.ts"],"names":[],"mappings":"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"}

package/dist/skills/poc-md-loader/markdown-loader.d.ts

@@ -0,0 +1,77 @@
+/**
+ * markdown-loader — prototype SKILL.md parser.
+ *
+ * Parses frontmatter (YAML-subset, no external dep) + markdown body.
+ * Returns a typed SkillManifest validated against a Zod schema.
+ *
+ * Constraint: no new npm deps — uses only node:fs/promises + zod (already in pkg).
+ *
+ * @poc-jetable
+ */
+import { z } from "zod";
+export declare const SkillManifestSchema: z.ZodObject<{
+    /** kebab-case, 1-64 chars */
+    name: z.ZodString;
+    /** 1-1024 chars */
+    description: z.ZodString;
+    /** Space-separated tool grant list, e.g. "Bash(curl:*) Read" */
+    "allowed-tools": z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        version: z.ZodDefault<z.ZodString>;
+        category: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodString>;
+        "model-hint": z.ZodOptional<z.ZodString>;
+        "env-required": z.ZodOptional<z.ZodString>;
+        "env-mode": z.ZodDefault<z.ZodEnum<["all", "at-least-one"]>>;
+    }, "strict", z.ZodTypeAny, {
+        version: string;
+        "env-mode": "all" | "at-least-one";
+        category?: string | undefined;
+        tags?: string | undefined;
+        "env-required"?: string | undefined;
+        "model-hint"?: string | undefined;
+    }, {
+        category?: string | undefined;
+        tags?: string | undefined;
+        version?: string | undefined;
+        "env-required"?: string | undefined;
+        "env-mode"?: "all" | "at-least-one" | undefined;
+        "model-hint"?: string | undefined;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    name: string;
+    description: string;
+    metadata?: {
+        version: string;
+        "env-mode": "all" | "at-least-one";
+        category?: string | undefined;
+        tags?: string | undefined;
+        "env-required"?: string | undefined;
+        "model-hint"?: string | undefined;
+    } | undefined;
+    "allowed-tools"?: string | undefined;
+}, {
+    name: string;
+    description: string;
+    metadata?: {
+        category?: string | undefined;
+        tags?: string | undefined;
+        version?: string | undefined;
+        "env-required"?: string | undefined;
+        "env-mode"?: "all" | "at-least-one" | undefined;
+        "model-hint"?: string | undefined;
+    } | undefined;
+    "allowed-tools"?: string | undefined;
+}>;
+export type SkillManifest = z.infer<typeof SkillManifestSchema>;
+export interface ParsedSkillFile {
+    manifest: SkillManifest;
+    body: string;
+}
+/**
+ * Parse a SKILL.md file at `filePath`.
+ * Extracts frontmatter (between --- delimiters) and validates with Zod.
+ * Returns typed manifest + raw markdown body.
+ */
+export declare function loadSkillMd(filePath: string): Promise<ParsedSkillFile>;
+//# sourceMappingURL=markdown-loader.d.ts.map

package/dist/skills/poc-md-loader/markdown-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown-loader.d.ts","sourceRoot":"","sources":["../../../src/skills/poc-md-loader/markdown-loader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAexB,eAAO,MAAM,mBAAmB;IAE5B,6BAA6B;;IAM7B,mBAAmB;;IAEnB,gEAAgE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIzD,CAAC;AAEZ,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAkFhE,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,aAAa,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;GAIG;AACH,wBAAsB,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAyB5E"}