@jinn-network/core 0.1.0-canary.3afae198

package/dist/scrub/types.d.ts

@@ -0,0 +1,36 @@
+export type Attributes = Record<string, unknown>;
+export interface RedactionRecord {
+    /** attribute key affected */
+    key: string;
+    /** stage that made the redaction (matches ScrubStage.name) */
+    stage: string;
+    /** category, e.g. 'dropped-key' | 'secret' | 'pii' */
+    kind: string;
+    /** optional detail, e.g. a rule id or entity type */
+    detail?: string;
+}
+export interface ScrubResult {
+    attributes: Attributes;
+    redactions: RedactionRecord[];
+    /** Findings from the detection pass (#1969). Optional for legacy stage wrappers. */
+    findings?: import('./finding.js').Finding[];
+    /** True when reject-publish fired or check-mode saw a non-pass finding. */
+    rejected?: boolean;
+    /** Unresolved flag findings held for review (#1973). */
+    unresolvedFlags?: import('./finding.js').Finding[];
+    /**
+     * Applied disposition counts keyed `${ScrubClass}:${redact|flag|reject}`
+     * (#1974). Optional for legacy stage wrappers.
+     */
+    perClassCounts?: Record<string, number>;
+}
+/**
+ * A single stage in the seller-side scrub pipeline. `name` + `version` expose
+ * the active components to local inspection and tests. The current published
+ * trace-envelope schema does not carry this component list.
+ */
+export interface ScrubStage {
+    readonly name: string;
+    readonly version: string;
+    scrub(attributes: Attributes): ScrubResult | Promise<ScrubResult>;
+}

package/dist/scrub/types.js

@@ -0,0 +1 @@
+export {};

package/dist/scrub/url-credentials-detector.d.ts

@@ -0,0 +1,9 @@
+/**
+ * A3 — credentials embedded in URLs (#1972 / design §6.2).
+ *
+ * Detects URL userinfo (`scheme://user:pass@host`) and known credential query
+ * params (`token`, `key`, `api_key`, and common aliases).
+ */
+import { type KeyPolicy } from './key-policy.js';
+import type { Detector } from './finding.js';
+export declare function urlCredentialsDetector(policy: KeyPolicy): Detector;

package/dist/scrub/url-credentials-detector.js

@@ -0,0 +1,66 @@
+/**
+ * A3 — credentials embedded in URLs (#1972 / design §6.2).
+ *
+ * Detects URL userinfo (`scheme://user:pass@host`) and known credential query
+ * params (`token`, `key`, `api_key`, and common aliases).
+ */
+import { classifyKey } from './key-policy.js';
+const VERSION = '1.0.0';
+/** user:pass@ or user@ before the host (requires ://). */
+const USERINFO_PATTERN = /([a-z][a-z0-9+.-]*:\/\/)([^/\s?#@]+@)/gi;
+/**
+ * Credential query-param names. Value runs until the next `&`, `#`, whitespace,
+ * or end of string. Case-insensitive names.
+ */
+const CRED_QUERY_PATTERN = /([?&](?:token|access_token|refresh_token|id_token|auth_token|api[_-]?key|apikey|key|password|secret|client_secret)=)([^&#\s]+)/gi;
+export function urlCredentialsDetector(policy) {
+    const meta = { name: 'url-credentials', version: VERSION };
+    return {
+        ...meta,
+        detect(attributes) {
+            const findings = [];
+            for (const [key, value] of Object.entries(attributes)) {
+                if (typeof value !== 'string' || classifyKey(key, policy) !== 'content')
+                    continue;
+                findings.push(...scan(value, key, meta));
+            }
+            return findings;
+        },
+    };
+}
+function scan(text, key, detector) {
+    const findings = [];
+    const userinfo = new RegExp(USERINFO_PATTERN.source, USERINFO_PATTERN.flags);
+    let m;
+    while ((m = userinfo.exec(text)) !== null) {
+        const full = m[0];
+        const prefix = m[1];
+        const start = m.index + prefix.length;
+        const end = m.index + full.length;
+        findings.push({
+            class: 'A3',
+            span: { key, start, end },
+            confidence: 'VERY_HIGH',
+            evidence: ['url-userinfo'],
+            detector,
+        });
+    }
+    const query = new RegExp(CRED_QUERY_PATTERN.source, CRED_QUERY_PATTERN.flags);
+    while ((m = query.exec(text)) !== null) {
+        const prefix = m[1];
+        const value = m[2];
+        // Skip empty / placeholder-looking values
+        if (!value || value === '$' || value.startsWith('$'))
+            continue;
+        const start = m.index + prefix.length;
+        const end = start + value.length;
+        findings.push({
+            class: 'A3',
+            span: { key, start, end },
+            confidence: 'VERY_HIGH',
+            evidence: ['url-query-credential'],
+            detector,
+        });
+    }
+    return findings;
+}

package/dist/session-provenance.d.ts

@@ -0,0 +1,75 @@
+import { z } from 'zod/v3';
+export declare const SessionProvenanceSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    capturedAt: z.ZodString;
+    originatingTool: z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        version?: string | undefined;
+    }, {
+        name: string;
+        version?: string | undefined;
+    }>;
+    repo: z.ZodOptional<z.ZodObject<{
+        remoteUrl: z.ZodOptional<z.ZodString>;
+        commitHash: z.ZodOptional<z.ZodString>;
+        branch: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        remoteUrl?: string | undefined;
+        commitHash?: string | undefined;
+        branch?: string | undefined;
+    }, {
+        remoteUrl?: string | undefined;
+        commitHash?: string | undefined;
+        branch?: string | undefined;
+    }>>;
+    license: z.ZodObject<{
+        spdxId: z.ZodOptional<z.ZodString>;
+        operatorAssertion: z.ZodEnum<["asserted", "unspecified"]>;
+    }, "strip", z.ZodTypeAny, {
+        operatorAssertion: "asserted" | "unspecified";
+        spdxId?: string | undefined;
+    }, {
+        operatorAssertion: "asserted" | "unspecified";
+        spdxId?: string | undefined;
+    }>;
+    /** The single `share` consent (mono#1714): may a mined task be published. */
+    publishMinedTasksConsent: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    sessionId: string;
+    capturedAt: string;
+    originatingTool: {
+        name: string;
+        version?: string | undefined;
+    };
+    license: {
+        operatorAssertion: "asserted" | "unspecified";
+        spdxId?: string | undefined;
+    };
+    publishMinedTasksConsent?: boolean | undefined;
+    repo?: {
+        remoteUrl?: string | undefined;
+        commitHash?: string | undefined;
+        branch?: string | undefined;
+    } | undefined;
+}, {
+    sessionId: string;
+    capturedAt: string;
+    originatingTool: {
+        name: string;
+        version?: string | undefined;
+    };
+    license: {
+        operatorAssertion: "asserted" | "unspecified";
+        spdxId?: string | undefined;
+    };
+    publishMinedTasksConsent?: boolean | undefined;
+    repo?: {
+        remoteUrl?: string | undefined;
+        commitHash?: string | undefined;
+        branch?: string | undefined;
+    } | undefined;
+}>;
+export type SessionProvenance = z.infer<typeof SessionProvenanceSchema>;

package/dist/session-provenance.js

@@ -0,0 +1,20 @@
+import { z } from 'zod/v3';
+export const SessionProvenanceSchema = z.object({
+    sessionId: z.string().min(1),
+    capturedAt: z.string().datetime(),
+    originatingTool: z.object({
+        name: z.string(),
+        version: z.string().optional(),
+    }),
+    repo: z.object({
+        remoteUrl: z.string().optional(),
+        commitHash: z.string().regex(/^[0-9a-f]{40}$/).optional(),
+        branch: z.string().optional(),
+    }).optional(),
+    license: z.object({
+        spdxId: z.string().optional(),
+        operatorAssertion: z.enum(['asserted', 'unspecified']),
+    }),
+    /** The single `share` consent (mono#1714): may a mined task be published. */
+    publishMinedTasksConsent: z.boolean().optional(),
+});

package/dist/skill-artifact.d.ts

@@ -0,0 +1,442 @@
+import { z } from 'zod/v3';
+/**
+ * jinn.skill.v1 — first-class skill artifact (issue #1394).
+ *
+ * A skill (SKILL.md + optional companion files + machine-readable
+ * provenance) carried as one entry in the `jinn.execution.v1` wrapper
+ * envelope's `artifacts[]`. Carrier invariant by provenance kind:
+ * **imported** (seeds) publish ALONGSIDE the seeded layer-1 trace envelope
+ * (never instead of it); **distilled** skills have no trace of their own —
+ * their evidence is the referenced layer-1 envelopes in `sourceEnvelopeCids` —
+ * so they publish as a skill-only wrapper (`publishSkill()`,
+ * packages/layer/src/publish-skill.ts, DR-2026-07-06).
+ * Access/pricing come from the enclosing Artifact
+ * entry (client/src/types/envelope.ts ArtifactSchema: sha256,
+ * access.endpoint, access.priceUsdc, metadata.tags).
+ *
+ * Frozen-caps review (AC3, additive): this schema is a NEW artifact payload
+ * type. It does not touch the frozen layer-1 evidence envelope
+ * (jinn.trace-envelope.v0 — packages/core/src/envelope.ts,
+ * caps in packages/layer/docs/envelope-v0.md) and requires no
+ * change to the jinn.execution.v1 wrapper, whose artifacts[] already accepts
+ * any artifactType string. Companion-file content lives here, free of the
+ * trace envelope's 16 KiB step-attribute cap, under its own 1 MiB total cap.
+ *
+ * Precedent: client/src/trajectory/harness-bundle-schema.ts.
+ */
+export declare const SKILL_ARTIFACT_TYPE: "jinn.skill.v1";
+/** Max companion files per skill. */
+export declare const MAX_SKILL_FILES = 64;
+/** Max total decoded bytes (skillMd + all companion files): 1 MiB. */
+export declare const MAX_SKILL_TOTAL_DECODED_BYTES: number;
+export declare const SkillCompanionFileSchema: z.ZodObject<{
+    path: z.ZodEffects<z.ZodString, string, string>;
+    contentBase64: z.ZodString;
+    sha256: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    sha256: string;
+    contentBase64: string;
+}, {
+    path: string;
+    sha256: string;
+    contentBase64: string;
+}>;
+export declare const SkillProvenanceSchema: z.ZodObject<{
+    kind: z.ZodEnum<["imported", "distilled"]>;
+    /**
+     * Envelope CIDs the skill was distilled from ([] for seed imports).
+     * The "distilled from N traces" count is this array's length — never
+     * stored separately (anti-drift).
+     */
+    sourceEnvelopeCids: z.ZodArray<z.ZodString, "many">;
+    operator: z.ZodObject<{
+        safeAddress: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        safeAddress: string;
+    }, {
+        safeAddress: string;
+    }>;
+    solverType: z.ZodOptional<z.ZodString>;
+    /** Seed attribution, mirroring the seeded trace's `seed.attribution`. */
+    seed: z.ZodOptional<z.ZodObject<{
+        skill: z.ZodString;
+        source: z.ZodString;
+        licence: z.ZodNullable<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        source: string;
+        skill: string;
+        licence: string | null;
+    }, {
+        source: string;
+        skill: string;
+        licence: string | null;
+    }>>;
+    /**
+     * Success→strategic-pattern, failure→lesson, both-polarity→contrastive
+     * (spec §7, D10 + v0.5), or cross-instance corroboration→cross-instance
+     * (stage-2 meta-distill). `contrastive` and `cross-instance` are additive
+     * enum values: strict consumers (`extractSkill`) reject them until upgraded
+     * — acceptable at testnet volume, named in the spec.
+     */
+    skillKind: z.ZodOptional<z.ZodEnum<["strategic-pattern", "failure-lesson", "contrastive", "cross-instance"]>>;
+    /** SHA-256 of the exact distill prompt that produced the skill (auditability, D4). */
+    distillPromptSha256: z.ZodOptional<z.ZodString>;
+    /** Task-distribution the skill targets (e.g. 'coding'). */
+    distribution: z.ZodOptional<z.ZodString>;
+    /** Verifiability tier of the source evidence (e.g. 'evaluator-verified'). */
+    verifiabilityTier: z.ZodOptional<z.ZodString>;
+    /**
+     * The model that ran distillation (spec §5, v0.5). Distillation quality is
+     * model-sensitive; recording it makes a skill's quality auditable.
+     */
+    distillModel: z.ZodOptional<z.ZodString>;
+    /**
+     * Deterministic `ceil(utf8 chars / 4)` token estimates of the distiller
+     * input and the emitted body (spec §5, v0.5). The pair records the
+     * compression ratio (SkillRL operates at 10–20×); an auditable estimate
+     * serves that purpose better than an unreproducible exact count (the LLM
+     * port reports no usage).
+     */
+    evidenceTokens: z.ZodOptional<z.ZodNumber>;
+    skillTokens: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Envelope/manifest CID of a prior skill record this one replaces — the same
+     * identity space as `sourceEnvelopeCids` and a search-hit `ref`. Honored at
+     * read time ONLY when this record's operator matches the superseded record's
+     * operator (cross-operator supersedes are ignored); see the read-path head
+     * resolver in packages/layer/src/consume.ts.
+     */
+    supersedes: z.ZodOptional<z.ZodString>;
+    /**
+     * Pure retirement marker: retires this record's `supersedes` target with no
+     * replacement and hides this record itself from discovery. A deprecation
+     * record carries no successor skill content.
+     */
+    deprecates: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    kind: "imported" | "distilled";
+    sourceEnvelopeCids: string[];
+    operator: {
+        safeAddress: string;
+    };
+    verifiabilityTier?: string | undefined;
+    solverType?: string | undefined;
+    seed?: {
+        source: string;
+        skill: string;
+        licence: string | null;
+    } | undefined;
+    skillKind?: "strategic-pattern" | "failure-lesson" | "contrastive" | "cross-instance" | undefined;
+    distillPromptSha256?: string | undefined;
+    distribution?: string | undefined;
+    distillModel?: string | undefined;
+    evidenceTokens?: number | undefined;
+    skillTokens?: number | undefined;
+    supersedes?: string | undefined;
+    deprecates?: boolean | undefined;
+}, {
+    kind: "imported" | "distilled";
+    sourceEnvelopeCids: string[];
+    operator: {
+        safeAddress: string;
+    };
+    verifiabilityTier?: string | undefined;
+    solverType?: string | undefined;
+    seed?: {
+        source: string;
+        skill: string;
+        licence: string | null;
+    } | undefined;
+    skillKind?: "strategic-pattern" | "failure-lesson" | "contrastive" | "cross-instance" | undefined;
+    distillPromptSha256?: string | undefined;
+    distribution?: string | undefined;
+    distillModel?: string | undefined;
+    evidenceTokens?: number | undefined;
+    skillTokens?: number | undefined;
+    supersedes?: string | undefined;
+    deprecates?: boolean | undefined;
+}>;
+export declare const SkillArtifactV1Schema: z.ZodEffects<z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"jinn.skill.v1">;
+    skill: z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        skillMd: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        skillMd: string;
+        description?: string | undefined;
+    }, {
+        name: string;
+        skillMd: string;
+        description?: string | undefined;
+    }>;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodEffects<z.ZodString, string, string>;
+        contentBase64: z.ZodString;
+        sha256: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        sha256: string;
+        contentBase64: string;
+    }, {
+        path: string;
+        sha256: string;
+        contentBase64: string;
+    }>, "many">;
+    provenance: z.ZodObject<{
+        kind: z.ZodEnum<["imported", "distilled"]>;
+        /**
+         * Envelope CIDs the skill was distilled from ([] for seed imports).
+         * The "distilled from N traces" count is this array's length — never
+         * stored separately (anti-drift).
+         */
+        sourceEnvelopeCids: z.ZodArray<z.ZodString, "many">;
+        operator: z.ZodObject<{
+            safeAddress: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            safeAddress: string;
+        }, {
+            safeAddress: string;
+        }>;
+        solverType: z.ZodOptional<z.ZodString>;
+        /** Seed attribution, mirroring the seeded trace's `seed.attribution`. */
+        seed: z.ZodOptional<z.ZodObject<{
+            skill: z.ZodString;
+            source: z.ZodString;
+            licence: z.ZodNullable<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            source: string;
+            skill: string;
+            licence: string | null;
+        }, {
+            source: string;
+            skill: string;
+            licence: string | null;
+        }>>;
+        /**
+         * Success→strategic-pattern, failure→lesson, both-polarity→contrastive
+         * (spec §7, D10 + v0.5), or cross-instance corroboration→cross-instance
+         * (stage-2 meta-distill). `contrastive` and `cross-instance` are additive
+         * enum values: strict consumers (`extractSkill`) reject them until upgraded
+         * — acceptable at testnet volume, named in the spec.
+         */
+        skillKind: z.ZodOptional<z.ZodEnum<["strategic-pattern", "failure-lesson", "contrastive", "cross-instance"]>>;
+        /** SHA-256 of the exact distill prompt that produced the skill (auditability, D4). */
+        distillPromptSha256: z.ZodOptional<z.ZodString>;
+        /** Task-distribution the skill targets (e.g. 'coding'). */
+        distribution: z.ZodOptional<z.ZodString>;
+        /** Verifiability tier of the source evidence (e.g. 'evaluator-verified'). */
+        verifiabilityTier: z.ZodOptional<z.ZodString>;
+        /**
+         * The model that ran distillation (spec §5, v0.5). Distillation quality is
+         * model-sensitive; recording it makes a skill's quality auditable.
+         */
+        distillModel: z.ZodOptional<z.ZodString>;
+        /**
+         * Deterministic `ceil(utf8 chars / 4)` token estimates of the distiller
+         * input and the emitted body (spec §5, v0.5). The pair records the
+         * compression ratio (SkillRL operates at 10–20×); an auditable estimate
+         * serves that purpose better than an unreproducible exact count (the LLM
+         * port reports no usage).
+         */
+        evidenceTokens: z.ZodOptional<z.ZodNumber>;
+        skillTokens: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Envelope/manifest CID of a prior skill record this one replaces — the same
+         * identity space as `sourceEnvelopeCids` and a search-hit `ref`. Honored at
+         * read time ONLY when this record's operator matches the superseded record's
+         * operator (cross-operator supersedes are ignored); see the read-path head
+         * resolver in packages/layer/src/consume.ts.
+         */
+        supersedes: z.ZodOptional<z.ZodString>;
+        /**
+         * Pure retirement marker: retires this record's `supersedes` target with no
+         * replacement and hides this record itself from discovery. A deprecation
+         * record carries no successor skill content.
+         */
+        deprecates: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "imported" | "distilled";
+        sourceEnvelopeCids: string[];
+        operator: {
+            safeAddress: string;
+        };
+        verifiabilityTier?: string | undefined;
+        solverType?: string | undefined;
+        seed?: {
+            source: string;
+            skill: string;
+            licence: string | null;
+        } | undefined;
+        skillKind?: "strategic-pattern" | "failure-lesson" | "contrastive" | "cross-instance" | undefined;
+        distillPromptSha256?: string | undefined;
+        distribution?: string | undefined;
+        distillModel?: string | undefined;
+        evidenceTokens?: number | undefined;
+        skillTokens?: number | undefined;
+        supersedes?: string | undefined;
+        deprecates?: boolean | undefined;
+    }, {
+        kind: "imported" | "distilled";
+        sourceEnvelopeCids: string[];
+        operator: {
+            safeAddress: string;
+        };
+        verifiabilityTier?: string | undefined;
+        solverType?: string | undefined;
+        seed?: {
+            source: string;
+            skill: string;
+            licence: string | null;
+        } | undefined;
+        skillKind?: "strategic-pattern" | "failure-lesson" | "contrastive" | "cross-instance" | undefined;
+        distillPromptSha256?: string | undefined;
+        distribution?: string | undefined;
+        distillModel?: string | undefined;
+        evidenceTokens?: number | undefined;
+        skillTokens?: number | undefined;
+        supersedes?: string | undefined;
+        deprecates?: boolean | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    schemaVersion: "jinn.skill.v1";
+    provenance: {
+        kind: "imported" | "distilled";
+        sourceEnvelopeCids: string[];
+        operator: {
+            safeAddress: string;
+        };
+        verifiabilityTier?: string | undefined;
+        solverType?: string | undefined;
+        seed?: {
+            source: string;
+            skill: string;
+            licence: string | null;
+        } | undefined;
+        skillKind?: "strategic-pattern" | "failure-lesson" | "contrastive" | "cross-instance" | undefined;
+        distillPromptSha256?: string | undefined;
+        distribution?: string | undefined;
+        distillModel?: string | undefined;
+        evidenceTokens?: number | undefined;
+        skillTokens?: number | undefined;
+        supersedes?: string | undefined;
+        deprecates?: boolean | undefined;
+    };
+    skill: {
+        name: string;
+        skillMd: string;
+        description?: string | undefined;
+    };
+    files: {
+        path: string;
+        sha256: string;
+        contentBase64: string;
+    }[];
+}, {
+    schemaVersion: "jinn.skill.v1";
+    provenance: {
+        kind: "imported" | "distilled";
+        sourceEnvelopeCids: string[];
+        operator: {
+            safeAddress: string;
+        };
+        verifiabilityTier?: string | undefined;
+        solverType?: string | undefined;
+        seed?: {
+            source: string;
+            skill: string;
+            licence: string | null;
+        } | undefined;
+        skillKind?: "strategic-pattern" | "failure-lesson" | "contrastive" | "cross-instance" | undefined;
+        distillPromptSha256?: string | undefined;
+        distribution?: string | undefined;
+        distillModel?: string | undefined;
+        evidenceTokens?: number | undefined;
+        skillTokens?: number | undefined;
+        supersedes?: string | undefined;
+        deprecates?: boolean | undefined;
+    };
+    skill: {
+        name: string;
+        skillMd: string;
+        description?: string | undefined;
+    };
+    files: {
+        path: string;
+        sha256: string;
+        contentBase64: string;
+    }[];
+}>, {
+    schemaVersion: "jinn.skill.v1";
+    provenance: {
+        kind: "imported" | "distilled";
+        sourceEnvelopeCids: string[];
+        operator: {
+            safeAddress: string;
+        };
+        verifiabilityTier?: string | undefined;
+        solverType?: string | undefined;
+        seed?: {
+            source: string;
+            skill: string;
+            licence: string | null;
+        } | undefined;
+        skillKind?: "strategic-pattern" | "failure-lesson" | "contrastive" | "cross-instance" | undefined;
+        distillPromptSha256?: string | undefined;
+        distribution?: string | undefined;
+        distillModel?: string | undefined;
+        evidenceTokens?: number | undefined;
+        skillTokens?: number | undefined;
+        supersedes?: string | undefined;
+        deprecates?: boolean | undefined;
+    };
+    skill: {
+        name: string;
+        skillMd: string;
+        description?: string | undefined;
+    };
+    files: {
+        path: string;
+        sha256: string;
+        contentBase64: string;
+    }[];
+}, {
+    schemaVersion: "jinn.skill.v1";
+    provenance: {
+        kind: "imported" | "distilled";
+        sourceEnvelopeCids: string[];
+        operator: {
+            safeAddress: string;
+        };
+        verifiabilityTier?: string | undefined;
+        solverType?: string | undefined;
+        seed?: {
+            source: string;
+            skill: string;
+            licence: string | null;
+        } | undefined;
+        skillKind?: "strategic-pattern" | "failure-lesson" | "contrastive" | "cross-instance" | undefined;
+        distillPromptSha256?: string | undefined;
+        distribution?: string | undefined;
+        distillModel?: string | undefined;
+        evidenceTokens?: number | undefined;
+        skillTokens?: number | undefined;
+        supersedes?: string | undefined;
+        deprecates?: boolean | undefined;
+    };
+    skill: {
+        name: string;
+        skillMd: string;
+        description?: string | undefined;
+    };
+    files: {
+        path: string;
+        sha256: string;
+        contentBase64: string;
+    }[];
+}>;
+export type SkillCompanionFile = z.infer<typeof SkillCompanionFileSchema>;
+export type SkillProvenance = z.infer<typeof SkillProvenanceSchema>;
+export type SkillArtifactV1 = z.infer<typeof SkillArtifactV1Schema>;