@dot-skill/core 0.4.2 → 0.5.0

package/README.md

@@ -0,0 +1,38 @@
+# `@dot-skill/core`
+
+Compile, pack, validate, and mint `.skill` packages for the [Open `.skill` Protocol](https://github.com/dot-skill/dot-skill).
+
+Turns a **SkillSource** / **SkillContract** into a deterministic ZIP with digests, privacy scrubbing, completeness gates, and optional mint attestation.
+
+## Install
+
+```bash
+npm i @dot-skill/core
+```
+
+## Capabilities
+
+| Function | Role |
+|----------|------|
+| Compile | SkillSource → package files; release profile refuses if incomplete |
+| Pack / unpack | Deterministic ZIP container |
+| Validate | Structure + SHA-256 digests |
+| Mint | Creation attestation (reference HMAC is development-only) |
+| Inspect helpers | Manifest and seal visibility without execution |
+
+## Profiles
+
+- **`continuity`** — handoff draft; soft gaps allowed; not mintable
+- **`release`** — complete or `compile_refused`; mintable when approved
+
+## Related
+
+- [`@dot-skill/protocol`](https://www.npmjs.com/package/@dot-skill/protocol) — types & contract
+- [`@dot-skill/runtime`](https://www.npmjs.com/package/@dot-skill/runtime) — inspect / dry-run / execute
+- [`skillerr`](https://www.npmjs.com/package/skillerr) — public install (`skill` CLI)
+
+Docs: [PROTOCOL.md](https://github.com/dot-skill/dot-skill/blob/main/docs/PROTOCOL.md) · [MINT.md](https://github.com/dot-skill/dot-skill/blob/main/docs/MINT.md)
+
+## License
+
+MIT

package/dist/compile.js

@@ -1,5 +1,5 @@
 import { createHash, randomUUID } from "node:crypto";
-import { DEFAULT_SKILL_POLICY, CONTAINER_VERSION, PROTOCOL_VERSION, WORKFLOW_DIALECT_VERSION, isValidAgentHost, recipeToSkillSource, } from "@dot-skill/protocol";
+import { DEFAULT_SKILL_POLICY, CONTAINER_VERSION, PROTOCOL_VERSION, WORKFLOW_DIALECT_VERSION, assessSkillContract, isValidAgentHost, recipeToSkillSource, } from "@dot-skill/protocol";
 import { packSkill, finalizeManifest, buildFileMap } from "./pack.js";
 const PLACEHOLDER_RE = /\{\{([a-zA-Z_][a-zA-Z0-9_]*)\}\}|<([A-Z][A-Z0-9_]+)>|\$\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g;
 const SECRET_PATTERNS = [
@@ -135,14 +135,391 @@ export function assessCompleteness(source, opts) {
         complete: requiredMissing.length === 0,
         present,
         missing: requiredMissing,
-        hints: requiredMissing.map((m) => HINTS[m]),
+        hints: requiredMissing.map((m) => HINTS[m] ?? `Complete the ${m} declaration.`),
     };
 }
 function sectionHasWorkflowAction(sections) {
     return sections.some((s) => ["integration", "prompt", "implementation_note", "workflow_note", "code", "config"].includes(s.type));
 }
+function declaredItems(declaration) {
+    if (!declaration)
+        return [];
+    return declaration.status === "specified" ? declaration.items ?? [] : [];
+}
+function contractCompleteness(assessment, profile) {
+    const missing = [...new Set(assessment.issues.map((issue) => {
+            const root = issue.field.split(".")[0];
+            return (root === "contract" ? "semantic_contract" : root);
+        }))];
+    const contractParts = [
+        "semantic_contract",
+        "intent",
+        "triggers",
+        "inputs",
+        "preconditions",
+        "steps",
+        "branches",
+        "human_decisions",
+        "capabilities",
+        "permissions",
+        "forbidden_actions",
+        "outputs",
+        "recovery",
+        "verification",
+        "corrections",
+        "provenance",
+    ];
+    return {
+        kind: "completeness_report",
+        profile,
+        complete: assessment.complete,
+        present: contractParts.filter((part) => !missing.includes(part)),
+        missing,
+        hints: assessment.issues.map((issue) => `${issue.field}: ${issue.fix}`),
+    };
+}
+function compileContractStep(step) {
+    const base = {
+        id: step.id,
+        title: step.title,
+        optional: step.optional,
+        next: step.next,
+        on_fail: step.on_failure,
+    };
+    switch (step.kind) {
+        case "instruct":
+            return { ...base, kind: "instruct", text: step.instruction ?? "" };
+        case "prompt":
+            return { ...base, kind: "prompt", template: step.instruction ?? "" };
+        case "tool":
+            return {
+                ...base,
+                kind: "tool",
+                capability: step.capability ?? "",
+                arguments: step.arguments,
+                argument_bindings: step.argument_bindings,
+                result_as: step.result_as,
+            };
+        case "transform":
+            return {
+                ...base,
+                kind: "transform",
+                expression: step.instruction ?? "identity",
+                result_as: step.result_as,
+            };
+        case "checkpoint":
+            return { ...base, kind: "checkpoint", message: step.instruction };
+        case "human_decision":
+            return {
+                ...base,
+                kind: "human_decision",
+                prompt: step.instruction ?? step.decision ?? step.title,
+                result_as: step.result_as,
+            };
+        case "verify":
+            return { ...base, kind: "verify", assertions: step.assertions ?? [] };
+        case "emit":
+            return {
+                ...base,
+                kind: "emit",
+                output: step.output ?? "",
+                from: step.from ?? "",
+            };
+    }
+}
+function compileNativeContract(source, opts, profile) {
+    const contract = source.contract;
+    if (!isValidAgentHost(source.agent.host) || !source.journey?.summary?.trim()) {
+        const missing = [];
+        const hints = [];
+        if (!isValidAgentHost(source.agent.host)) {
+            missing.push("agent_context");
+            hints.push(HINTS.agent_context);
+        }
+        if (!source.journey?.summary?.trim()) {
+            missing.push("journey");
+            hints.push(HINTS.journey);
+        }
+        throw new CompileRefusalError({
+            kind: "completeness_report",
+            profile,
+            complete: false,
+            present: [],
+            missing,
+            hints,
+        });
+    }
+    const assessment = assessSkillContract(contract, profile);
+    const completeness = contractCompleteness(assessment, profile);
+    if (!assessment.complete && !opts.allow_incomplete && profile === "release") {
+        throw new CompileRefusalError(completeness);
+    }
+    const skillId = opts.skill_id ?? shortId("skl");
+    const inputs = declaredItems(contract.inputs).map((input) => ({
+        name: input.name,
+        description: input.description,
+        schema: structuredClone(input.schema),
+        required: input.required,
+        ...(input.default !== undefined ? { default: structuredClone(input.default) } : {}),
+        sensitivity: input.sensitivity,
+        source: input.source,
+        ask_when: input.ask_when,
+        approval: input.approval,
+        // Contract review approves the slot definition; human_before_use remains a runtime gate.
+        approved: true,
+    }));
+    const outputs = declaredItems(contract.outputs).map((output) => ({
+        name: output.name,
+        description: output.description,
+        schema: structuredClone(output.schema),
+        required: output.required,
+        media_type: output.media_type,
+        assert: output.assertions,
+    }));
+    const capabilities = declaredItems(contract.capabilities).map((capability) => ({
+        ...structuredClone(capability),
+    }));
+    const permissions = declaredItems(contract.permissions).map((permission) => ({
+        side_effect_class: permission.side_effect_class,
+        description: permission.description,
+        paths: permission.paths,
+        hosts: permission.hosts,
+        requires_consent: permission.consent === "explicit_human",
+    }));
+    const knowledge = source.sections.map((section) => ({
+        kind: "knowledge",
+        id: `k_${section.id.replace(/[^a-zA-Z0-9]/g, "").slice(0, 16)}`,
+        type: knowledgeTypeFor(section),
+        title: section.title,
+        body: redactSecrets(section.body),
+        fidelity: "exact",
+        pinned: true,
+        sensitivity: section.sensitivity === "public" ? "public" : "private",
+        provenance: [{ kind: "section", id: section.id, revision: section.revision, hash: source.hash }],
+    }));
+    const steps = declaredItems(contract.steps).map(compileContractStep);
+    for (let i = 0; i < steps.length - 1; i++) {
+        if (!steps[i].next)
+            steps[i].next = steps[i + 1].id;
+    }
+    let entrypoint = steps[0]?.id;
+    for (const branch of declaredItems(contract.branches)) {
+        const branchStep = {
+            id: branch.id,
+            kind: "branch",
+            title: `Conditional branch: ${branch.condition}`,
+            cases: [{ when: branch.condition, goto: branch.then }],
+            else: branch.otherwise,
+        };
+        steps.push(branchStep);
+        if (branch.after_step) {
+            const parent = steps.find((step) => step.id === branch.after_step);
+            if (parent)
+                parent.next = branch.id;
+        }
+    }
+    for (const decision of declaredItems(contract.human_decisions)) {
+        const decisionStep = {
+            id: decision.id,
+            kind: "human_decision",
+            title: decision.prompt,
+            prompt: decision.prompt,
+            choices: decision.choices,
+            result_as: decision.id,
+            next: decision.required_before,
+        };
+        for (const step of steps) {
+            if (step.next === decision.required_before)
+                step.next = decision.id;
+        }
+        if (entrypoint === decision.required_before)
+            entrypoint = decision.id;
+        steps.push(decisionStep);
+    }
+    for (const input of declaredItems(contract.inputs).filter((item) => item.approval === "human_before_use")) {
+        const id = `approve_input_${slug(input.name)}`;
+        steps.push({
+            id,
+            kind: "human_decision",
+            title: `Approve input ${input.name}`,
+            prompt: `Approve use of input ${input.name}: ${input.description}`,
+            choices: ["approve", "deny"],
+            result_as: id,
+            next: entrypoint,
+        });
+        entrypoint = id;
+    }
+    for (const edge of declaredItems(contract.recovery)) {
+        const from = steps.find((step) => step.id === edge.from_step);
+        if (from && edge.goto)
+            from.on_fail = edge.goto;
+    }
+    if (declaredItems(contract.preconditions).length) {
+        const id = "contract_preconditions";
+        steps.push({
+            id,
+            kind: "verify",
+            title: "Verify contract preconditions",
+            assertions: declaredItems(contract.preconditions).map((item) => `precondition:${item.id}`),
+            next: entrypoint,
+        });
+        entrypoint = id;
+    }
+    const verification = declaredItems(contract.verification);
+    if (verification.length) {
+        const id = "contract_verification";
+        const terminal = steps.find((step) => !step.next && step.id !== id);
+        if (terminal)
+            terminal.next = id;
+        steps.push({
+            id,
+            kind: "verify",
+            title: "Verify domain assertions",
+            assertions: verification.map((item) => `contract_assertion:${item.id}`),
+        });
+        if (!entrypoint)
+            entrypoint = id;
+    }
+    if (!entrypoint) {
+        const id = "contract_noop";
+        steps.push({
+            id,
+            kind: "instruct",
+            title: "No operational steps declared",
+            text: contract.intent,
+        });
+        entrypoint = id;
+    }
+    const constraints = declaredItems(contract.forbidden_actions).map((forbidden) => ({
+        kind: "steering_constraint",
+        id: forbidden.id,
+        verb: "reject",
+        effect: "forbidden",
+        statement: forbidden.description,
+    }));
+    const report = {
+        kind: "compilation_report",
+        skill_id: skillId,
+        source_id: source.id,
+        profile,
+        created_at: new Date().toISOString(),
+        mappings: [],
+        inferred_inputs: [],
+        issues: assessment.issues.map((issue) => ({
+            severity: profile === "release" ? "error" : "warning",
+            code: `contract_${issue.code}`,
+            message: `${issue.field}: ${issue.message}`,
+            related: [issue.field],
+        })),
+        pending_approvals: [],
+        approved: contract.provenance.human_review.status === "reviewed",
+        completeness,
+        semantic_contract: "native_0.5",
+    };
+    const safeJourney = {
+        ...source.journey,
+        summary: redactSecrets(source.journey.summary),
+        open_questions: source.journey.open_questions?.map(redactSecrets),
+        decisions: source.journey.decisions?.map(redactSecrets),
+        redacted: true,
+    };
+    const files = {
+        manifest: {
+            kind: "dot-skill",
+            id: skillId,
+            version: opts.version ?? "1.0.0",
+            title: opts.title ?? contract.title,
+            description: opts.description ?? source.summary ?? contract.intent,
+            intent: contract.intent,
+            contract: structuredClone(contract),
+            triggers: declaredItems(contract.triggers),
+            preconditions: structuredClone(contract.preconditions),
+            branches: structuredClone(contract.branches),
+            human_decisions: structuredClone(contract.human_decisions),
+            forbidden_actions: structuredClone(contract.forbidden_actions),
+            recovery: structuredClone(contract.recovery),
+            verification: structuredClone(contract.verification),
+            corrections: structuredClone(contract.corrections),
+            authors: source.actor ? [source.actor] : undefined,
+            container_version: CONTAINER_VERSION,
+            protocol_version: PROTOCOL_VERSION,
+            entrypoint,
+            inputs,
+            outputs,
+            capabilities,
+            permissions,
+            policy: { ...DEFAULT_SKILL_POLICY },
+            content: [],
+            package_digest: "sha256:" + "0".repeat(64),
+            provenance_mode: opts.provenance_mode ?? (profile === "continuity" ? "redacted" : "full"),
+            compile_profile: profile,
+            completeness,
+            package_sensitivity: contract.sensitivity,
+            mint: { mint_status: "draft" },
+            needs_human_review: profile === "continuity" || contract.provenance.human_review.status !== "reviewed",
+        },
+        workflow: {
+            kind: "workflow",
+            dialect_version: WORKFLOW_DIALECT_VERSION,
+            entrypoint,
+            steps,
+            constraints,
+            preconditions: structuredClone(contract.preconditions),
+            branches: structuredClone(contract.branches),
+            human_decisions: structuredClone(contract.human_decisions),
+            recovery: structuredClone(contract.recovery),
+            verification: structuredClone(contract.verification),
+        },
+        knowledge,
+        provenance: {
+            source: opts.provenance_mode === "proof_only"
+                ? undefined
+                : {
+                    id: source.id,
+                    hash: source.hash,
+                    title: source.title,
+                    contract: structuredClone(contract),
+                    agent: {
+                        ...source.agent,
+                        endpoint: source.agent.endpoint
+                            ? redactSecrets(source.agent.endpoint)
+                            : undefined,
+                    },
+                    section_ids: source.sections.map((section) => `${section.id}@${section.revision}`),
+                },
+            journey: safeJourney,
+            generation_usage: opts.generation_usage ?? source.generation_usage,
+            proof: { source_id: source.id, source_hash: source.hash },
+            compilation_report: report,
+        },
+    };
+    const fileMap = buildFileMap(files);
+    files.manifest = finalizeManifest(files.manifest, fileMap);
+    const packageBytes = packSkill(files);
+    return {
+        files,
+        report,
+        packageBytes,
+        pending_approvals: [],
+        completeness,
+    };
+}
 export function compileSkillSource(source, opts = {}) {
     const profile = opts.profile ?? "release";
+    if (source.contract)
+        return compileNativeContract(source, opts, profile);
+    if (profile === "release") {
+        throw new CompileRefusalError({
+            kind: "completeness_report",
+            profile,
+            complete: false,
+            present: [],
+            missing: ["semantic_contract"],
+            hints: [
+                "Legacy 0.4 SkillSource/Recipe text is a lossy adapter. Add a protocol 0.5 SkillContract and assess it before release compile; use continuity only for migration.",
+            ],
+        });
+    }
     const skillId = opts.skill_id ?? shortId("skl");
     const version = opts.version ?? "1.0.0";
     const issues = [];
@@ -380,8 +757,12 @@ export function compileSkillSource(source, opts = {}) {
         hasInputsDeclared,
         pendingApprovals: pending,
     });
-    if (!completeness.complete && !opts.allow_incomplete && profile === "release") {
-        throw new CompileRefusalError(completeness);
+    if (!source.contract) {
+        completeness.complete = false;
+        if (!completeness.missing.includes("semantic_contract")) {
+            completeness.missing.push("semantic_contract");
+        }
+        completeness.hints.push("Add a 0.5 SkillContract. Legacy text was retained for continuity but structured semantics are unknown.");
     }
     if (!completeness.complete && profile === "continuity") {
         // continuity still requires hard parts
@@ -429,6 +810,13 @@ export function compileSkillSource(source, opts = {}) {
         pending_approvals: pending,
         approved: pending.length === 0,
         completeness,
+        semantic_contract: "legacy_lossy",
+        losses: [
+            "intent/triggers may be inferred from title or summary",
+            "inputs inferred from placeholders lose original schema semantics",
+            "preconditions, branches, outputs, recovery, and verification may remain prose",
+            "human review cannot be reconstructed from legacy text",
+        ],
     };
     const files = {
         manifest: {
@@ -440,7 +828,7 @@ export function compileSkillSource(source, opts = {}) {
                 source.summary ??
                 `Skill compiled from source ${source.id}`,
             intent: source.intent ?? source.summary,
-            triggers: [source.title],
+            triggers: [{ id: "legacy_title", description: source.title }],
             authors: source.actor ? [source.actor] : undefined,
             container_version: CONTAINER_VERSION,
             protocol_version: PROTOCOL_VERSION,
@@ -476,6 +864,7 @@ export function compileSkillSource(source, opts = {}) {
             package_sensitivity: source.sensitivity,
             mint: { mint_status: "draft" },
             needs_human_review: pending.length > 0 || profile === "continuity",
+            legacy: true,
         },
         workflow: {
             kind: "workflow",

package/dist/hash.d.ts

@@ -1,3 +1,4 @@
+import type { SealedManifestClaims, SkillManifest } from "@dot-skill/protocol";
 /** RFC 8785-inspired JSON Canonicalization for I-JSON-compatible objects. */
 export declare function canonicalize(value: unknown): string;
 export declare function sha256Hex(data: string | Uint8Array): string;
@@ -6,3 +7,12 @@ export declare function packageDigestFromContent(content: Array<{
     path: string;
     digest: string;
 }>): string;
+/** Public development HMAC key — forgeable; never production trust. */
+export declare const PUBLIC_DEV_MINT_KEY = "dot-skill-dev-mint-key";
+export declare const PUBLIC_DEV_MINT_KEY_ID = "dot-skill-dev-mint-key";
+/**
+ * Build the claim set covered by the creation seal.
+ * Binds identity, intent, permissions, policy, capabilities, inputs, and content digests.
+ */
+export declare function buildSealedManifestClaims(manifest: SkillManifest): SealedManifestClaims;
+export declare function sealedManifestDigest(manifest: SkillManifest): string;

package/dist/hash.js

@@ -50,3 +50,73 @@ export function packageDigestFromContent(content) {
     }
     return sha256Digest(canonicalize({ paths }));
 }
+/** Public development HMAC key — forgeable; never production trust. */
+export const PUBLIC_DEV_MINT_KEY = "dot-skill-dev-mint-key";
+export const PUBLIC_DEV_MINT_KEY_ID = "dot-skill-dev-mint-key";
+/**
+ * Build the claim set covered by the creation seal.
+ * Binds identity, intent, permissions, policy, capabilities, inputs, and content digests.
+ */
+export function buildSealedManifestClaims(manifest) {
+    const claims = {
+        id: manifest.id,
+        version: manifest.version,
+        title: manifest.title,
+        intent: manifest.intent,
+        description: manifest.description,
+        package_digest: manifest.package_digest,
+        permissions: [...manifest.permissions]
+            .map((p) => ({
+            side_effect_class: p.side_effect_class,
+            description: p.description,
+            paths: p.paths,
+            hosts: p.hosts,
+            requires_consent: p.requires_consent,
+        }))
+            .sort((a, b) => `${a.side_effect_class}:${a.description}`.localeCompare(`${b.side_effect_class}:${b.description}`)),
+        policy: {
+            require_signatures: manifest.policy.require_signatures,
+            require_minted: manifest.policy.require_minted,
+            require_anchor: manifest.policy.require_anchor,
+            allow_network: manifest.policy.allow_network,
+            filesystem_roots: manifest.policy.filesystem_roots
+                ? [...manifest.policy.filesystem_roots].sort()
+                : undefined,
+            consent_for: [...manifest.policy.consent_for].sort(),
+            trust_profile: manifest.policy.trust_profile,
+            max_tool_calls: manifest.policy.max_tool_calls,
+            max_runtime_ms: manifest.policy.max_runtime_ms,
+            fail_on_unsupported_step: manifest.policy.fail_on_unsupported_step,
+        },
+        capabilities: [...manifest.capabilities]
+            .map((c) => ({
+            name: c.name,
+            side_effect_class: c.side_effect_class,
+            required: c.required,
+        }))
+            .sort((a, b) => a.name.localeCompare(b.name)),
+        inputs: [...manifest.inputs]
+            .map((i) => ({
+            name: i.name,
+            sensitivity: i.sensitivity,
+            required: i.required,
+            source: i.source,
+        }))
+            .sort((a, b) => a.name.localeCompare(b.name)),
+        content: [...manifest.content]
+            .map((c) => ({ path: c.path, digest: c.digest, media_type: c.media_type, bytes: c.bytes }))
+            .sort((a, b) => a.path.localeCompare(b.path)),
+    };
+    if (manifest.contract) {
+        claims.contract = {
+            title: manifest.contract.title,
+            intent: manifest.contract.intent,
+            skill_kind: manifest.contract.skill_kind,
+            sensitivity: manifest.contract.sensitivity,
+        };
+    }
+    return claims;
+}
+export function sealedManifestDigest(manifest) {
+    return sha256Digest(canonicalize(buildSealedManifestClaims(manifest)));
+}

package/dist/index.d.ts

@@ -1,12 +1,12 @@
 /** @dot-skill/core — pack, unpack, validate, mint, compile .skill packages. */
-export { canonicalize, sha256Hex, sha256Digest, packageDigestFromContent } from "./hash.js";
+export { canonicalize, sha256Hex, sha256Digest, packageDigestFromContent, buildSealedManifestClaims, sealedManifestDigest, PUBLIC_DEV_MINT_KEY, PUBLIC_DEV_MINT_KEY_ID, } from "./hash.js";
 export { normalizePath, assertSafePaths, MAX_ENTRIES, MAX_UNCOMPRESSED_BYTES, MAX_COMPRESSION_RATIO, } from "./paths.js";
 export { buildFileMap, finalizeManifest, packSkill, unpackSkill, } from "./pack.js";
 export type { PackOptions, UnpackResult } from "./pack.js";
 export { validateManifestShape, validateWorkflowShape, validatePackageBytes, inspectSkill, } from "./validate.js";
 export type { ValidationIssue, ValidationResult } from "./validate.js";
 export { migrateLegacySkill, toSkillMdAdapter } from "./migrate.js";
-export { mintSkillPackage, addPermanenceAnchor, verifyMintTrust, } from "./mint.js";
-export type { MintOptions } from "./mint.js";
+export { mintSkillPackage, addPermanenceAnchor, verifyMintTrust, inspectTrustView, } from "./mint.js";
+export type { MintOptions, VerifyMintTrustOptions } from "./mint.js";
 export { compileSkillSource, compileRecipeToSkill, approveCompilation, assessCompleteness, redactSecrets, CompileRefusalError, } from "./compile.js";
 export type { CompileOptions, CompileResult } from "./compile.js";

package/dist/index.js

@@ -1,8 +1,8 @@
 /** @dot-skill/core — pack, unpack, validate, mint, compile .skill packages. */
-export { canonicalize, sha256Hex, sha256Digest, packageDigestFromContent } from "./hash.js";
+export { canonicalize, sha256Hex, sha256Digest, packageDigestFromContent, buildSealedManifestClaims, sealedManifestDigest, PUBLIC_DEV_MINT_KEY, PUBLIC_DEV_MINT_KEY_ID, } from "./hash.js";
 export { normalizePath, assertSafePaths, MAX_ENTRIES, MAX_UNCOMPRESSED_BYTES, MAX_COMPRESSION_RATIO, } from "./paths.js";
 export { buildFileMap, finalizeManifest, packSkill, unpackSkill, } from "./pack.js";
 export { validateManifestShape, validateWorkflowShape, validatePackageBytes, inspectSkill, } from "./validate.js";
 export { migrateLegacySkill, toSkillMdAdapter } from "./migrate.js";
-export { mintSkillPackage, addPermanenceAnchor, verifyMintTrust, } from "./mint.js";
+export { mintSkillPackage, addPermanenceAnchor, verifyMintTrust, inspectTrustView, } from "./mint.js";
 export { compileSkillSource, compileRecipeToSkill, approveCompilation, assessCompleteness, redactSecrets, CompileRefusalError, } from "./compile.js";

package/dist/mint.d.ts

@@ -1,4 +1,4 @@
-import type { CreationAttestation, PermanenceAnchor, SkillPackageFiles, TrustProfile } from "@dot-skill/protocol";
+import type { CreationAttestation, HostClaimBinding, PermanenceAnchor, SkillPackageFiles, TrustProfile, TrustState, TrustView } from "@dot-skill/protocol";
 import { type ValidationIssue } from "./validate.js";
 export interface MintOptions {
     host: string;
@@ -11,16 +11,47 @@ export interface MintOptions {
     endpoint?: string;
     actors?: string[];
     /**
-     * HMAC-style digest seal for development/testing only.
-     * REFERENCE IMPLEMENTATION ONLY — not production PKI.
-     * Default key is `dot-skill-dev-mint-key` and must be replaced in production.
+     * HMAC-style digest seal.
+     * Omit / use the public constant only for local development — never production trust.
      */
     issuer_secret?: string;
     policy_profile?: TrustProfile;
+    /**
+     * Evidence that mint was invoked from an agent runtime path (not a bare human shell
+     * that only exported SKILL_HOST). Markers are still locally spoofable; residual risk
+     * for local LLMs remains.
+     */
+    agent_runtime_evidence?: {
+        markers?: string[];
+        session_id?: string;
+    };
+    /**
+     * Only set when a non-public issuer key authenticates the host/model claim.
+     * Default is always self_reported.
+     */
+    host_claim_binding?: HostClaimBinding;
+    /** Env snapshot for marker detection (defaults to process.env). */
+    env?: Record<string, string | undefined>;
+}
+export interface VerifyMintTrustOptions {
+    issuer_secret?: string;
+    /**
+     * When true, public-dev HMAC may pass structural verification as trust_state=development.
+     * Production execute paths must leave this false (fail closed).
+     */
+    allow_development_issuer?: boolean;
+    /** Accept self_reported host binding as ok for the requested profile. Default false for minted+. */
+    allow_self_reported?: boolean;
 }
 /**
  * Seal a draft package as minted.
  * Content under signatures/ may change; package_digest (content) stays fixed after finalize.
+ *
+ * Trust rules:
+ * - Forbidden hosts (human/cli/shell/manual/…) refuse mint entirely.
+ * - Env-only SKILL_HOST without agent runtime markers still mints, but as self_reported
+ *   + public_dev_hmac — never production trust.
+ * - Seal binds sealed_manifest_digest (identity + policy + content claims).
  */
 export declare function mintSkillPackage(pkg: SkillPackageFiles, opts: MintOptions): {
     files: SkillPackageFiles;
@@ -30,8 +61,13 @@ export declare function mintSkillPackage(pkg: SkillPackageFiles, opts: MintOptio
 export declare function addPermanenceAnchor(archive: Uint8Array, anchor: Omit<PermanenceAnchor, "package_digest"> & {
     package_digest?: string;
 }): Uint8Array;
-export declare function verifyMintTrust(archive: Uint8Array, profile?: TrustProfile, issuer_secret?: string): {
+export declare function verifyMintTrust(archive: Uint8Array, profile?: TrustProfile, issuer_secret_or_opts?: string | VerifyMintTrustOptions): {
     ok: boolean;
     issues: ValidationIssue[];
     attestation?: CreationAttestation;
+    trust_state: TrustState;
 };
+/**
+ * TrustView from skill.json + signatures + digests only — no compile, no model body ingest.
+ */
+export declare function inspectTrustView(archive: Uint8Array): TrustView;

package/dist/mint.js

@@ -1,14 +1,48 @@
-import { isValidAgentHost } from "@dot-skill/protocol";
-import { canonicalize, sha256Digest } from "./hash.js";
+import { readFileSync } from "node:fs";
+import { detectAgentRuntimeMarkers, hasAgentRuntimeEvidence, isValidAgentHost, } from "@dot-skill/protocol";
+import { canonicalize, PUBLIC_DEV_MINT_KEY, PUBLIC_DEV_MINT_KEY_ID, sealedManifestDigest, sha256Digest, } from "./hash.js";
 import { packSkill, unpackSkill } from "./pack.js";
 import { validatePackageBytes } from "./validate.js";
+function loadCoreIdentity() {
+    const metadata = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+    if (typeof metadata.name !== "string" || typeof metadata.version !== "string") {
+        throw new Error("Invalid @dot-skill/core package metadata");
+    }
+    return { name: metadata.name, version: metadata.version };
+}
+const CORE_IDENTITY = loadCoreIdentity();
+function resolveIssuerClass(secret, keyId) {
+    if (secret === PUBLIC_DEV_MINT_KEY || keyId === PUBLIC_DEV_MINT_KEY_ID) {
+        return "public_dev_hmac";
+    }
+    return "configured_hmac";
+}
+function resolveHostClaimBinding(opts, issuerClass, markers) {
+    if (opts.host_claim_binding === "verified_issuer") {
+        if (issuerClass === "public_dev_hmac") {
+            throw new Error("Cannot mark host_claim_binding=verified_issuer with the public development HMAC key");
+        }
+        if (!hasAgentRuntimeEvidence(opts.agent_runtime_evidence, opts.env) && markers.length === 0) {
+            throw new Error("verified_issuer host binding requires agent runtime evidence (markers or session_id)");
+        }
+        return "verified_issuer";
+    }
+    return "self_reported";
+}
 /**
  * Seal a draft package as minted.
  * Content under signatures/ may change; package_digest (content) stays fixed after finalize.
+ *
+ * Trust rules:
+ * - Forbidden hosts (human/cli/shell/manual/…) refuse mint entirely.
+ * - Env-only SKILL_HOST without agent runtime markers still mints, but as self_reported
+ *   + public_dev_hmac — never production trust.
+ * - Seal binds sealed_manifest_digest (identity + policy + content claims).
  */
 export function mintSkillPackage(pkg, opts) {
     if (!isValidAgentHost(opts.host)) {
-        throw new Error(`Mint host "${opts.host}" is not a valid AI agent host. Use cursor, ollama, lmstudio, llama-cpp, custom-agent, …`);
+        throw new Error(`Mint host "${opts.host}" is not a valid AI agent host (denylisted human/cli/shell/manual). ` +
+            `Use an agent host id such as cursor, ollama, lmstudio, llama-cpp, custom-agent.`);
     }
     if (pkg.manifest.needs_human_review) {
         throw new Error("Cannot mint while needs_human_review is true — approve inputs/permissions first");
@@ -22,6 +56,7 @@ export function mintSkillPackage(pkg, opts) {
     const report = pkg.provenance?.compilation_report;
     if (!report ||
         report.profile !== "release" ||
+        report.semantic_contract !== "native_0.5" ||
         !report.completeness.complete ||
         !report.approved ||
         report.pending_approvals.length > 0) {
@@ -39,22 +74,48 @@ export function mintSkillPackage(pkg, opts) {
     });
     const unpacked = unpackSkill(draftBytes);
     const package_digest = unpacked.manifest.package_digest;
+    const agentRuntime = opts.agent_runtime ?? CORE_IDENTITY.name;
+    const agentVersion = opts.agent_version ?? (agentRuntime === CORE_IDENTITY.name ? CORE_IDENTITY.version : "unknown");
+    const secret = opts.issuer_secret ?? PUBLIC_DEV_MINT_KEY;
+    const keyId = opts.key_id ?? (secret === PUBLIC_DEV_MINT_KEY ? PUBLIC_DEV_MINT_KEY_ID : "configured-issuer");
+    const issuer_class = resolveIssuerClass(secret, keyId);
+    const markers = [
+        ...detectAgentRuntimeMarkers(opts.env),
+        ...(opts.agent_runtime_evidence?.markers ?? []),
+    ].filter((m, i, arr) => arr.indexOf(m) === i);
+    const host_claim_binding = resolveHostClaimBinding(opts, issuer_class, markers);
+    // Apply seal-bound policy updates before hashing sealed_manifest_digest so
+    // attestation covers the final identity/policy/content claims.
+    const sealedManifestBase = {
+        ...unpacked.manifest,
+        policy: {
+            ...unpacked.manifest.policy,
+            require_signatures: true,
+            require_minted: true,
+            trust_profile: opts.policy_profile ?? "minted",
+        },
+    };
+    const sealed_manifest_digest = sealedManifestDigest(sealedManifestBase);
     const attestation = {
         kind: "creation_attestation",
         package_digest,
+        sealed_manifest_digest,
         skill_id: pkg.manifest.id,
         skill_version: pkg.manifest.version,
         minted_at: new Date().toISOString(),
         agent: {
-            runtime: opts.agent_runtime ?? "@dot-skill/runtime",
-            version: opts.agent_version ?? "0.4.0",
-            key_id: opts.key_id ?? "dot-skill-dev-mint-key",
+            runtime: agentRuntime,
+            version: agentVersion,
+            key_id: keyId,
         },
         host: opts.host,
         provider: opts.provider,
         model: opts.model,
         deployment: opts.deployment,
         endpoint: opts.endpoint,
+        host_claim_binding,
+        issuer_class,
+        agent_runtime_markers: markers.length ? markers : undefined,
         journey: {
             source_id: pkg.provenance?.compilation_report?.source_id,
             source_hash: pkg.provenance?.proof &&
@@ -87,12 +148,6 @@ export function mintSkillPackage(pkg, opts) {
     };
     const payload = canonicalize(attestation);
     const payloadDigest = sha256Digest(payload);
-    /**
-     * REFERENCE IMPLEMENTATION ONLY.
-     * The default key "dot-skill-dev-mint-key" is a public constant for testing.
-     * Replace issuer_secret with a real private key in any production issuer.
-     */
-    const secret = opts.issuer_secret ?? "dot-skill-dev-mint-key";
     const sig = sha256Digest(`${secret}:${payloadDigest}`);
     const dsse = {
         payloadType: "application/vnd.dot-skill.creation-attestation+json",
@@ -103,7 +158,7 @@ export function mintSkillPackage(pkg, opts) {
     const minted = {
         ...unpacked.raw,
         manifest: {
-            ...unpacked.manifest,
+            ...sealedManifestBase,
             mint: {
                 mint_status: "minted",
                 minted_at: attestation.minted_at,
@@ -111,12 +166,7 @@ export function mintSkillPackage(pkg, opts) {
                 content_id: package_digest,
             },
             attestation_digest: payloadDigest,
-            policy: {
-                ...unpacked.manifest.policy,
-                require_signatures: true,
-                require_minted: true,
-                trust_profile: opts.policy_profile ?? "minted",
-            },
+            sealed_manifest_digest,
         },
         attestation,
         signatures: {
@@ -156,14 +206,30 @@ export function addPermanenceAnchor(archive, anchor) {
     };
     return packSkill(files);
 }
-export function verifyMintTrust(archive, profile = "minted", issuer_secret) {
+function extractAttestation(unpacked) {
+    const envelope = unpacked.raw.signatures?.["creation.dsse.json"];
+    const attestation = envelope?.attestation ?? unpacked.raw.attestation;
+    return { attestation, envelope };
+}
+function classifyTrustState(attestation, signedOk) {
+    if (!attestation || !signedOk)
+        return "untrusted";
+    if (attestation.issuer_class === "public_dev_hmac")
+        return "development";
+    if (attestation.host_claim_binding === "verified_issuer")
+        return "verified_issuer";
+    return "self_reported";
+}
+export function verifyMintTrust(archive, profile = "minted", issuer_secret_or_opts) {
+    const opts = typeof issuer_secret_or_opts === "string"
+        ? { issuer_secret: issuer_secret_or_opts }
+        : (issuer_secret_or_opts ?? {});
     const base = validatePackageBytes(archive);
     const issues = [...base.issues];
     const unpacked = unpackSkill(archive);
     const mintStatus = unpacked.manifest.mint?.mint_status ?? "draft";
-    const attestation = unpacked.raw.signatures?.["creation.dsse.json"]?.attestation
-        ?? unpacked.raw.attestation;
-    const envelope = unpacked.raw.signatures?.["creation.dsse.json"];
+    const { attestation, envelope } = extractAttestation(unpacked);
+    let signedOk = false;
     if (profile !== "open") {
         if (mintStatus !== "minted") {
             issues.push({
@@ -194,6 +260,30 @@ export function verifyMintTrust(archive, profile = "minted", issuer_secret) {
             });
         }
         else {
+            const expectedSealed = sealedManifestDigest(unpacked.manifest);
+            const sealed = attestation.sealed_manifest_digest ?? unpacked.manifest.sealed_manifest_digest;
+            if (!sealed) {
+                issues.push({
+                    severity: "error",
+                    code: "missing_sealed_manifest_digest",
+                    message: "Attestation must bind sealed_manifest_digest over identity/policy/content claims",
+                });
+            }
+            else if (sealed !== expectedSealed) {
+                issues.push({
+                    severity: "error",
+                    code: "sealed_manifest_digest_mismatch",
+                    message: "sealed_manifest_digest does not match current manifest claims",
+                });
+            }
+            if (unpacked.manifest.sealed_manifest_digest &&
+                unpacked.manifest.sealed_manifest_digest !== sealed) {
+                issues.push({
+                    severity: "error",
+                    code: "manifest_sealed_digest_mismatch",
+                    message: "Manifest sealed_manifest_digest does not match attestation",
+                });
+            }
             const payloadDigest = sha256Digest(canonicalize(attestation));
             if (envelope.payload_digest !== payloadDigest) {
                 issues.push({
@@ -202,26 +292,68 @@ export function verifyMintTrust(archive, profile = "minted", issuer_secret) {
                     message: "DSSE payload_digest does not match CreationAttestation",
                 });
             }
-            // REFERENCE IMPLEMENTATION ONLY — replace with real PKI in production.
-            const secret = issuer_secret ?? "dot-skill-dev-mint-key";
-            const expected = sha256Digest(`${secret}:${payloadDigest}`);
-            const sig = envelope?.signatures?.[0]?.sig;
-            if (sig !== expected) {
+            const issuerClass = attestation.issuer_class ??
+                (attestation.agent.key_id === PUBLIC_DEV_MINT_KEY_ID
+                    ? "public_dev_hmac"
+                    : "configured_hmac");
+            // Fail closed: public-dev HMAC is never production trust unless explicitly allowed.
+            if (issuerClass === "public_dev_hmac" && !opts.allow_development_issuer) {
                 issues.push({
                     severity: "error",
-                    code: "attestation_sig_invalid",
-                    message: "CreationAttestation signature failed verification",
+                    code: "public_dev_issuer_untrusted",
+                    message: "Seal uses the public development HMAC key — not production trust. " +
+                        "Pass allow_development_issuer only for local testing, or mint with a configured issuer secret.",
                 });
             }
-            if (!issuer_secret && attestation.agent.key_id === "dot-skill-dev-mint-key") {
+            const hostBinding = attestation.host_claim_binding ?? "self_reported";
+            if (hostBinding === "self_reported" &&
+                !opts.allow_self_reported &&
+                !opts.allow_development_issuer) {
+                issues.push({
+                    severity: "error",
+                    code: "self_reported_host_untrusted",
+                    message: "Host/model claims are self_reported (e.g. SKILL_HOST env alone). " +
+                        "Not treated as verified_issuer trust.",
+                });
+            }
+            const secret = opts.issuer_secret ??
+                (issuerClass === "public_dev_hmac" ? PUBLIC_DEV_MINT_KEY : undefined);
+            if (!secret) {
+                issues.push({
+                    severity: "error",
+                    code: "issuer_secret_required",
+                    message: "Configured issuer seal requires a matching issuer_secret in the trust store",
+                });
+            }
+            else {
+                const expected = sha256Digest(`${secret}:${payloadDigest}`);
+                const sig = envelope?.signatures?.[0]?.sig;
+                if (sig !== expected) {
+                    issues.push({
+                        severity: "error",
+                        code: "attestation_sig_invalid",
+                        message: "CreationAttestation signature failed verification",
+                    });
+                }
+                else {
+                    signedOk = true;
+                }
+            }
+            if (issuerClass === "public_dev_hmac") {
                 issues.push({
                     severity: "warning",
                     code: "development_attestation",
-                    message: "Attestation uses the public development key; provenance is self-asserted, not trusted identity",
+                    message: "Attestation uses the public development key — labeled development, never production identity",
                 });
             }
         }
     }
+    else if (attestation && envelope?.signatures?.[0]?.sig) {
+        // open profile: still classify if a seal is present
+        const payloadDigest = sha256Digest(canonicalize(attestation));
+        const secret = opts.issuer_secret ?? PUBLIC_DEV_MINT_KEY;
+        signedOk = envelope.signatures[0].sig === sha256Digest(`${secret}:${payloadDigest}`);
+    }
     if (profile === "anchored") {
         const anchors = unpacked.manifest.anchors ?? [];
         if (!anchors.length) {
@@ -242,9 +374,94 @@ export function verifyMintTrust(archive, profile = "minted", issuer_secret) {
             });
         }
     }
+    const trust_state = classifyTrustState(attestation, signedOk);
     return {
         ok: !issues.some((i) => i.severity === "error"),
         issues,
         attestation,
+        trust_state,
+    };
+}
+/**
+ * TrustView from skill.json + signatures + digests only — no compile, no model body ingest.
+ */
+export function inspectTrustView(archive) {
+    const base = validatePackageBytes(archive);
+    const warnings = [];
+    if (!base.manifest) {
+        return {
+            trust_state: "untrusted",
+            mint_status: "draft",
+            signed: false,
+            package_digest: "",
+            label: "INVALID — package failed validation",
+            warnings: [],
+            issues: base.issues,
+        };
+    }
+    const unpacked = unpackSkill(archive);
+    const m = unpacked.manifest;
+    const mint_status = m.mint?.mint_status ?? "draft";
+    const { attestation, envelope } = extractAttestation(unpacked);
+    const signed = Boolean(envelope?.signatures?.[0]?.sig && attestation);
+    let trust_state = "untrusted";
+    let label = "UNSIGNED / OPEN — untrusted";
+    if (mint_status === "draft" || !signed) {
+        trust_state = "untrusted";
+        label = "UNSIGNED / OPEN — untrusted (do not execute without --allow-untrusted)";
+        warnings.push("Package has no verified creation seal");
+    }
+    else {
+        const verify = verifyMintTrust(archive, "minted", {
+            allow_development_issuer: true,
+            allow_self_reported: true,
+        });
+        trust_state = verify.trust_state;
+        if (trust_state === "development") {
+            label = "DEVELOPMENT seal (public-dev HMAC) — not production trust";
+            warnings.push("Public development HMAC is forgeable; treat as untrusted for production execute");
+        }
+        else if (trust_state === "self_reported") {
+            label = "SELF-REPORTED agent host claims — signed but not verified_issuer";
+            warnings.push("Host/provider/model are self-asserted; local LLMs can lie about authorship");
+        }
+        else if (trust_state === "verified_issuer") {
+            label = "VERIFIED ISSUER seal — host claims bound by configured issuer";
+            warnings.push("Issuer key authenticity is established; model honesty (esp. local LLMs) remains a residual risk");
+        }
+        else {
+            label = "UNTRUSTED — seal present but verification failed";
+        }
+        for (const issue of verify.issues) {
+            if (issue.severity === "warning")
+                warnings.push(issue.message);
+        }
+    }
+    const expectedSealed = sealedManifestDigest(m);
+    return {
+        trust_state,
+        mint_status,
+        signed,
+        issuer: attestation?.agent.runtime ?? m.mint?.mint_issuer,
+        issuer_class: attestation?.issuer_class,
+        host_claim_binding: attestation?.host_claim_binding,
+        agent: attestation
+            ? {
+                host: attestation.host,
+                provider: attestation.provider,
+                model: attestation.model,
+                runtime: attestation.agent.runtime,
+                version: attestation.agent.version,
+                key_id: attestation.agent.key_id,
+                deployment: attestation.deployment,
+                markers: attestation.agent_runtime_markers,
+            }
+            : undefined,
+        package_digest: m.package_digest,
+        sealed_manifest_digest: attestation?.sealed_manifest_digest ?? m.sealed_manifest_digest ?? expectedSealed,
+        attestation_digest: m.attestation_digest,
+        label,
+        warnings,
+        issues: base.issues,
     };
 }

package/dist/validate.d.ts

@@ -21,12 +21,16 @@ export declare function inspectSkill(archive: Uint8Array): {
         version: string;
         title: string;
         description: string;
+        intent?: string;
         inputs: string[];
         permissions: string[];
         capabilities: string[];
         package_digest: string;
+        sealed_manifest_digest?: string;
         mint_status?: string;
         needs_human_review?: boolean;
+        trust_label?: string;
+        trust_state?: string;
     };
     issues: ValidationIssue[];
 };

package/dist/validate.js

@@ -1,4 +1,4 @@
-import { CONTAINER_VERSION, PROTOCOL_VERSION, WORKFLOW_DIALECT_VERSION, } from "@dot-skill/protocol";
+import { assessSkillContract, CONTAINER_VERSION, PROTOCOL_VERSION, WORKFLOW_DIALECT_VERSION, } from "@dot-skill/protocol";
 import { packageDigestFromContent, sha256Digest } from "./hash.js";
 import { unpackSkill } from "./pack.js";
 export function validateManifestShape(manifest) {
@@ -38,6 +38,25 @@ export function validateManifestShape(manifest) {
             message: `Unsupported protocol_version ${manifest.protocol_version}; expected ${PROTOCOL_VERSION}`,
         });
     }
+    if (manifest.compile_profile === "release") {
+        if (!manifest.contract) {
+            issues.push({
+                severity: "error",
+                code: "release_contract_missing",
+                message: "Release packages require a native 0.5 authoring contract",
+            });
+        }
+        else {
+            for (const issue of assessSkillContract(manifest.contract, "release").issues) {
+                issues.push({
+                    severity: "error",
+                    code: `contract_${issue.code}`,
+                    message: `${issue.field}: ${issue.message}`,
+                    path: issue.field,
+                });
+            }
+        }
+    }
     if (manifest.mint?.mint_status === "minted") {
         if (manifest.compile_profile !== "release") {
             issues.push({
@@ -94,6 +113,23 @@ export function validateWorkflowShape(workflow, entrypoint) {
                 message: "Each step needs id and kind",
             });
         }
+        const refs = [
+            ...(typeof step.next === "string" ? [step.next] : step.next ?? []),
+            ...(step.on_fail ? [step.on_fail] : []),
+            ...(step.kind === "branch"
+                ? [...step.cases.map((branch) => branch.goto), ...(step.else ? [step.else] : [])]
+                : []),
+        ];
+        for (const ref of refs) {
+            if (!ids.has(ref)) {
+                issues.push({
+                    severity: "error",
+                    code: "step_reference_missing",
+                    message: `Step ${step.id} references missing step ${ref}`,
+                    path: step.id,
+                });
+            }
+        }
     }
     return issues;
 }
@@ -191,11 +227,30 @@ export function inspectSkill(archive) {
                 permissions: [],
                 capabilities: [],
                 package_digest: "",
+                trust_label: "INVALID",
+                trust_state: "untrusted",
             },
             issues: result.issues,
         };
     }
     const m = result.manifest;
+    const mint_status = m.mint?.mint_status ?? "draft";
+    const signed = Boolean((result.manifest &&
+        Object.keys(
+        // signatures live outside validate result — infer from mint + attestation_digest
+        m.attestation_digest ? { signed: true } : {}).length) ||
+        mint_status === "minted");
+    // Lightweight label without full TrustView import cycle; CLI --trust uses inspectTrustView.
+    let trust_label = "UNSIGNED / OPEN — untrusted";
+    let trust_state = "untrusted";
+    if (mint_status === "minted" && m.attestation_digest) {
+        trust_label = "SEALED — use skill inspect --trust for issuer/host details";
+        trust_state = "self_reported";
+    }
+    else if (!signed || mint_status === "draft") {
+        trust_label = "UNSIGNED / OPEN — untrusted";
+        trust_state = "untrusted";
+    }
     return {
         ok: result.ok,
         summary: {
@@ -203,12 +258,16 @@ export function inspectSkill(archive) {
             version: m.version,
             title: m.title,
             description: m.description,
+            intent: m.intent,
             inputs: m.inputs.filter((i) => i.required).map((i) => i.name),
             permissions: m.permissions.map((p) => p.side_effect_class),
             capabilities: m.capabilities.map((c) => c.name),
             package_digest: m.package_digest,
-            mint_status: m.mint?.mint_status ?? "draft",
+            sealed_manifest_digest: m.sealed_manifest_digest,
+            mint_status,
             needs_human_review: m.needs_human_review,
+            trust_label,
+            trust_state,
         },
         issues: result.issues,
     };

package/package.json

@@ -1,12 +1,21 @@
 {
   "name": "@dot-skill/core",
-  "version": "0.4.2",
-  "description": "Open .skill Protocol — pack, validate, compile, mint",
+  "version": "0.5.0",
+  "description": "Compile, pack, validate, and mint portable .skill packages",
   "license": "MIT",
   "author": {
     "name": "Bharat Dudeja",
     "url": "https://github.com/bharatdudeja13-cmd"
   },
+  "keywords": [
+    "skill",
+    "dot-skill",
+    ".skill",
+    "ai-agents",
+    "agent-skills",
+    "compile",
+    "mint"
+  ],
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -18,8 +27,14 @@
     "url": "https://github.com/dot-skill/dot-skill.git",
     "directory": "packages/core"
   },
+  "homepage": "https://github.com/dot-skill/dot-skill#readme",
+  "bugs": {
+    "url": "https://github.com/dot-skill/dot-skill/issues"
+  },
   "files": [
-    "dist"
+    "dist",
+    "README.md",
+    "LICENSE"
   ],
   "exports": {
     ".": {
@@ -33,7 +48,7 @@
     "clean": "rm -rf dist"
   },
   "dependencies": {
-    "@dot-skill/protocol": "^0.4.2",
+    "@dot-skill/protocol": "^0.5.0",
     "fflate": "^0.8.2"
   },
   "devDependencies": {