@hardkas/sdk 0.9.0-alpha → 0.9.1-alpha

package/dist/index.js

@@ -11,7 +11,7 @@ import { HardkasError as HardkasError3 } from "@hardkas/core";
 
 // src/accounts.ts
 import { resolveHardkasAccount } from "@hardkas/accounts";
-import { formatSompi } from "@hardkas/core";
+import { formatSompiToKas } from "@hardkas/core";
 var HardkasAccounts = class {
   constructor(sdk) {
     this.sdk = sdk;
@@ -37,7 +37,7 @@ var HardkasAccounts = class {
     const sompi = BigInt(balanceSompi);
     return {
       sompi,
-      formatted: formatSompi(sompi)
+      formatted: formatSompiToKas(sompi)
     };
   }
   /**
@@ -47,10 +47,12 @@ var HardkasAccounts = class {
     return this.getBalance(accountNameOrAddress);
   }
   /**
-   * Lists all configured account names.
+   * Lists all available HardKAS accounts.
    */
   async list() {
-    return Object.keys(this.sdk.config.config.accounts || {});
+    const { listHardkasAccounts, describeAccount } = await import("@hardkas/accounts");
+    const accounts = listHardkasAccounts({ ...this.sdk.config.config, cwd: this.sdk.workspace.root });
+    return accounts.map((a) => describeAccount(a));
   }
   /**
    * Funds an account from another account (defaults to 'default' account).
@@ -59,7 +61,8 @@ var HardkasAccounts = class {
     let from = options?.from;
     const amount = options?.amount || "1000000000";
     if (!from) {
-      const accounts = await this.list();
+      const accountsList = await this.list();
+      const accounts = accountsList.map((a) => a.name);
       if (accounts.includes("faucet")) {
         from = "faucet";
       } else if (accounts.includes("simulated_faucet")) {
@@ -67,7 +70,9 @@ var HardkasAccounts = class {
       } else if (this.sdk.network === "simulated" && accounts.includes("alice")) {
         from = "alice";
       } else {
-        throw new Error("No funding account available.\nFor simulated mode, run Hardkas.create({ network: 'simulated', autoBootstrap: true })\nor call accounts.fund(target, { from: 'alice' }).");
+        throw new Error(
+          "No funding account available.\nFor simulated mode, run Hardkas.create({ network: 'simulated', autoBootstrap: true })\nor call accounts.fund(target, { from: 'alice' })."
+        );
       }
     }
     if (from === accountNameOrAddress) {
@@ -105,16 +110,22 @@ import {
   getBroadcastableSignedTransaction
 } from "@hardkas/artifacts";
 import { coreEvents } from "@hardkas/core";
-import { signTxPlanArtifact, validateAddressNetwork } from "@hardkas/accounts";
+import {
+  signTxPlanArtifact,
+  validateAddressNetwork
+} from "@hardkas/accounts";
 import { parseKasToSompi } from "@hardkas/core";
 import { TxPlanService } from "@hardkas/tx-builder";
+import { HardkasSchemas } from "@hardkas/artifacts";
 function normalizeSimulatedPlanInput(target, fallbackId) {
   if (target.schema === ARTIFACT_SCHEMAS.TX_PLAN && Array.isArray(target.inputs)) {
     return target;
   }
   if (target.from && target.to && target.amountSompi) {
     if (target.mode !== "simulated") {
-      throw new Error("Cannot simulate real signed artifact without parent plan. Missing plan inputs data.");
+      throw new Error(
+        "Cannot simulate real signed artifact without parent plan. Missing plan inputs data."
+      );
     }
     return {
       schema: ARTIFACT_SCHEMAS.TX_PLAN,
@@ -130,14 +141,18 @@ function normalizeSimulatedPlanInput(target, fallbackId) {
       outputs: [{ address: target.to.address, amountSompi: target.amountSompi || "0" }],
       plan: {
         inputs: [],
-        outputs: [{ address: target.to.address, amountSompi: BigInt(target.amountSompi || 0) }],
+        outputs: [
+          { address: target.to.address, amountSompi: BigInt(target.amountSompi || 0) }
+        ],
         feeSompi: 0n,
         mass: 0n,
         changeSompi: 0n
       }
     };
   }
-  throw new Error("Cannot simulate signed artifact without parent plan or embedded plan data.");
+  throw new Error(
+    "Cannot simulate signed artifact without parent plan or embedded plan data."
+  );
 }
 var HardkasTx = class {
   constructor(sdk) {
@@ -156,7 +171,9 @@ var HardkasTx = class {
       throw new Error(`To account ${toAccount.name} has no address.`);
     const amountSompi = typeof options.amount === "string" ? parseKasToSompi(options.amount) : typeof options.amount === "number" ? parseKasToSompi(options.amount.toString()) : options.amount;
     if (amountSompi === 0n) {
-      throw new Error("Kaspa value-transfer outputs require amount > 0.\nFor metadata/notary/DID marker transactions use --amount 1.\nFuture: hardkas tx anchor.");
+      throw new Error(
+        "Kaspa value-transfer outputs require amount > 0.\nFor metadata/notary/DID marker transactions use --amount 1.\nFuture: hardkas tx anchor."
+      );
     }
     const activeNetwork = this.sdk.config.config.defaultNetwork || "simnet";
     const allowMainnet = this.sdk.config.config.networks?.mainnet?.allowMainnet === true;
@@ -169,7 +186,9 @@ var HardkasTx = class {
       getUtxos: async (address) => {
         if (activeNetwork === "simulated" || this.sdk.config.config.networks?.[activeNetwork]?.kind === "simulated") {
           const { loadOrCreateLocalnetState, getSpendableUtxos } = await import("@hardkas/localnet");
-          const localState = await loadOrCreateLocalnetState({ cwd: this.sdk.workspace.root });
+          const localState = await loadOrCreateLocalnetState({
+            cwd: this.sdk.workspace.root
+          });
           const unspent = getSpendableUtxos(localState, address);
           return unspent.map((u) => {
             const parts = u.id.split(":");
@@ -278,21 +297,25 @@ var HardkasTx = class {
         basePlan.assumptionRef = options.assumption;
       }
     }
-    const { CURRENT_HASH_VERSION: CURRENT_HASH_VERSION2, calculateContentHash: calculateContentHash2 } = await import("@hardkas/artifacts");
-    const newHash = calculateContentHash2(basePlan, CURRENT_HASH_VERSION2);
+    const { CURRENT_HASH_VERSION: CURRENT_HASH_VERSION3, calculateContentHash: calculateContentHash7 } = await import("@hardkas/artifacts");
+    const newHash = calculateContentHash7(basePlan, CURRENT_HASH_VERSION3);
     basePlan.contentHash = newHash;
     if (basePlan.lineage) {
       basePlan.lineage.lineageId = newHash;
       basePlan.lineage.parentArtifactId = "";
       basePlan.lineage.rootArtifactId = newHash;
-      const finalHash = calculateContentHash2(basePlan, CURRENT_HASH_VERSION2);
+      const finalHash = calculateContentHash7(basePlan, CURRENT_HASH_VERSION3);
       basePlan.contentHash = finalHash;
       basePlan.lineage.artifactId = finalHash;
       basePlan.planId = `plan-${finalHash.slice(0, 16)}`;
     }
     this.sdk.artifacts.cacheArtifact(basePlan);
     if (basePlan.policyRefs && basePlan.policyRefs.length > 0) {
-      await this.sdk.artifacts.verify(basePlan, { throwOnInvalid: true, strict: true, enforceMetadata: false });
+      await this.sdk.artifacts.verify(basePlan, {
+        throwOnInvalid: true,
+        strict: true,
+        enforceMetadata: false
+      });
     }
     return basePlan;
   }
@@ -308,7 +331,9 @@ var HardkasTx = class {
       resolvedAccount = options.account;
     }
     if (!resolvedAccount.address) {
-      throw new Error(`Account '${resolvedAccount.name || options.account}' has no address.`);
+      throw new Error(
+        `Account '${resolvedAccount.name || options.account}' has no address.`
+      );
     }
     const activeNetwork = options.network || this.sdk.config.config.defaultNetwork || "simnet";
     const isSimulated = activeNetwork === "simulated" || this.sdk.config.config.networks?.[activeNetwork]?.kind === "simulated";
@@ -354,14 +379,14 @@ var HardkasTx = class {
         }
       }
     });
-    const { CURRENT_HASH_VERSION: CURRENT_HASH_VERSION2, calculateContentHash: calculateContentHash2 } = await import("@hardkas/artifacts");
-    const newHash = calculateContentHash2(basePlan, CURRENT_HASH_VERSION2);
+    const { CURRENT_HASH_VERSION: CURRENT_HASH_VERSION3, calculateContentHash: calculateContentHash7 } = await import("@hardkas/artifacts");
+    const newHash = calculateContentHash7(basePlan, CURRENT_HASH_VERSION3);
     basePlan.contentHash = newHash;
     if (basePlan.lineage) {
       basePlan.lineage.lineageId = newHash;
       basePlan.lineage.parentArtifactId = "";
       basePlan.lineage.rootArtifactId = newHash;
-      const finalHash = calculateContentHash2(basePlan, CURRENT_HASH_VERSION2);
+      const finalHash = calculateContentHash7(basePlan, CURRENT_HASH_VERSION3);
       basePlan.contentHash = finalHash;
       basePlan.lineage.artifactId = finalHash;
       basePlan.planId = `plan-${finalHash.slice(0, 16)}`;
@@ -374,10 +399,16 @@ var HardkasTx = class {
    */
   async sign(plan, account, options) {
     if (typeof plan === "object" && plan !== null && plan.contentHash) {
-      await this.sdk.artifacts.verify(plan, { throwOnInvalid: true, strict: true, enforceMetadata: false });
+      await this.sdk.artifacts.verify(plan, {
+        throwOnInvalid: true,
+        strict: true,
+        enforceMetadata: false
+      });
     }
-    if (this.sdk.signer && plan.schema === "hardkas.txPlan") {
-      const signedArtifact2 = await this.sdk.signer.signTransaction(plan);
+    if (this.sdk.signer && plan.schema === HardkasSchemas.TxPlan) {
+      const signedArtifact2 = await this.sdk.signer.signTransaction(
+        plan
+      );
       const { absolutePath: absolutePath2 } = await this.sdk.artifacts.write(signedArtifact2);
       const { coreEvents: coreEvents3 } = await import("@hardkas/core");
       const signedRecord2 = signedArtifact2;
@@ -413,7 +444,7 @@ var HardkasTx = class {
       resolvedAccount = await this.sdk.accounts.resolve(fromName);
     }
     let signedArtifact;
-    if (plan.schema === "hardkas.signedTx") {
+    if (plan.schema === HardkasSchemas.SignedTx) {
       if (plan.status === "signed") {
         throw new Error(
           "Cannot append signature to an already completed signed transaction."
@@ -473,7 +504,7 @@ var HardkasTx = class {
           signatures: newSignatures
         },
         signatureMetadata: newMeta,
-        lineage: createLineageTransition(partialTx, "hardkas.signedTx")
+        lineage: createLineageTransition(partialTx, HardkasSchemas.SignedTx)
       };
       if (thresholdReached) {
         draft.signedTransaction = {
@@ -485,13 +516,13 @@ var HardkasTx = class {
         delete draft.signedTransaction;
         delete draft.txId;
       }
-      const { CURRENT_HASH_VERSION: CURRENT_HASH_VERSION2 } = await import("@hardkas/artifacts");
-      const hash = calculateContentHash(draft, CURRENT_HASH_VERSION2);
+      const { CURRENT_HASH_VERSION: CURRENT_HASH_VERSION3 } = await import("@hardkas/artifacts");
+      const hash = calculateContentHash(draft, CURRENT_HASH_VERSION3);
       draft.signedId = `signed-${hash.slice(0, 16)}`;
       draft.contentHash = hash;
       if (draft.lineage) draft.lineage.artifactId = hash;
       signedArtifact = draft;
-    } else if (plan.schema === "hardkas.txPlan") {
+    } else if (plan.schema === HardkasSchemas.TxPlan) {
       if (options?.append) {
         throw new Error(
           "Do not use --append for the first signature of a transaction plan."
@@ -529,13 +560,13 @@ var HardkasTx = class {
         ];
         const thresholdReached = signatures.length >= threshold;
         const finalStatus = thresholdReached ? "signed" : "partially_signed";
-        const { HARDKAS_VERSION: HARDKAS_VERSION4, ARTIFACT_VERSION: ARTIFACT_VERSION2, CURRENT_HASH_VERSION: CURRENT_HASH_VERSION2 } = await import("@hardkas/artifacts");
+        const { HARDKAS_VERSION: HARDKAS_VERSION6, ARTIFACT_VERSION: ARTIFACT_VERSION2, CURRENT_HASH_VERSION: CURRENT_HASH_VERSION3 } = await import("@hardkas/artifacts");
         const draft = {
-          schema: "hardkas.signedTx",
-          schemaVersion: "hardkas.artifact.v1",
-          hardkasVersion: HARDKAS_VERSION4,
+          schema: HardkasSchemas.SignedTx,
+          schemaVersion: HardkasSchemas.ArtifactV1,
+          hardkasVersion: HARDKAS_VERSION6,
           version: ARTIFACT_VERSION2,
-          hashVersion: CURRENT_HASH_VERSION2,
+          hashVersion: CURRENT_HASH_VERSION3,
           createdAt: (/* @__PURE__ */ new Date()).toISOString(),
           status: finalStatus,
           sourcePlanId: plan.planId,
@@ -551,7 +582,7 @@ var HardkasTx = class {
             signatures
           },
           signatureMetadata,
-          lineage: createLineageTransition(plan, "hardkas.signedTx"),
+          lineage: createLineageTransition(plan, HardkasSchemas.SignedTx),
           ...plan.workflowId ? { workflowId: plan.workflowId } : {}
         };
         if (thresholdReached) {
@@ -561,19 +592,21 @@ var HardkasTx = class {
           };
           draft.txId = `simulated-${plan.planId}-tx`;
         }
-        let hash = calculateContentHash(draft, CURRENT_HASH_VERSION2);
+        let hash = calculateContentHash(draft, CURRENT_HASH_VERSION3);
         draft.signedId = `signed-${hash.slice(0, 16)}`;
         draft.contentHash = hash;
         if (draft.lineage) {
           draft.lineage.artifactId = hash;
-          hash = calculateContentHash(draft, CURRENT_HASH_VERSION2);
+          hash = calculateContentHash(draft, CURRENT_HASH_VERSION3);
           draft.contentHash = hash;
           draft.lineage.artifactId = hash;
         }
         signedArtifact = draft;
       } else {
         if (resolvedAccount.address !== plan.from.address) {
-          throw new Error(`Signer account '${resolvedAccount.address}' is not authorized to sign for '${plan.from.address}'.`);
+          throw new Error(
+            `Signer account '${resolvedAccount.address}' is not authorized to sign for '${plan.from.address}'.`
+          );
         }
         signedArtifact = await signTxPlanArtifact({
           planArtifact: plan,
@@ -613,7 +646,11 @@ var HardkasTx = class {
   async simulate(target, options = {}) {
     if (typeof target === "object" && target !== null && target.contentHash) {
       try {
-        await this.sdk.artifacts.verify(target, { throwOnInvalid: true, strict: true, enforceMetadata: false });
+        await this.sdk.artifacts.verify(target, {
+          throwOnInvalid: true,
+          strict: true,
+          enforceMetadata: false
+        });
       } catch (e) {
         if (e.message.includes("PARENT_MISSING")) {
           throw new Error("parent_plan_unresolved: Missing context plan for simulation.");
@@ -626,7 +663,9 @@ var HardkasTx = class {
       const checkTxId = target.txId || (target.schema === ARTIFACT_SCHEMAS.SIGNED_TX ? `simulated-${target.sourcePlanId || "unknown"}-tx` : `simulated-${target.planId || target.id || "unknown"}-tx`);
       if (checkTxId) {
         try {
-          const existingReceipt = await this.sdk.artifacts.read(checkTxId, { expectedSchema: ARTIFACT_SCHEMAS.TX_RECEIPT });
+          const existingReceipt = await this.sdk.artifacts.read(checkTxId, {
+            expectedSchema: ARTIFACT_SCHEMAS.TX_RECEIPT
+          });
           if (existingReceipt && existingReceipt.schema === ARTIFACT_SCHEMAS.TX_RECEIPT) {
             const receiptPath2 = getDefaultReceiptPath(checkTxId, this.sdk.config.cwd);
             return { receipt: existingReceipt, receiptPath: receiptPath2 };
@@ -643,7 +682,7 @@ var HardkasTx = class {
       saveSimulatedReceipt,
       saveSimulatedTrace
     } = await import("@hardkas/localnet");
-    const path4 = await import("path");
+    const path9 = await import("path");
     const state = await loadOrCreateLocalnetState({ cwd: this.sdk.workspace.root });
     const startTime = Date.now();
     const events = [
@@ -656,9 +695,13 @@ var HardkasTx = class {
     let targetObj = target;
     if (typeof target === "string") {
       try {
-        targetObj = await this.sdk.artifacts.read(target, { expectedSchema: ARTIFACT_SCHEMAS.TX_PLAN });
+        targetObj = await this.sdk.artifacts.read(target, {
+          expectedSchema: ARTIFACT_SCHEMAS.TX_PLAN
+        });
       } catch (e) {
-        throw new Error(`Artifact '${target}' not found. If you already have an in-memory artifact, pass the object directly to tx.simulate(artifact).`);
+        throw new Error(
+          `Artifact '${target}' not found. If you already have an in-memory artifact, pass the object directly to tx.simulate(artifact).`
+        );
       }
     }
     if (targetObj.schema === ARTIFACT_SCHEMAS.SIGNED_TX) {
@@ -668,7 +711,9 @@ var HardkasTx = class {
       planArtifact = this.sdk.artifacts.getCached(sourcePlanId);
       if (!planArtifact) {
         try {
-          planArtifact = await this.sdk.artifacts.read(sourcePlanId, { expectedSchema: ARTIFACT_SCHEMAS.TX_PLAN });
+          planArtifact = await this.sdk.artifacts.read(sourcePlanId, {
+            expectedSchema: ARTIFACT_SCHEMAS.TX_PLAN
+          });
         } catch (e) {
           throw new Error("parent_plan_unresolved");
         }
@@ -714,7 +759,7 @@ var HardkasTx = class {
     const isSimulated = activeNetwork === "simulated" || this.sdk.config.config.networks?.[activeNetwork]?.kind === "simulated";
     const receiptBase = {
       schema: ARTIFACT_SCHEMAS.TX_RECEIPT,
-      schemaVersion: "hardkas.receipt.v1",
+      schemaVersion: HardkasSchemas.TxReceiptV1,
       hardkasVersion: HARDKAS_VERSION,
       version: ARTIFACT_VERSION,
       hashVersion: CURRENT_HASH_VERSION,
@@ -816,7 +861,11 @@ var HardkasTx = class {
   async send(signedArtifact, urlOrOptions) {
     if (typeof signedArtifact === "object" && signedArtifact !== null && signedArtifact.contentHash) {
       try {
-        await this.sdk.artifacts.verify(signedArtifact, { throwOnInvalid: true, strict: true, enforceMetadata: false });
+        await this.sdk.artifacts.verify(signedArtifact, {
+          throwOnInvalid: true,
+          strict: true,
+          enforceMetadata: false
+        });
       } catch (e) {
         if (e.message.includes("PARENT_MISSING")) {
           throw new Error("parent_plan_unresolved: Missing context plan for simulation.");
@@ -844,7 +893,9 @@ var HardkasTx = class {
           try {
             const { loadSimulatedReceipt, getReceiptPath } = await import("@hardkas/localnet");
             const txIdToLoad = signedArtifact.txId || `simulated-${signedArtifact.sourcePlanId}-tx`;
-            const existingReceipt = await loadSimulatedReceipt(txIdToLoad, { cwd: this.sdk.workspace.root });
+            const existingReceipt = await loadSimulatedReceipt(txIdToLoad, {
+              cwd: this.sdk.workspace.root
+            });
             if (existingReceipt) {
               if (existingReceipt.schema === ARTIFACT_SCHEMAS.TX_RECEIPT && (existingReceipt.status === "confirmed" || existingReceipt.status === "accepted")) {
                 return {
@@ -855,7 +906,10 @@ var HardkasTx = class {
                   artifactId: existingReceipt.txId,
                   // simulated receipts use txId as artifactId
                   receipt: existingReceipt,
-                  receiptPath: getReceiptPath(existingReceipt.txId, this.sdk.workspace.root)
+                  receiptPath: getReceiptPath(
+                    existingReceipt.txId,
+                    this.sdk.workspace.root
+                  )
                 };
               }
             }
@@ -910,7 +964,7 @@ var HardkasTx = class {
       ...signedArtifact.networkProfileRef ? { networkProfileRef: signedArtifact.networkProfileRef } : {},
       ...signedArtifact.assumptionRef ? { assumptionRef: signedArtifact.assumptionRef } : {},
       tracePath: void 0,
-      lineage: createLineageTransition(signedArtifact, "hardkas.txReceipt")
+      lineage: createLineageTransition(signedArtifact, HardkasSchemas.TxReceipt)
     };
     realReceiptBase.contentHash = calculateContentHash(
       realReceiptBase,
@@ -918,7 +972,10 @@ var HardkasTx = class {
     );
     if (realReceiptBase.lineage) {
       realReceiptBase.lineage.artifactId = realReceiptBase.contentHash;
-      realReceiptBase.contentHash = calculateContentHash(realReceiptBase, CURRENT_HASH_VERSION);
+      realReceiptBase.contentHash = calculateContentHash(
+        realReceiptBase,
+        CURRENT_HASH_VERSION
+      );
       realReceiptBase.lineage.artifactId = realReceiptBase.contentHash;
     }
     const receipt = realReceiptBase;
@@ -989,11 +1046,13 @@ var HardkasQuery = class {
    * Synchronizes the query store with the filesystem artifacts.
    */
   async sync(options) {
-    const fs4 = await import("fs");
-    const path4 = await import("path");
-    const hardkasDir = path4.join(this.sdk.workspace.root, ".hardkas");
-    if (!fs4.existsSync(hardkasDir)) {
-      throw new Error("Workspace not initialized. Run hardkas init or Hardkas.create({ autoBootstrap:true }).");
+    const fs9 = await import("fs");
+    const path9 = await import("path");
+    const hardkasDir = path9.join(this.sdk.workspace.root, ".hardkas");
+    if (!fs9.existsSync(hardkasDir)) {
+      throw new Error(
+        "Workspace not initialized. Run hardkas init or Hardkas.create({ autoBootstrap:true })."
+      );
     }
     let HardkasStore, HardkasIndexer;
     try {
@@ -1001,10 +1060,12 @@ var HardkasQuery = class {
       HardkasStore = qs.HardkasStore;
       HardkasIndexer = qs.HardkasIndexer;
     } catch (e) {
-      throw new Error("Query store backend unavailable. Install @hardkas/query-store or run query.store.rebuild.");
+      throw new Error(
+        "Query store backend unavailable. Install @hardkas/query-store or run query.store.rebuild."
+      );
     }
     const { withLock } = await import("@hardkas/core");
-    const dbPath = path4.join(hardkasDir, "store.db");
+    const dbPath = path9.join(hardkasDir, "store.db");
     const store = new HardkasStore({ dbPath });
     let stats;
     try {
@@ -1027,7 +1088,9 @@ var HardkasQuery = class {
       );
     } catch (e) {
       if (e.message?.includes("SQLITE") || e.message?.includes("Cannot read properties")) {
-        throw new Error("Query store database is not configured correctly or corrupted. Try running query.sync({ force: true }).");
+        throw new Error(
+          "Query store database is not configured correctly or corrupted. Try running query.sync({ force: true })."
+        );
       }
       throw e;
     }
@@ -1056,6 +1119,8 @@ var HardkasQuery = class {
 };
 
 // src/localnet.ts
+import { execFileSync } from "child_process";
+import { HardkasSchemas as HardkasSchemas2 } from "@hardkas/artifacts";
 var HardkasLocalnet = class {
   constructor(sdk) {
     this.sdk = sdk;
@@ -1073,17 +1138,141 @@ var HardkasLocalnet = class {
     }
   }
   /**
-   * Future: control localnet process/container from here.
+   * Status check with the same claim boundaries as `hardkas localnet status --json`.
+   */
+  async status(options = {}) {
+    const profile = options.profile || "toccata-v2";
+    const node = await this.detectToccataNode();
+    return {
+      schema: HardkasSchemas2.LocalnetStatusV1,
+      profile,
+      node,
+      miner: this.inspectDockerContainer("hardkas-toccata-stratum-v2"),
+      simulationLevels: {
+        artifactCoherence: "READY",
+        runtimeOutcome: "PARTIAL",
+        vmConsensusEquivalence: "NOT_CLAIMED"
+      }
+    };
+  }
+  /**
+   * Initializes the in-memory simulated workspace.
+   *
+   * Docker Toccata process control remains a CLI/localnet responsibility in
+   * 0.9.1-alpha; the SDK reports that boundary instead of silently shelling out.
+   */
+  async start(options = {}) {
+    const profile = options.profile || "simulated";
+    if (profile === "simulated") {
+      const { loadOrCreateLocalnetState } = await import("@hardkas/localnet");
+      await loadOrCreateLocalnetState({ cwd: this.sdk.cwd });
+      return {
+        schema: HardkasSchemas2.LocalnetControlV1,
+        profile,
+        status: "SIMULATED_LOCALNET_READY",
+        message: "Simulated localnet state is ready."
+      };
+    }
+    return {
+      schema: HardkasSchemas2.LocalnetControlV1,
+      profile,
+      status: "SDK_LOCALNET_CONTROL_UNSUPPORTED",
+      message: "SDK Docker localnet start is not supported in 0.9.1-alpha. Use `hardkas localnet start --profile toccata-v2`."
+    };
+  }
+  /**
+   * Funds a simulated account through the SDK transaction flow.
+   *
+   * Toccata Docker mining/funding remains CLI-only in 0.9.1-alpha because it
+   * depends on a local stratum/miner companion and host Docker state.
    */
-  async start() {
-    console.log("Localnet control via SDK is not yet implemented.");
-    console.log("Please use 'hardkas localnet' CLI command.");
+  async fund(identifier, options = {}) {
+    const profile = options.profile || (this.sdk.network === "simulated" ? "simulated" : "toccata-v2");
+    if (profile === "simulated") {
+      const fundOptions = {};
+      if (options.from !== void 0) fundOptions.from = options.from;
+      if (options.amount !== void 0) fundOptions.amount = options.amount;
+      const receipt = await this.sdk.accounts.fund(identifier, fundOptions);
+      return {
+        schema: HardkasSchemas2.LocalnetFundingV1,
+        profile,
+        identifier,
+        status: "SIMULATED_ACCOUNT_FUNDED",
+        receipt,
+        message: "Simulated account funded through SDK transaction simulation."
+      };
+    }
+    return {
+      schema: HardkasSchemas2.LocalnetFundingV1,
+      profile,
+      identifier,
+      status: "SDK_TOCCATA_FUNDING_UNSUPPORTED",
+      message: "SDK Toccata funding is not supported in 0.9.1-alpha. Use `hardkas localnet fund <account> --profile toccata-v2`."
+    };
   }
   /**
    * Resets the localnet state (simulated or node).
    */
   async reset() {
-    console.log("Localnet reset via SDK is not yet implemented.");
+    const { resetLocalnetState } = await import("@hardkas/localnet");
+    await resetLocalnetState({ cwd: this.sdk.cwd });
+  }
+  async detectToccataNode() {
+    const rpcUrl = "ws://127.0.0.1:18210";
+    const { JsonWrpcKaspaClient: JsonWrpcKaspaClient2 } = await import("@hardkas/kaspa-rpc");
+    const client = new JsonWrpcKaspaClient2({ rpcUrl, timeoutMs: 3e3 });
+    try {
+      const server = await client.getServerInfo();
+      const info = await client.getInfo();
+      const serverNetworkId = String(server.networkId || "");
+      const result = {
+        ready: true,
+        rpcUrl,
+        networkId: serverNetworkId === "unknown" ? "simnet" : server.networkId || info.networkId || "simnet",
+        serverVersion: server.serverVersion || info.serverVersion,
+        isSynced: server.isSynced ?? info.isSynced,
+        virtualDaaScore: info.virtualDaaScore?.toString()
+      };
+      await client.close();
+      return result;
+    } catch (error) {
+      await client.close().catch(() => {
+      });
+      return {
+        ready: false,
+        rpcUrl,
+        lastError: error?.message || String(error)
+      };
+    }
+  }
+  inspectDockerContainer(name) {
+    const image = "hardkas/stratum-bridge:v2.0.0-local-simnet-unsynced";
+    try {
+      const stdout = execFileSync(
+        "docker",
+        ["inspect", "--format", "{{.State.Status}}|{{.Config.Image}}|{{.Name}}", name],
+        {
+          encoding: "utf8",
+          stdio: "pipe"
+        }
+      );
+      const [status, detectedImage, rawName] = stdout.trim().split("|");
+      return {
+        exists: true,
+        running: status === "running",
+        status: status || "unknown",
+        image: detectedImage || image,
+        name: rawName?.replace(/^\//, "") || name
+      };
+    } catch {
+      return {
+        exists: false,
+        running: false,
+        status: "not-found",
+        image,
+        name
+      };
+    }
   }
 };
 
@@ -1097,6 +1286,7 @@ import {
   writeArtifact as writeArtifact2
 } from "@hardkas/artifacts";
 import { deterministicCompare as deterministicCompare2 } from "@hardkas/core";
+import { HardkasSchemas as HardkasSchemas3 } from "@hardkas/artifacts";
 function resolveReplayTargets(cwd, options) {
   if (options.path) {
     const fullPath = path.resolve(cwd, options.path);
@@ -1150,13 +1340,13 @@ function resolveFromDirectory(dir, source) {
       const raw = fs.readFileSync(path.join(dir, f), "utf-8");
       const data = JSON.parse(raw);
       if (!data || !data.schema) continue;
-      if (data.schema === "hardkas.txPlan") {
+      if (data.schema === HardkasSchemas3.TxPlan) {
         plans.push({
           file: f,
           planId: data.planId || "",
           createdAt: data.createdAt || ""
         });
-      } else if (data.schema === "hardkas.txReceipt") {
+      } else if (data.schema === HardkasSchemas3.TxReceipt) {
         receipts.push({
           file: f,
           sourcePlanId: data.sourcePlanId || data.lineage?.parentArtifactId || data.lineage?.rootArtifactId || "",
@@ -1207,7 +1397,7 @@ function findReceiptByPlanId(dir, planId) {
     try {
       const raw = fs.readFileSync(path.join(dir, f), "utf-8");
       const data = JSON.parse(raw);
-      if (data && data.schema === "hardkas.txReceipt" && (data.sourcePlanId && data.sourcePlanId === planId || data.lineage?.parentArtifactId && data.lineage.parentArtifactId === planId || data.lineage?.rootArtifactId && data.lineage.rootArtifactId === planId || data.txId && data.txId.includes(planId))) {
+      if (data && data.schema === HardkasSchemas3.TxReceipt && (data.sourcePlanId && data.sourcePlanId === planId || data.lineage?.parentArtifactId && data.lineage.parentArtifactId === planId || data.lineage?.rootArtifactId && data.lineage.rootArtifactId === planId || data.txId && data.txId.includes(planId))) {
         return path.join(dir, f);
       }
     } catch {
@@ -1227,7 +1417,10 @@ var HardkasReplay = class {
   async verify(targetOrOptions, options) {
     const throwOnInvalid = options?.throwOnInvalid !== false;
     if (typeof targetOrOptions === "object" && targetOrOptions !== null && targetOrOptions.contentHash) {
-      const verifyRes = await this.sdk.artifacts.verify(targetOrOptions, { throwOnInvalid, strict: true });
+      const verifyRes = await this.sdk.artifacts.verify(targetOrOptions, {
+        throwOnInvalid,
+        strict: true
+      });
       if (!verifyRes.valid && !throwOnInvalid) {
         return {
           passed: false,
@@ -1298,10 +1491,10 @@ var HardkasReplay = class {
           artifactCount++;
           if (isContaminated(json)) contaminationOk = false;
           const isCoreArtifact = [
-            "hardkas.txPlan",
-            "hardkas.signedTx",
-            "hardkas.txReceipt",
-            "hardkas.snapshot"
+            HardkasSchemas3.TxPlan,
+            HardkasSchemas3.SignedTx,
+            HardkasSchemas3.TxReceipt,
+            HardkasSchemas3.Snapshot
           ].includes(json.schema);
           if (isCoreArtifact) {
             const integrity = await verifyArtifactIntegrity(json);
@@ -1328,7 +1521,7 @@ var HardkasReplay = class {
           "utf-8"
         );
         const wfArtifact = JSON.parse(wfArtifactStr);
-        if (wfArtifact.schema !== "hardkas.workflow.v1") {
+        if (wfArtifact.schema !== HardkasSchemas3.WorkflowV1) {
           throw new Error(`Artifact ${opts.workflowId} is not a workflow artifact`);
         }
         const childArtifacts = wfArtifact.producedArtifacts || [];
@@ -1504,8 +1697,8 @@ var HardkasArtifactsManager = class {
   async write(artifact, options = {}) {
     const record = artifact;
     if (!record.hashVersion) {
-      const { CURRENT_HASH_VERSION: CURRENT_HASH_VERSION2 } = await import("@hardkas/artifacts");
-      record.hashVersion = CURRENT_HASH_VERSION2;
+      const { CURRENT_HASH_VERSION: CURRENT_HASH_VERSION3 } = await import("@hardkas/artifacts");
+      record.hashVersion = CURRENT_HASH_VERSION3;
     }
     const hash = record.contentHash || "unknown";
     if (record.planId) this.cache.set(record.planId, artifact);
@@ -1526,8 +1719,8 @@ var HardkasArtifactsManager = class {
     const shortSchema = schema.replace("hardkas.", "");
     const fileName = options.fileName || `${shortSchema}-${hash}.json`;
     const absolutePath = path3.join(outputDir, fileName);
-    const { writeArtifact: writeArtifact4 } = await import("@hardkas/artifacts");
-    await writeArtifact4(absolutePath, artifact);
+    const { writeArtifact: writeArtifact5 } = await import("@hardkas/artifacts");
+    await writeArtifact5(absolutePath, artifact);
     const {
       coreEvents: coreEvents2,
       createEventEnvelope,
@@ -1580,7 +1773,10 @@ var HardkasArtifactsManager = class {
     const rootRel = path3.relative(this.workspace.root, resolvedPath);
     const artifactsRel = path3.relative(this.workspace.artifactsDir, resolvedPath);
     if ((rootRel.startsWith("..") || path3.isAbsolute(rootRel)) && (artifactsRel.startsWith("..") || path3.isAbsolute(artifactsRel))) {
-      throw new HardkasError("PATH_TRAVERSAL", "Artifact path escapes workspace boundary");
+      throw new HardkasError(
+        "PATH_TRAVERSAL",
+        "Artifact path escapes workspace boundary"
+      );
     }
     if (!fs3.existsSync(filePath)) {
       filePath = path3.join(this.workspace.artifactsDir, `${id}.json`);
@@ -1618,7 +1814,9 @@ var HardkasArtifactsManager = class {
     }
     const artifact = await readArtifact(filePath);
     if (options?.expectedSchema && artifact.schema !== options.expectedSchema) {
-      throw new Error(`Artifact ${id} has schema '${artifact.schema}' but expected '${options.expectedSchema}'`);
+      throw new Error(
+        `Artifact ${id} has schema '${artifact.schema}' but expected '${options.expectedSchema}'`
+      );
     }
     return artifact;
   }
@@ -1641,7 +1839,9 @@ var HardkasArtifactsManager = class {
     for (const file of files) {
       if (file.endsWith(".json")) {
         try {
-          const artifact = await readArtifact(path3.join(this.workspace.artifactsDir, file));
+          const artifact = await readArtifact(
+            path3.join(this.workspace.artifactsDir, file)
+          );
           artifacts.push(artifact);
         } catch (e) {
         }
@@ -1662,14 +1862,24 @@ var HardkasArtifactsManager = class {
     if (typeof target === "string") {
       id = target;
       if (!id) {
-        if (throwOnInvalid) throw new Error("No artifact target provided for verification.");
-        return { valid: false, reason: "unknown", message: "No artifact target provided for verification." };
+        if (throwOnInvalid)
+          throw new Error("No artifact target provided for verification.");
+        return {
+          valid: false,
+          reason: "unknown",
+          message: "No artifact target provided for verification."
+        };
       }
       try {
         artifact = await this.read(id);
       } catch (e) {
         if (throwOnInvalid) throw e;
-        return { valid: false, reason: "missing_artifact", message: e.message, artifactId: id };
+        return {
+          valid: false,
+          reason: "missing_artifact",
+          message: e.message,
+          artifactId: id
+        };
       }
     } else {
       artifact = target;
@@ -1693,7 +1903,9 @@ var HardkasArtifactsManager = class {
     if (!result.ok) {
       const mappedReason = result.issues[0]?.code === "HASH_MISMATCH" ? "content_hash_mismatch" : result.issues[0]?.code === "MISSING_CONTENT_HASH" ? "missing_content_hash" : result.issues[0]?.code === "MISSING_SIGNATURE" ? "missing_signature" : result.issues[0]?.code === "REFERENCE_MISSING" ? "reference_missing" : result.issues[0]?.code === "REFERENCE_HASH_MISMATCH" ? "reference_hash_mismatch" : result.issues[0]?.code === "POLICY_VIOLATION" ? "policy_violation" : result.issues[0]?.code === "LEGACY_HASH_VERSION_UNSAFE" ? "legacy_hash_version_unsafe" : result.issues[0]?.code === "PARENT_MISSING" ? "parent_missing" : "schema_invalid";
       if (throwOnInvalid) {
-        throw new Error(`Artifact ${id} corrupted or invalid: ` + JSON.stringify(result.issues, null, 2));
+        throw new Error(
+          `Artifact ${id} corrupted or invalid: ` + JSON.stringify(result.issues, null, 2)
+        );
       }
       return {
         valid: false,
@@ -1723,7 +1935,9 @@ var HardkasArtifactsManager = class {
     const { migrateArtifactPayload, generateMigrationReceipt } = await import("@hardkas/artifacts");
     const result = migrateArtifactPayload(artifact, void 0, { strictPolicy: false });
     if (!result.migrated) {
-      throw new Error(`Artifact ${artifact.artifactId || artifact.contentHash} is already at the target version or cannot be migrated.`);
+      throw new Error(
+        `Artifact ${artifact.artifactId || artifact.contentHash} is already at the target version or cannot be migrated.`
+      );
     }
     const receipt = generateMigrationReceipt(artifact, result.artifact, migrationId);
     await this.write(result.artifact);
@@ -1735,6 +1949,7 @@ var HardkasArtifactsManager = class {
 // src/workflow.ts
 import { HARDKAS_VERSION as HARDKAS_VERSION2 } from "@hardkas/artifacts";
 import { HardkasError as HardkasError2, deterministicCompare as deterministicCompare3 } from "@hardkas/core";
+import { HardkasSchemas as HardkasSchemas4 } from "@hardkas/artifacts";
 var HardkasWorkflow = class {
   constructor(sdk) {
     this.sdk = sdk;
@@ -1744,9 +1959,9 @@ var HardkasWorkflow = class {
    * Executes a sequence of declarative steps and returns a definitive WorkflowArtifact.
    */
   async run(options) {
-    const { calculateContentHash: calculateContentHash2 } = await import("@hardkas/artifacts");
+    const { calculateContentHash: calculateContentHash7 } = await import("@hardkas/artifacts");
     const intentPayload = {
-      type: "hardkas.workflow.intent",
+      type: HardkasSchemas4.WorkflowIntent,
       schemaVersion: "v1",
       workflowSpec: options.steps,
       normalizedInputs: {},
@@ -1763,9 +1978,9 @@ var HardkasWorkflow = class {
         network: this.sdk.network
       },
       runtimeVersion: HARDKAS_VERSION2,
-      workspaceSchemaVersion: "hardkas.workflow.v1"
+      workspaceSchemaVersion: HardkasSchemas4.WorkflowV1
     };
-    const intentHash = calculateContentHash2(intentPayload);
+    const intentHash = calculateContentHash7(intentPayload);
     const workflowId = `wf_${intentHash.slice(0, 16)}`;
     const artifactSteps = [];
     const producedArtifacts = [];
@@ -1916,7 +2131,6 @@ var HardkasWorkflow = class {
         if (producedArtifactId) stepRecord.producedArtifactId = producedArtifactId;
         artifactSteps.push(stepRecord);
       } catch (e) {
-        console.error("DEBUG WORKFLOW ERROR:", e.stack);
         status = "failed";
         errorEnvelope = {
           code: e.code || "WORKFLOW_STEP_FAILED",
@@ -1936,7 +2150,7 @@ var HardkasWorkflow = class {
     }
     const executionMode = this.sdk.network === "simulated" ? "simulated" : "real";
     const artifact = {
-      schema: "hardkas.workflow.v1",
+      schema: HardkasSchemas4.WorkflowV1,
       version: "1.0.0-alpha",
       hardkasVersion: HARDKAS_VERSION2,
       networkId: this.sdk.network,
@@ -1966,7 +2180,7 @@ var HardkasWorkflow = class {
     if (errorEnvelope) {
       artifact.errorEnvelope = errorEnvelope;
     }
-    artifact.contentHash = calculateContentHash2(artifact, 1);
+    artifact.contentHash = calculateContentHash7(artifact, 1);
     if (!options.dryRun) {
       this.sdk.enforcePolicy("mutation", "Workflow Runtime saving artifact");
       await this.sdk.artifacts.write(artifact, {
@@ -1977,6 +2191,1750 @@ var HardkasWorkflow = class {
   }
 };
 
+// src/capabilities.ts
+import { CURRENT_HASH_VERSION as CURRENT_HASH_VERSION2, HARDKAS_VERSION as HARDKAS_VERSION3 } from "@hardkas/artifacts";
+var HardkasCapabilitiesApi = class {
+  async get() {
+    return createHardkasCapabilities();
+  }
+};
+function createHardkasCapabilities() {
+  return {
+    version: HARDKAS_VERSION3,
+    maturity: "hardened-alpha",
+    proofVersion: "repro-v0",
+    hashVersion: CURRENT_HASH_VERSION2,
+    capabilities: {
+      artifacts: true,
+      lineageVerification: true,
+      deterministicHashing: true,
+      atomicPersistence: true,
+      workspaceLocks: true,
+      corruptionDetection: true,
+      secretRedaction: true,
+      mainnetGuards: true,
+      localnetSimulation: true,
+      ghostdagSimulation: true,
+      dagConflictResolution: true,
+      massProfiler: true,
+      simulationScenarios: true,
+      queryStore: true,
+      replayVerification: true,
+      schemaMigrations: true,
+      dockerNode: true,
+      scriptRunner: true,
+      testingFramework: true,
+      l2Profiles: true,
+      l2BridgeAssumptions: true,
+      consensusValidation: false,
+      productionWallet: false,
+      silverScript: false,
+      covenants: false,
+      trustlessExit: false,
+      differentialDagValidation: false
+    },
+    trustBoundaries: {
+      replay: "local-workflow-only",
+      artifacts: "internal-integrity-only",
+      simulator: "research-experimental",
+      queryStore: "rebuildable-read-model",
+      l2Bridge: "pre-zk-assumptions"
+    }
+  };
+}
+
+// src/corpus.ts
+import fs4 from "fs";
+import path4 from "path";
+import { calculateContentHash as calculateContentHash2 } from "@hardkas/artifacts";
+import { HardkasSchemas as HardkasSchemas5 } from "@hardkas/artifacts";
+var EXPECTED_LIMITATION = "PARTIAL_VM_SIMULATION";
+var HardkasCorpus = class {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+  sdk;
+  async verify(targetPath) {
+    return verifyToccataCorpus(targetPath, this.sdk.cwd);
+  }
+};
+function verifyToccataCorpus(targetPath, workspaceRoot = process.cwd()) {
+  const corpusPath = path4.resolve(workspaceRoot, targetPath);
+  const issues = [];
+  const opTrueDir = path4.join(corpusPath, "op-true");
+  const failuresDir = path4.join(corpusPath, "failures");
+  const opManifestPath = path4.join(opTrueDir, "manifest.json");
+  const failureManifestPath = path4.join(failuresDir, "manifest.json");
+  const opManifest = readRequiredJson(opManifestPath, issues);
+  const failureManifest = readRequiredJson(failureManifestPath, issues);
+  if (opManifest) {
+    expectEqual(
+      opManifest.schema,
+      HardkasSchemas5.ToccataGoldenManifestV1,
+      issues,
+      "OP_TRUE_SCHEMA_INVALID",
+      opManifestPath
+    );
+    validateCommonClaims(opManifest, issues, opManifestPath);
+  }
+  if (failureManifest) {
+    expectEqual(
+      failureManifest.schema,
+      HardkasSchemas5.ToccataGoldenFailureManifestV1,
+      issues,
+      "FAILURE_SCHEMA_INVALID",
+      failureManifestPath
+    );
+    validateCommonClaims(failureManifest, issues, failureManifestPath);
+  }
+  let artifactsChecked = 0;
+  if (Array.isArray(opManifest?.files)) {
+    for (const file of opManifest.files) {
+      const filePath = path4.join(opTrueDir, file);
+      if (!fs4.existsSync(filePath)) {
+        issues.push({
+          code: "CORPUS_FILE_MISSING",
+          message: `Missing referenced OP_TRUE file ${file}.`,
+          file: filePath
+        });
+        continue;
+      }
+      if (file === "manifest.json" || file === "compare-report.json") continue;
+      const artifact = readRequiredJson(filePath, issues);
+      if (!artifact) continue;
+      artifactsChecked += 1;
+      verifyContentHash(artifact, issues, filePath);
+    }
+  }
+  const comparePath = path4.join(opTrueDir, "compare-report.json");
+  const compareReport = readRequiredJson(comparePath, issues);
+  if (compareReport) {
+    expectEqual(
+      compareReport.schema,
+      HardkasSchemas5.ToccataGoldenCompareV1,
+      issues,
+      "COMPARE_SCHEMA_INVALID",
+      comparePath
+    );
+    expectEqual(
+      compareReport.compareMode,
+      "artifact-coherence",
+      issues,
+      "COMPARE_MODE_INVALID",
+      comparePath
+    );
+    expectEqual(
+      compareReport.status,
+      "SILVERSCRIPT_SIMULATION_MATCH",
+      issues,
+      "COMPARE_STATUS_INVALID",
+      comparePath
+    );
+    if (!Array.isArray(compareReport.drift) || compareReport.drift.length !== 0) {
+      issues.push({
+        code: "COMPARE_DRIFT_NOT_EMPTY",
+        message: "artifact-coherence compare report must not contain drift.",
+        file: comparePath
+      });
+    }
+    expectKnownLimitation(compareReport, issues, comparePath);
+    const strictNotes = compareReport.semanticNotes || [];
+    if (!Array.isArray(strictNotes) || strictNotes.length === 0) {
+      issues.push({
+        code: "STRICT_DRIFT_NOT_DECLARED",
+        message: "Strict/runtime lineage differences must be declared as semantic notes.",
+        file: comparePath
+      });
+    }
+  }
+  let failureFixtures = 0;
+  if (Array.isArray(failureManifest?.cases)) {
+    for (const entry of failureManifest.cases) {
+      failureFixtures += 1;
+      const filePath = path4.join(failuresDir, entry.file);
+      const fixture = readRequiredJson(filePath, issues);
+      if (!fixture) continue;
+      expectEqual(
+        fixture.schema,
+        HardkasSchemas5.ToccataGoldenFailureCaseV1,
+        issues,
+        "FAILURE_CASE_SCHEMA_INVALID",
+        filePath
+      );
+      if (!entry.expectedSimulatorError) {
+        issues.push({
+          code: "EXPECTED_SIMULATOR_ERROR_MISSING",
+          message: `Failure case ${entry.caseId} must declare expectedSimulatorError.`,
+          file: failureManifestPath
+        });
+      }
+      const expectedError = fixture.expectedSimulator?.error || fixture.expectedSimulator?.secondAttempt?.error;
+      expectEqual(
+        expectedError,
+        entry.expectedSimulatorError,
+        issues,
+        "EXPECTED_SIMULATOR_ERROR_MISMATCH",
+        filePath
+      );
+      validateFailureReferences(fixture, issues, filePath, corpusPath);
+      if (entry.caseId === "mainnet-guard") {
+        validateMainnetGuard(entry, fixture, issues, filePath);
+      }
+    }
+  }
+  const ok = issues.length === 0;
+  return {
+    ok,
+    schema: HardkasSchemas5.ToccataCorpusV1,
+    path: path4.relative(workspaceRoot, corpusPath).replace(/\\/g, "/"),
+    summary: {
+      happyPathFixtures: opManifest ? 1 : 0,
+      failureFixtures,
+      artifactsChecked,
+      contentHashes: issues.some((issue) => issue.code.includes("HASH")) ? "FAIL" : "PASS",
+      compareMode: compareReport?.compareMode ?? "unknown",
+      simulationStatus: compareReport?.status ?? "unknown",
+      knownLimitations: collectKnownLimitations(
+        opManifest,
+        failureManifest,
+        compareReport
+      )
+    },
+    claims: {
+      artifactCoherence: ok ? "READY_MATCH" : "INVALID",
+      runtimeOutcome: ok ? "PARTIAL" : "INVALID",
+      vmConsensusEquivalence: ok ? "NOT_CLAIMED" : "INVALID",
+      mainnet: ok ? "BLOCKED_BY_POLICY" : "INVALID"
+    },
+    issues
+  };
+}
+function readRequiredJson(filePath, issues) {
+  if (!fs4.existsSync(filePath)) {
+    issues.push({
+      code: "FILE_MISSING",
+      message: `Missing required file ${filePath}.`,
+      file: filePath
+    });
+    return void 0;
+  }
+  try {
+    return JSON.parse(fs4.readFileSync(filePath, "utf8"));
+  } catch (error) {
+    issues.push({
+      code: "JSON_INVALID",
+      message: error?.message || `Invalid JSON in ${filePath}.`,
+      file: filePath
+    });
+    return void 0;
+  }
+}
+function validateCommonClaims(manifest, issues, filePath) {
+  expectEqual(manifest.network, "simnet", issues, "NETWORK_INVALID", filePath);
+  expectEqual(manifest.profile, "toccata-v2", issues, "PROFILE_INVALID", filePath);
+  const claim = manifest.simulationClaim || manifest.simulationLevel;
+  expectEqual(
+    claim?.artifactCoherence,
+    "READY",
+    issues,
+    "ARTIFACT_COHERENCE_CLAIM_INVALID",
+    filePath
+  );
+  expectEqual(
+    claim?.runtimeOutcome,
+    "PARTIAL",
+    issues,
+    "RUNTIME_OUTCOME_CLAIM_INVALID",
+    filePath
+  );
+  expectEqual(
+    claim?.vmConsensusEquivalence,
+    "NOT_CLAIMED",
+    issues,
+    "VM_CONSENSUS_CLAIM_INVALID",
+    filePath
+  );
+  expectKnownLimitation(manifest, issues, filePath);
+}
+function expectKnownLimitation(value, issues, filePath) {
+  const limitations = value.expectedKnownLimitations || [value.expectedCompareStatus].filter(Boolean);
+  if (!Array.isArray(limitations) || !limitations.includes(EXPECTED_LIMITATION)) {
+    issues.push({
+      code: "PARTIAL_VM_SIMULATION_NOT_DECLARED",
+      message: "Expected known limitations must include PARTIAL_VM_SIMULATION.",
+      file: filePath
+    });
+  }
+}
+function verifyContentHash(artifact, issues, filePath) {
+  if (typeof artifact.contentHash !== "string") {
+    issues.push({
+      code: "CONTENT_HASH_MISSING",
+      message: "Artifact is missing contentHash.",
+      file: filePath
+    });
+    return;
+  }
+  const actual = calculateContentHash2(artifact, artifact.hashVersion ?? 4);
+  if (actual !== artifact.contentHash) {
+    issues.push({
+      code: "CONTENT_HASH_MISMATCH",
+      message: `Expected ${artifact.contentHash}, got ${actual}.`,
+      file: filePath
+    });
+  }
+}
+function validateFailureReferences(fixture, issues, filePath, corpusPath) {
+  for (const ref of collectFixtureRefs(fixture)) {
+    const refPath = ref.split("#")[0];
+    if (!refPath) {
+      issues.push({
+        code: "FAILURE_REFERENCE_INVALID",
+        message: `Referenced fixture path is empty: ${ref}.`,
+        file: filePath
+      });
+      continue;
+    }
+    const resolved = path4.resolve(path4.dirname(filePath), refPath);
+    if (!resolved.startsWith(corpusPath) || !fs4.existsSync(resolved)) {
+      issues.push({
+        code: "FAILURE_REFERENCE_INVALID",
+        message: `Referenced fixture file does not exist or escapes corpus: ${ref}.`,
+        file: filePath
+      });
+    }
+  }
+}
+function collectFixtureRefs(fixture) {
+  const refs = [fixture.baseArtifact, fixture.requiredState].filter(Boolean);
+  const setupRefs = fixture.stateSetup ? [fixture.stateSetup.deployPlan, fixture.stateSetup.deploySimulationReceipt] : [];
+  const normalizationRefs = fixture.stateSetup?.simulatorSpendInputNormalization ?? [];
+  for (const entry of normalizationRefs) {
+    if (entry.valueFrom) refs.push(entry.valueFrom);
+  }
+  return [...refs, ...setupRefs].filter(Boolean);
+}
+function validateMainnetGuard(entry, fixture, issues, filePath) {
+  const status = fixture.expectedReal?.status;
+  const error = fixture.expectedReal?.error || entry.expectedRealError;
+  if (status !== "BLOCKED_BY_POLICY" || error !== "SILVERSCRIPT_MAINNET_NOT_ENABLED") {
+    issues.push({
+      code: "MAINNET_GUARD_CLAIM_INVALID",
+      message: "mainnet-guard must declare BLOCKED_BY_POLICY / SILVERSCRIPT_MAINNET_NOT_ENABLED.",
+      file: filePath
+    });
+  }
+}
+function collectKnownLimitations(...values) {
+  return Array.from(
+    new Set(
+      values.flatMap((value) => {
+        if (!value) return [];
+        if (Array.isArray(value.expectedKnownLimitations))
+          return value.expectedKnownLimitations;
+        return [value.expectedCompareStatus].filter(Boolean);
+      })
+    )
+  ).sort();
+}
+function expectEqual(actual, expected, issues, code, file) {
+  if (actual !== expected) {
+    issues.push({
+      code,
+      message: `Expected ${String(expected)}, got ${String(actual)}.`,
+      file
+    });
+  }
+}
+
+// src/silver.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { createHash } from "crypto";
+import fs5 from "fs";
+import path5 from "path";
+import { calculateContentHash as calculateContentHash3, HARDKAS_VERSION as HARDKAS_VERSION4, writeArtifact as writeArtifact3 } from "@hardkas/artifacts";
+import {
+  createKaspaP2shBlake2bLock,
+  createPushOnlySignatureScript,
+  parseKasToSompi as parseKasToSompi2
+} from "@hardkas/core";
+import {
+  createSilverSimulationState,
+  simulateSilverDeploy,
+  simulateSilverSpend
+} from "@hardkas/simulator";
+import { HardkasSchemas as HardkasSchemas6 } from "@hardkas/artifacts";
+var HardkasSilver = class {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+  sdk;
+  simulate = {
+    deploy: (deployPlan, options = {}) => this.simulateDeploy(deployPlan, options),
+    spend: (spendPlan, state = this.loadSimulationState(), options = {}) => this.simulateSpend(spendPlan, state, options),
+    compare: (options) => this.compare(options)
+  };
+  async compile(options) {
+    const network = options.network || "simnet";
+    assertSimnet(network);
+    const filePath = path5.resolve(this.sdk.cwd, options.file);
+    if (!fs5.existsSync(filePath)) {
+      throw new Error(`SILVERSCRIPT_SOURCE_NOT_FOUND: ${filePath}`);
+    }
+    const compilerPath = resolveCompilerPath(this.sdk.cwd, options.compilerPath);
+    if (!isExecutableAvailable(compilerPath)) {
+      throw new Error(
+        "SILVERSCRIPT_COMPILER_UNAVAILABLE: pass compilerPath, set HARDKAS_SILVERC_PATH, or install .hardkas/bin/silverc."
+      );
+    }
+    const sourceContent = fs5.readFileSync(filePath, "utf8");
+    const compilerOutput = execFileSync2(compilerPath, [filePath, "-c"], {
+      encoding: "utf8",
+      stdio: "pipe"
+    });
+    const normalized = normalizeSilverCompilerOutput(compilerOutput);
+    if (!normalized.scriptHex) {
+      throw new Error(
+        "SILVERSCRIPT_COMPILER_OUTPUT_INVALID: compiled script hex not found."
+      );
+    }
+    const artifact = {
+      schema: HardkasSchemas6.SilverCompile,
+      hardkasVersion: HARDKAS_VERSION4,
+      version: "1.0.0-alpha",
+      hashVersion: 4,
+      networkId: network,
+      mode: "simulated",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      sourcePath: filePath,
+      sourceHash: createHash("sha256").update(sourceContent).digest("hex"),
+      compilerName: "silverc",
+      compilerVersion: "unknown",
+      compilerCommand: `${compilerPath} "${filePath}" -c`,
+      compiledScriptHex: normalized.scriptHex,
+      compiledScriptHash: normalized.scriptHash || createHash("sha256").update(Buffer.from(normalized.scriptHex, "hex")).digest("hex"),
+      abi: normalized.abi,
+      network,
+      assumptions: ["toccata-v2", "mainnet-disabled"]
+    };
+    finalizeArtifact(artifact, "silver");
+    return this.writeSdkArtifact(artifact, options);
+  }
+  async deployPlan(options) {
+    const network = options.network || "simnet";
+    assertSimnet(network);
+    const compileArtifact = await this.resolveArtifact(
+      options.artifact,
+      HardkasSchemas6.SilverCompile
+    );
+    const amountSompi = parseKasToSompi2(String(options.amount ?? "1")).toString();
+    const fromAccount = await this.sdk.accounts.resolve(options.from);
+    const lock = createKaspaP2shBlake2bLock(compileArtifact.compiledScriptHex);
+    const artifact = {
+      schema: HardkasSchemas6.SilverDeployPlan,
+      hardkasVersion: HARDKAS_VERSION4,
+      version: "1.0.0-alpha",
+      hashVersion: 4,
+      networkId: network,
+      mode: "simulated",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      compileArtifactHash: compileArtifact.contentHash,
+      compiledScriptHash: compileArtifact.compiledScriptHash,
+      redeemScriptHex: lock.redeemScriptHex,
+      redeemScriptHash: lock.redeemScriptHash,
+      lockingScriptHex: lock.lockingScriptHex,
+      scriptPublicKeyVersion: lock.scriptPublicKeyVersion,
+      amountSompi,
+      deployerAddress: fromAccount.address
+    };
+    finalizeArtifact(artifact, "silverdeployplan");
+    return this.writeSdkArtifact(artifact, options);
+  }
+  async deploy(options) {
+    if (options.mode === "real") {
+      throw new Error(
+        "SDK_SILVER_REAL_LIFECYCLE_UNSUPPORTED: use `hardkas silver deploy` for Docker/RPC execution in 0.9.1-alpha."
+      );
+    }
+    return this.simulateDeploy(options.artifact, options);
+  }
+  async spendPlan(options) {
+    const deployArtifact = await this.resolveArtifact(
+      options.receipt,
+      HardkasSchemas6.SilverDeploy
+    );
+    assertSimnet(deployArtifact.networkId);
+    const args = options.args ?? readArgsFile(this.sdk.cwd, options.argsPath);
+    const lock = createKaspaP2shBlake2bLock(deployArtifact.redeemScriptHex);
+    if (lock.lockingScriptHex !== deployArtifact.lockingScriptHex) {
+      throw new Error("SILVERSCRIPT_LOCKING_SCRIPT_MISMATCH");
+    }
+    if (lock.redeemScriptHash !== deployArtifact.redeemScriptHash) {
+      throw new Error("SILVERSCRIPT_REDEEM_HASH_MISMATCH");
+    }
+    const signatureScriptHex = createPushOnlySignatureScript(
+      args.map((arg) => arg.value),
+      lock.redeemScriptHex
+    );
+    const feeSompi = 200000n;
+    const sendAmount = BigInt(deployArtifact.amountSompi) - feeSompi;
+    if (sendAmount <= 0n) {
+      throw new Error("SILVERSCRIPT_AMOUNT_TOO_SMALL");
+    }
+    const artifact = {
+      schema: HardkasSchemas6.SilverSpendPlan,
+      hardkasVersion: HARDKAS_VERSION4,
+      version: "1.0.0-alpha",
+      hashVersion: 4,
+      networkId: deployArtifact.networkId,
+      mode: "simulated",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      deployArtifactHash: deployArtifact.contentHash,
+      compileArtifactHash: deployArtifact.compileArtifactHash,
+      redeemScriptHash: lock.redeemScriptHash,
+      lockingScriptHex: lock.lockingScriptHex,
+      contractUtxoRef: {
+        transactionId: deployArtifact.deployTxId,
+        index: deployArtifact.outputIndex
+      },
+      args,
+      argsHash: calculateArgsHash(args),
+      signatureScriptHex,
+      expectedOutputs: [
+        {
+          address: options.to,
+          amountSompi: sendAmount.toString()
+        }
+      ]
+    };
+    finalizeArtifact(artifact, "silverspendplan");
+    return this.writeSdkArtifact(artifact, options);
+  }
+  async spend(options) {
+    if (options.mode === "real") {
+      throw new Error(
+        "SDK_SILVER_REAL_LIFECYCLE_UNSUPPORTED: use `hardkas silver spend` for Docker/RPC execution in 0.9.1-alpha."
+      );
+    }
+    return this.simulateSpend(
+      options.artifact,
+      options.state ?? this.loadSimulationState(),
+      options
+    );
+  }
+  async simulateDeploy(deployPlan, options = {}) {
+    const artifact = await this.resolveArtifact(deployPlan, HardkasSchemas6.SilverDeployPlan);
+    const result = simulateSilverDeploy(artifact);
+    this.saveSimulationState(mergeState(this.loadSimulationState(), result.state));
+    return this.writeSdkArtifact(result.receipt, options);
+  }
+  async simulateSpend(spendPlan, state = this.loadSimulationState(), options = {}) {
+    const artifact = await this.resolveArtifact(spendPlan, HardkasSchemas6.SilverSpendPlan);
+    const result = simulateSilverSpend(artifact, state);
+    this.saveSimulationState(result.state);
+    return this.writeSdkArtifact(result.receipt, options);
+  }
+  async compare(options) {
+    const simulated = await this.resolveArtifact(options.simulated);
+    const docker = await this.resolveArtifact(options.docker);
+    const mode = normalizeCompareMode(options.mode || "artifact-coherence");
+    const { drift, notes } = compareSilverReceipts(simulated, docker, mode);
+    return {
+      status: drift.length === 0 ? "SILVERSCRIPT_SIMULATION_MATCH" : "SILVERSCRIPT_SIMULATION_DRIFT",
+      mode,
+      drift,
+      notes,
+      expectedKnownLimitations: ["PARTIAL_VM_SIMULATION"]
+    };
+  }
+  async resolveArtifact(target, expectedSchema) {
+    const artifact = typeof target === "string" ? await this.sdk.artifacts.read(target) : target;
+    if (expectedSchema && artifact.schema !== expectedSchema) {
+      throw new Error(
+        `SILVERSCRIPT_SCHEMA_INVALID: expected ${expectedSchema}, got ${artifact.schema}.`
+      );
+    }
+    return artifact;
+  }
+  async writeSdkArtifact(artifact, options) {
+    if (options.write === false) return { artifact };
+    const artifactPath = options.outputPath ? path5.resolve(this.sdk.cwd, options.outputPath) : path5.join(this.sdk.cwd, `${artifact.artifactId}.json`);
+    await writeArtifact3(artifactPath, artifact);
+    this.sdk.artifacts.cacheArtifact(artifact);
+    return { artifact, artifactPath };
+  }
+  simulationStatePath() {
+    return path5.join(this.sdk.workspace.hardkasDir, "silver-simulator", "state.json");
+  }
+  loadSimulationState() {
+    const statePath = this.simulationStatePath();
+    if (!fs5.existsSync(statePath)) return createSilverSimulationState();
+    return JSON.parse(fs5.readFileSync(statePath, "utf8"));
+  }
+  saveSimulationState(state) {
+    const statePath = this.simulationStatePath();
+    fs5.mkdirSync(path5.dirname(statePath), { recursive: true });
+    fs5.writeFileSync(statePath, `${JSON.stringify(state, null, 2)}
+`, "utf8");
+  }
+};
+function assertSimnet(network) {
+  if (network !== "simnet") {
+    throw new Error(
+      "SILVERSCRIPT_MAINNET_NOT_ENABLED: Only simnet is supported for SilverScript lifecycle."
+    );
+  }
+}
+function resolveCompilerPath(cwd, explicit) {
+  return explicit || process.env.HARDKAS_SILVERC_PATH || path5.join(
+    cwd,
+    ".hardkas",
+    "bin",
+    process.platform === "win32" ? "silverc.exe" : "silverc"
+  );
+}
+function isExecutableAvailable(command) {
+  try {
+    execFileSync2(command, ["--help"], { stdio: "ignore" });
+    return true;
+  } catch {
+    return fs5.existsSync(command);
+  }
+}
+function normalizeSilverCompilerOutput(rawOutput) {
+  const normalized = {};
+  const hexMatch = rawOutput.match(/Compiled script:\s*([a-fA-F0-9]+)/i);
+  if (hexMatch?.[1]) normalized.scriptHex = hexMatch[1];
+  const hashMatch = rawOutput.match(/Script Hash:\s*([a-fA-F0-9]+)/i);
+  if (hashMatch?.[1]) normalized.scriptHash = hashMatch[1];
+  try {
+    const parsed = JSON.parse(rawOutput);
+    if (Array.isArray(parsed.script)) {
+      normalized.scriptHex = Buffer.from(parsed.script).toString("hex");
+    } else if (typeof parsed.scriptHex === "string") {
+      normalized.scriptHex = parsed.scriptHex;
+    }
+    if (typeof parsed.scriptHash === "string") normalized.scriptHash = parsed.scriptHash;
+    if (parsed.abi !== void 0) normalized.abi = parsed.abi;
+  } catch {
+  }
+  return normalized;
+}
+function readArgsFile(cwd, argsPath) {
+  if (!argsPath) return [];
+  const parsed = JSON.parse(fs5.readFileSync(path5.resolve(cwd, argsPath), "utf8"));
+  const args = parsed.args ?? parsed;
+  if (!Array.isArray(args))
+    throw new Error("SILVERSCRIPT_SPEND_PLAN_INVALID: args must be an array.");
+  return args.map((arg) => {
+    if (arg.type !== "hex" || typeof arg.value !== "string") {
+      throw new Error(
+        "SILVERSCRIPT_SPEND_PLAN_INVALID: args must be { type: 'hex', value }."
+      );
+    }
+    return { type: "hex", value: arg.value };
+  });
+}
+function calculateArgsHash(args) {
+  return createHash("sha256").update(JSON.stringify(args)).digest("hex");
+}
+function finalizeArtifact(artifact, prefix) {
+  artifact.contentHash = calculateContentHash3(artifact);
+  artifact.artifactId = `${prefix}-${artifact.contentHash.substring(0, 16)}`;
+}
+function mergeState(existing, next) {
+  return {
+    ...next,
+    deployReceipts: {
+      ...existing.deployReceipts,
+      ...next.deployReceipts
+    },
+    utxos: {
+      ...existing.utxos,
+      ...next.utxos
+    },
+    spentOutpoints: Array.from(
+      /* @__PURE__ */ new Set([...existing.spentOutpoints, ...next.spentOutpoints])
+    ).sort()
+  };
+}
+function normalizeCompareMode(mode) {
+  if (mode === "artifact-coherence" || mode === "runtime-outcome" || mode === "strict")
+    return mode;
+  throw new Error(
+    "SILVERSCRIPT_COMPARE_MODE_INVALID: Expected artifact-coherence, runtime-outcome, or strict."
+  );
+}
+function stableJson(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+  const record = value;
+  return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${stableJson(record[key])}`).join(",")}}`;
+}
+function valuesMatch(field, simulated, docker) {
+  if (field === "status") {
+    return simulated === docker || simulated === "SIMULATED_ACCEPTED" && (docker === "accepted" || docker === "submitted");
+  }
+  return stableJson(simulated) === stableJson(docker);
+}
+function compareSilverReceipts(simulated, docker, mode) {
+  const drift = [];
+  const notes = [];
+  const fields = [
+    "redeemScriptHash",
+    "lockingScriptHex",
+    "signatureScriptHex",
+    "expectedOutputs",
+    "status"
+  ];
+  if (mode === "runtime-outcome" || mode === "strict")
+    fields.push("networkId", "spentOutpoint");
+  if (mode === "strict") fields.push("lineage", "txId", "simulatedSpendTxId");
+  for (const field of fields) {
+    const entry = compareField(field, simulated[field], docker[field]);
+    if (entry.classification === "MATCH") continue;
+    const nonConsensusRuntimeIds = mode === "runtime-outcome" && (field === "spentOutpoint" || field === "txId" || field === "simulatedSpendTxId");
+    if (nonConsensusRuntimeIds) {
+      notes.push({
+        ...entry,
+        classification: "SEMANTICALLY_DERIVED",
+        reason: "synthetic simulator runtime identifier differs from Docker-observed runtime identifier"
+      });
+      continue;
+    }
+    drift.push(entry);
+  }
+  if (mode !== "strict") {
+    const lineageReport = compareLineageSemantics(simulated, docker, mode);
+    drift.push(...lineageReport.drift);
+    notes.push(...lineageReport.notes);
+  }
+  return { drift, notes };
+}
+function compareField(field, simulatedValue, dockerValue) {
+  if (simulatedValue === void 0) {
+    return {
+      field,
+      reason: "missing in simulated receipt",
+      classification: "MISSING_IN_SIM"
+    };
+  }
+  if (dockerValue === void 0) {
+    return {
+      field,
+      reason: "missing in docker receipt",
+      classification: "MISSING_IN_REAL"
+    };
+  }
+  if (valuesMatch(field, simulatedValue, dockerValue)) {
+    return { field, reason: "match", classification: "MATCH" };
+  }
+  return { field, reason: "semantic mismatch", classification: "SEMANTIC_MISMATCH" };
+}
+function compareLineageSemantics(simulated, docker, mode) {
+  const drift = [];
+  const notes = [];
+  if (!simulated.lineage) {
+    drift.push({
+      field: "lineage",
+      reason: "missing in simulated receipt",
+      classification: "MISSING_IN_SIM"
+    });
+    return { drift, notes };
+  }
+  if (!docker.lineage) {
+    drift.push({
+      field: "lineage",
+      reason: "missing in docker receipt",
+      classification: "MISSING_IN_REAL"
+    });
+    return { drift, notes };
+  }
+  for (const check of [
+    [
+      "lineage.redeemScriptHash",
+      simulated.redeemScriptHash,
+      docker.redeemScriptHash,
+      "redeem script hash anchors artifact coherence"
+    ],
+    [
+      "lineage.lockingScriptHex",
+      simulated.lockingScriptHex,
+      docker.lockingScriptHex,
+      "locking script anchors artifact coherence"
+    ],
+    [
+      "lineage.signatureScriptHex",
+      simulated.signatureScriptHex,
+      docker.signatureScriptHex,
+      "unlock script anchors artifact coherence"
+    ],
+    [
+      "lineage.expectedOutputs",
+      simulated.expectedOutputs,
+      docker.expectedOutputs,
+      "expected outputs anchor artifact coherence"
+    ],
+    ["lineage.network", simulated.networkId, docker.networkId, "network must match"]
+  ]) {
+    const entry = compareField(check[0], check[1], check[2]);
+    if (entry.classification !== "MATCH") drift.push({ ...entry, reason: check[3] });
+  }
+  notes.push({
+    field: "lineage.blob",
+    reason: mode === "artifact-coherence" ? "raw lineage IDs are domain-specific: simulator lineage is synthetic, Docker lineage is receipt artifact lineage" : "raw lineage IDs are compared by semantic anchors; VM/consensus lineage equivalence is not claimed",
+    classification: "SEMANTICALLY_DERIVED"
+  });
+  if (simulated.simulatedSpendTxId || docker.txId) {
+    notes.push({
+      field: "lineage.runtime.txid",
+      reason: "simulatedSpendTxId and Docker txId are intentionally different runtime identifiers",
+      classification: "IGNORED_NON_CONSENSUS"
+    });
+  }
+  return { drift, notes };
+}
+
+// src/zk.ts
+import fs6 from "fs";
+import path6 from "path";
+import { calculateContentHash as calculateContentHash4 } from "@hardkas/artifacts";
+import { HardkasSchemas as HardkasSchemas7 } from "@hardkas/artifacts";
+var ZK_KNOWN_LIMITATIONS = [
+  "ZK_ONCHAIN_VERIFICATION_NOT_CLAIMED",
+  "PARTIAL_VM_SIMULATION"
+];
+var HardkasZk = class {
+  constructor(sdk) {
+    this.sdk = sdk;
+    this.proof = {
+      inspect: (targetPath) => inspectZkProof(targetPath, this.sdk.cwd),
+      verifyLocal: (targetPath) => verifyZkProofLocal(targetPath, this.sdk.cwd)
+    };
+    this.corpus = {
+      verify: (targetPath) => verifyZkCorpus(targetPath, this.sdk.cwd)
+    };
+  }
+  sdk;
+  proof;
+  corpus;
+  async capabilities() {
+    return createZkCapabilities();
+  }
+};
+function createZkCapabilities() {
+  return {
+    schema: HardkasSchemas7.ZkCapabilitiesV1,
+    experimental: true,
+    proofSystems: {
+      groth16: {
+        inspect: true,
+        verifyLocal: "FIXTURE_COHERENCE_ONLY",
+        proofGeneration: "NOT_CLAIMED"
+      },
+      risc0: {
+        inspect: true,
+        verifyLocal: "RISC0_LOCAL_VERIFICATION_NOT_IMPLEMENTED",
+        proofGeneration: "NOT_CLAIMED"
+      }
+    },
+    claims: zkClaims(),
+    errors: [
+      "SDK_ZK_ONCHAIN_VERIFICATION_UNSUPPORTED",
+      "ZK_ONCHAIN_VERIFICATION_NOT_CLAIMED",
+      "ZK_VERIFIER_UNSUPPORTED",
+      "ZK_VERIFIER_UNAVAILABLE",
+      "ZK_CORPUS_MANIFEST_INVALID",
+      "ZK_CORPUS_HASH_MISMATCH",
+      "RISC0_VERIFIER_UNAVAILABLE",
+      "RISC0_LOCAL_VERIFICATION_NOT_IMPLEMENTED"
+    ]
+  };
+}
+async function inspectZkProof(targetPath, workspaceRoot = process.cwd()) {
+  const resolved = path6.resolve(workspaceRoot, targetPath);
+  const issues = [];
+  const manifestPath = resolveManifestPath(resolved, issues);
+  const manifest = manifestPath ? readJson(manifestPath, issues) : void 0;
+  const dir = manifestPath ? path6.dirname(manifestPath) : path6.dirname(resolved);
+  const proofSystem = detectProofSystem(manifest, resolved);
+  const fixtureFiles = collectFixtureFiles(manifest);
+  const files = fixtureFiles.map((entry) => entry.file);
+  const contentHashes = {};
+  for (const { key, file } of fixtureFiles) {
+    const filePath = path6.join(dir, file);
+    const value = readJson(filePath, issues);
+    if (!value) continue;
+    const actual = calculateContentHash4(value);
+    contentHashes[file] = actual;
+    const expected = manifest?.contentHashes?.[key];
+    if (typeof expected === "string" && expected !== actual) {
+      issues.push({
+        code: "ZK_CORPUS_HASH_MISMATCH",
+        message: `Expected ${expected}, got ${actual}.`,
+        file: filePath
+      });
+    }
+  }
+  const ok = issues.length === 0 && proofSystem !== "unknown";
+  if (proofSystem === "unknown") {
+    issues.push({
+      code: "ZK_VERIFIER_UNSUPPORTED",
+      message: "Could not determine proof system from artifact or manifest.",
+      file: resolved
+    });
+  }
+  return {
+    ok,
+    schema: HardkasSchemas7.ZkProofInspectV1,
+    path: path6.relative(workspaceRoot, resolved).replace(/\\/g, "/"),
+    proofSystem,
+    status: ok ? "ZK_PROOF_INSPECTED" : "ZK_PROOF_INSPECT_FAILED",
+    experimental: true,
+    summary: {
+      files,
+      contentHashes,
+      verifierAdapter: manifest?.verifierAdapter,
+      expectedStatus: manifest?.expectedStatus
+    },
+    claims: zkClaims(),
+    issues
+  };
+}
+async function verifyZkProofLocal(targetPath, workspaceRoot = process.cwd()) {
+  const resolved = path6.resolve(workspaceRoot, targetPath);
+  const issues = [];
+  const manifestPath = resolveManifestPath(resolved, issues);
+  const manifest = manifestPath ? readJson(manifestPath, issues) : void 0;
+  const dir = manifestPath ? path6.dirname(manifestPath) : path6.dirname(resolved);
+  const proofSystem = detectProofSystem(manifest, resolved);
+  if (proofSystem === "risc0") {
+    return {
+      ok: false,
+      schema: HardkasSchemas7.ZkProofVerificationV1,
+      path: path6.relative(workspaceRoot, resolved).replace(/\\/g, "/"),
+      proofSystem,
+      status: "RISC0_LOCAL_VERIFICATION_NOT_IMPLEMENTED",
+      experimental: true,
+      summary: {
+        verifierAdapter: manifest?.verifierAdapter ?? "risc0-helper",
+        contentHashes: "PASS",
+        localVerification: "NOT_IMPLEMENTED"
+      },
+      claims: zkClaims(),
+      issues: [
+        {
+          code: "RISC0_VERIFIER_UNAVAILABLE",
+          message: "RISC0 local receipt verification helper is not bundled in 0.9.1-alpha."
+        },
+        {
+          code: "RISC0_LOCAL_VERIFICATION_NOT_IMPLEMENTED",
+          message: "RISC0 is inspect-only in this experimental lab scaffold."
+        }
+      ]
+    };
+  }
+  if (proofSystem !== "groth16") {
+    return unsupportedVerification(
+      resolved,
+      workspaceRoot,
+      proofSystem,
+      issues,
+      manifest?.verifierAdapter
+    );
+  }
+  verifyGroth16Fixture(dir, manifest, issues);
+  const ok = issues.length === 0;
+  return {
+    ok,
+    schema: HardkasSchemas7.ZkProofVerificationV1,
+    path: path6.relative(workspaceRoot, resolved).replace(/\\/g, "/"),
+    proofSystem,
+    status: ok ? "ZK_FIXTURE_COHERENCE_PASS" : "ZK_FIXTURE_COHERENCE_FAIL",
+    experimental: true,
+    summary: {
+      verifierAdapter: manifest?.verifierAdapter ?? "hardkas-groth16-fixture-coherence-v1",
+      contentHashes: issues.some((issue) => issue.code.includes("HASH")) ? "FAIL" : "PASS",
+      localVerification: ok ? "PASS" : "FAIL"
+    },
+    claims: zkClaims(),
+    issues
+  };
+}
+async function verifyZkCorpus(targetPath, workspaceRoot = process.cwd()) {
+  const corpusPath = path6.resolve(workspaceRoot, targetPath);
+  const issues = [];
+  const manifestPath = path6.join(corpusPath, "manifest.json");
+  const manifest = readJson(manifestPath, issues);
+  if (manifest) {
+    expectEqual2(
+      manifest.schema,
+      HardkasSchemas7.ZkCorpusV1,
+      issues,
+      "ZK_CORPUS_MANIFEST_INVALID",
+      manifestPath
+    );
+    expectEqual2(
+      manifest.network,
+      "simnet",
+      issues,
+      "ZK_NETWORK_UNSUPPORTED",
+      manifestPath
+    );
+    expectEqual2(
+      manifest.profile,
+      "toccata-v2",
+      issues,
+      "ZK_PROFILE_UNSUPPORTED",
+      manifestPath
+    );
+    expectEqual2(
+      manifest.claims?.zkOnchainVerification,
+      "NOT_CLAIMED",
+      issues,
+      "ZK_ONCHAIN_VERIFICATION_NOT_CLAIMED",
+      manifestPath
+    );
+    expectEqual2(
+      manifest.claims?.vmConsensusEquivalence,
+      "NOT_CLAIMED",
+      issues,
+      "ZK_VM_CONSENSUS_CLAIM_INVALID",
+      manifestPath
+    );
+    expectEqual2(
+      manifest.claims?.mainnet,
+      "BLOCKED_BY_POLICY",
+      issues,
+      "ZK_MAINNET_GUARD_INVALID",
+      manifestPath
+    );
+    for (const limitation of ZK_KNOWN_LIMITATIONS) {
+      if (!Array.isArray(manifest.expectedKnownLimitations) || !manifest.expectedKnownLimitations.includes(limitation)) {
+        issues.push({
+          code: "ZK_LIMITATION_NOT_DECLARED",
+          message: `ZK corpus must declare ${limitation}.`,
+          file: manifestPath
+        });
+      }
+    }
+  }
+  let fixturesChecked = 0;
+  let artifactsChecked = 0;
+  const proofSystems = /* @__PURE__ */ new Set();
+  if (Array.isArray(manifest?.fixtures)) {
+    for (const fixture of manifest.fixtures) {
+      fixturesChecked += 1;
+      const fixturePath = path6.join(corpusPath, fixture.path);
+      const inspect = await inspectZkProof(fixturePath, workspaceRoot);
+      artifactsChecked += inspect.summary.files.length;
+      if (inspect.proofSystem !== "unknown") proofSystems.add(inspect.proofSystem);
+      issues.push(...inspect.issues);
+      if (inspect.proofSystem === "groth16") {
+        const verified = await verifyZkProofLocal(fixturePath, workspaceRoot);
+        issues.push(...verified.issues);
+        expectEqual2(
+          verified.status,
+          fixture.expectedStatus,
+          issues,
+          "ZK_FIXTURE_STATUS_MISMATCH",
+          fixturePath
+        );
+      } else if (inspect.proofSystem === "risc0") {
+        const verified = await verifyZkProofLocal(fixturePath, workspaceRoot);
+        expectEqual2(
+          verified.status,
+          fixture.expectedStatus,
+          issues,
+          "ZK_FIXTURE_STATUS_MISMATCH",
+          fixturePath
+        );
+      }
+    }
+  } else if (manifest) {
+    issues.push({
+      code: "ZK_CORPUS_MANIFEST_INVALID",
+      message: "ZK corpus manifest must include fixtures array.",
+      file: manifestPath
+    });
+  }
+  const ok = issues.length === 0;
+  return {
+    ok,
+    schema: HardkasSchemas7.ZkCorpusVerificationV1,
+    path: path6.relative(workspaceRoot, corpusPath).replace(/\\/g, "/"),
+    experimental: true,
+    status: ok ? "ZK_CORPUS_VERIFICATION_PASS" : "ZK_CORPUS_VERIFICATION_FAIL",
+    summary: {
+      proofSystems: Array.from(proofSystems).sort(),
+      fixturesChecked,
+      artifactsChecked,
+      contentHashes: issues.some((issue) => issue.code.includes("HASH")) ? "FAIL" : "PASS",
+      localVerification: ok ? "PARTIAL" : "FAIL",
+      knownLimitations: Array.isArray(manifest?.expectedKnownLimitations) ? manifest.expectedKnownLimitations : []
+    },
+    claims: {
+      zkArtifactCoherence: ok ? "READY_MATCH" : "INVALID",
+      zkLocalVerification: ok ? "READY_GROTH16_FIXTURE_COHERENCE" : "INVALID",
+      zkOnchainVerification: ok ? "NOT_CLAIMED" : "INVALID",
+      runtimeOutcome: ok ? "PARTIAL" : "INVALID",
+      vmConsensusEquivalence: ok ? "NOT_CLAIMED" : "INVALID",
+      mainnet: ok ? "BLOCKED_BY_POLICY" : "INVALID"
+    },
+    issues
+  };
+}
+function verifyGroth16Fixture(dir, manifest, issues) {
+  if (!manifest) return;
+  const proofPath = path6.join(dir, manifest.proof ?? "proof.json");
+  const inputsPath = path6.join(dir, manifest.publicInputs ?? "public-inputs.json");
+  const keyPath = path6.join(dir, manifest.verificationKey ?? "verification-key.json");
+  const metadataPath = path6.join(
+    dir,
+    manifest.verifierMetadata ?? "verifier-metadata.json"
+  );
+  const reportPath = path6.join(dir, manifest.verifyReport ?? "verify-report.json");
+  const proof = readJson(proofPath, issues);
+  const publicInputs = readJson(inputsPath, issues);
+  const verificationKey = readJson(keyPath, issues);
+  const metadata = readJson(metadataPath, issues);
+  const report = readJson(reportPath, issues);
+  if (!proof || !publicInputs || !verificationKey || !metadata || !report) return;
+  verifyManifestHash(manifest, "proof", proof, issues, proofPath);
+  verifyManifestHash(manifest, "publicInputs", publicInputs, issues, inputsPath);
+  verifyManifestHash(manifest, "verificationKey", verificationKey, issues, keyPath);
+  verifyManifestHash(manifest, "verifierMetadata", metadata, issues, metadataPath);
+  verifyManifestHash(manifest, "verifyReport", report, issues, reportPath);
+  const publicInputsHash = calculateContentHash4(publicInputs);
+  const verificationKeyHash = calculateContentHash4(verificationKey);
+  const proofHash = calculateContentHash4(proof);
+  expectEqual2(
+    proof.publicInputsHash,
+    publicInputsHash,
+    issues,
+    "ZK_GROTH16_PUBLIC_INPUTS_HASH_MISMATCH",
+    proofPath
+  );
+  expectEqual2(
+    proof.verificationKeyHash,
+    verificationKeyHash,
+    issues,
+    "ZK_GROTH16_VERIFICATION_KEY_HASH_MISMATCH",
+    proofPath
+  );
+  expectEqual2(
+    metadata.proofHash,
+    proofHash,
+    issues,
+    "ZK_GROTH16_PROOF_HASH_MISMATCH",
+    metadataPath
+  );
+  expectEqual2(
+    metadata.publicInputsHash,
+    publicInputsHash,
+    issues,
+    "ZK_GROTH16_PUBLIC_INPUTS_HASH_MISMATCH",
+    metadataPath
+  );
+  expectEqual2(
+    metadata.verificationKeyHash,
+    verificationKeyHash,
+    issues,
+    "ZK_GROTH16_VERIFICATION_KEY_HASH_MISMATCH",
+    metadataPath
+  );
+  expectEqual2(
+    report.status,
+    "ZK_FIXTURE_COHERENCE_PASS",
+    issues,
+    "ZK_GROTH16_REPORT_STATUS_INVALID",
+    reportPath
+  );
+  expectEqual2(
+    report.claims?.zkOnchainVerification,
+    "NOT_CLAIMED",
+    issues,
+    "ZK_ONCHAIN_VERIFICATION_NOT_CLAIMED",
+    reportPath
+  );
+  const coherenceDigest = calculateContentHash4({
+    proofSystem: "groth16",
+    proofHash,
+    publicInputsHash,
+    verificationKeyHash,
+    statementHash: publicInputs.statementHash,
+    verifierAdapter: manifest.verifierAdapter
+  });
+  expectEqual2(
+    metadata.coherenceDigest,
+    coherenceDigest,
+    issues,
+    "ZK_GROTH16_COHERENCE_MISMATCH",
+    metadataPath
+  );
+  expectEqual2(
+    report.coherenceDigest,
+    coherenceDigest,
+    issues,
+    "ZK_GROTH16_COHERENCE_MISMATCH",
+    reportPath
+  );
+}
+function unsupportedVerification(resolved, workspaceRoot, proofSystem, issues, verifierAdapter) {
+  return {
+    ok: false,
+    schema: HardkasSchemas7.ZkProofVerificationV1,
+    path: path6.relative(workspaceRoot, resolved).replace(/\\/g, "/"),
+    proofSystem,
+    status: "ZK_VERIFIER_UNSUPPORTED",
+    experimental: true,
+    summary: {
+      ...verifierAdapter ? { verifierAdapter } : {},
+      contentHashes: issues.some((issue) => issue.code.includes("HASH")) ? "FAIL" : "PASS",
+      localVerification: "FAIL"
+    },
+    claims: zkClaims(),
+    issues: [
+      ...issues,
+      {
+        code: "ZK_VERIFIER_UNSUPPORTED",
+        message: `No local verifier is available for proof system ${proofSystem}.`
+      }
+    ]
+  };
+}
+function resolveManifestPath(resolved, issues) {
+  if (!fs6.existsSync(resolved)) {
+    issues.push({
+      code: "ZK_PROOF_FILE_MISSING",
+      message: `Missing ${resolved}.`,
+      file: resolved
+    });
+    return void 0;
+  }
+  const stat = fs6.statSync(resolved);
+  if (stat.isDirectory()) return path6.join(resolved, "manifest.json");
+  return resolved;
+}
+function collectFixtureFiles(manifest) {
+  if (!manifest) return [];
+  return [
+    ["proof", manifest.proof],
+    ["publicInputs", manifest.publicInputs],
+    ["verificationKey", manifest.verificationKey],
+    ["verifierMetadata", manifest.verifierMetadata],
+    ["verifyReport", manifest.verifyReport],
+    ["receipt", manifest.receipt],
+    ["journal", manifest.journal],
+    ["imageId", manifest.imageId]
+  ].filter((entry) => typeof entry[1] === "string").map(([key, file]) => ({ key, file }));
+}
+function detectProofSystem(manifest, resolved) {
+  const declared = manifest?.proofSystem;
+  if (declared === "groth16" || declared === "risc0") return declared;
+  const lower = resolved.toLowerCase();
+  if (lower.includes("groth16")) return "groth16";
+  if (lower.includes("risc0")) return "risc0";
+  return "unknown";
+}
+function verifyManifestHash(manifest, key, value, issues, filePath) {
+  const expected = manifest.contentHashes?.[key];
+  if (typeof expected !== "string") {
+    issues.push({
+      code: "ZK_CORPUS_HASH_MISSING",
+      message: `Missing content hash for ${key}.`,
+      file: filePath
+    });
+    return;
+  }
+  const actual = calculateContentHash4(value);
+  if (actual !== expected) {
+    issues.push({
+      code: "ZK_CORPUS_HASH_MISMATCH",
+      message: `Expected ${expected}, got ${actual}.`,
+      file: filePath
+    });
+  }
+}
+function readJson(filePath, issues) {
+  if (!fs6.existsSync(filePath)) {
+    issues.push({
+      code: "ZK_FILE_MISSING",
+      message: `Missing ${filePath}.`,
+      file: filePath
+    });
+    return void 0;
+  }
+  try {
+    return JSON.parse(fs6.readFileSync(filePath, "utf8"));
+  } catch (error) {
+    issues.push({
+      code: "ZK_JSON_INVALID",
+      message: error?.message || `Invalid JSON in ${filePath}.`,
+      file: filePath
+    });
+    return void 0;
+  }
+}
+function expectEqual2(actual, expected, issues, code, file) {
+  if (actual !== expected) {
+    issues.push({
+      code,
+      message: `Expected ${String(expected)}, got ${String(actual)}.`,
+      file
+    });
+  }
+}
+function zkClaims() {
+  return {
+    zkArtifactCoherence: "EXPERIMENTAL",
+    zkLocalVerification: "EXPERIMENTAL_FIXTURE_ONLY",
+    zkOnchainVerification: "NOT_CLAIMED",
+    vmConsensusEquivalence: "NOT_CLAIMED",
+    mainnet: "BLOCKED_BY_POLICY"
+  };
+}
+
+// src/vprogs.ts
+import fs7 from "fs";
+import path7 from "path";
+import { calculateContentHash as calculateContentHash5 } from "@hardkas/artifacts";
+import { HardkasSchemas as HardkasSchemas8 } from "@hardkas/artifacts";
+var HardkasVprogs = class {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+  sdk;
+  async capabilities() {
+    return createVprogsCapabilities();
+  }
+  async status() {
+    return createVprogsStatus();
+  }
+  async inspect(targetPath) {
+    return inspectVprogsArtifact(targetPath, this.sdk.cwd);
+  }
+};
+function createVprogsCapabilities() {
+  return {
+    ok: true,
+    schema: HardkasSchemas8.VProgsCapabilitiesV1,
+    status: "VPROGS_INSPECT_SURFACE_READY",
+    claims: vprogsClaims(),
+    errors: [
+      "VPROGS_RUNTIME_NOT_CLAIMED",
+      "VPROGS_STABLE_API_NOT_CLAIMED",
+      "ZK_ONCHAIN_VERIFICATION_NOT_CLAIMED"
+    ]
+  };
+}
+function createVprogsStatus() {
+  return {
+    ok: true,
+    schema: HardkasSchemas8.VProgsStatusV1,
+    status: "VPROGS_INSPECT_SURFACE_READY",
+    claims: vprogsClaims()
+  };
+}
+async function inspectVprogsArtifact(targetPath, workspaceRoot = process.cwd()) {
+  const resolved = path7.resolve(workspaceRoot, targetPath);
+  if (!fs7.existsSync(resolved)) {
+    return {
+      ok: false,
+      schema: HardkasSchemas8.VProgsInspectV1,
+      status: "VPROGS_ARTIFACT_INVALID",
+      path: path7.relative(workspaceRoot, resolved).replace(/\\/g, "/"),
+      claims: vprogsClaims(),
+      issues: [
+        {
+          code: "VPROGS_ARTIFACT_MISSING",
+          message: `Missing ${resolved}.`,
+          file: resolved
+        }
+      ]
+    };
+  }
+  try {
+    const artifact = JSON.parse(fs7.readFileSync(resolved, "utf8"));
+    return {
+      ok: true,
+      schema: HardkasSchemas8.VProgsInspectV1,
+      status: "VPROGS_ARTIFACT_INSPECTED",
+      path: path7.relative(workspaceRoot, resolved).replace(/\\/g, "/"),
+      artifactHash: calculateContentHash5(artifact),
+      artifactSchema: artifact.schema,
+      claims: vprogsClaims(),
+      issues: []
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      schema: HardkasSchemas8.VProgsInspectV1,
+      status: "VPROGS_ARTIFACT_INVALID",
+      path: path7.relative(workspaceRoot, resolved).replace(/\\/g, "/"),
+      claims: vprogsClaims(),
+      issues: [
+        {
+          code: "VPROGS_ARTIFACT_INVALID",
+          message: error?.message || "Invalid vProgs artifact JSON.",
+          file: resolved
+        }
+      ]
+    };
+  }
+}
+function vprogsClaims() {
+  return {
+    vProgsArtifactInspection: "READY",
+    vProgsRuntime: "NOT_CLAIMED",
+    vProgsStableApi: "NOT_CLAIMED",
+    zkOnchainVerification: "NOT_CLAIMED",
+    vmConsensusEquivalence: "NOT_CLAIMED",
+    mainnet: "BLOCKED_BY_POLICY"
+  };
+}
+
+// src/programmability.ts
+import fs8 from "fs";
+import path8 from "path";
+import { calculateContentHash as calculateContentHash6, verifyArtifactIntegritySync } from "@hardkas/artifacts";
+import { HardkasSchemas as HardkasSchemas9 } from "@hardkas/artifacts";
+var HardkasProgrammability = class {
+  constructor(sdk) {
+    this.sdk = sdk;
+    this.corpus = {
+      verify: (options = {}) => this.verifyCorpus(options)
+    };
+    this.app = {
+      plan: (options = {}) => this.planApp(options)
+    };
+  }
+  sdk;
+  corpus;
+  app;
+  async capabilities() {
+    return createProgrammabilityCapabilities();
+  }
+  async inspect(options) {
+    if (options.kind === "zk") {
+      const result = await this.sdk.zk.proof.inspect(options.path);
+      return {
+        ok: result.ok,
+        schema: HardkasSchemas9.ProgrammabilityInspectV1,
+        status: result.ok ? "PROGRAMMABILITY_ARTIFACT_INSPECTED" : "PROGRAMMABILITY_ARTIFACT_INVALID",
+        kind: "zk",
+        path: result.path,
+        sourceStatus: result.status,
+        claims: programmabilityClaims(),
+        issues: result.issues
+      };
+    }
+    if (options.kind === "vprog") {
+      const result = await this.sdk.vprogs.inspect(options.path);
+      return {
+        ok: result.ok,
+        schema: HardkasSchemas9.ProgrammabilityInspectV1,
+        status: result.ok ? "PROGRAMMABILITY_ARTIFACT_INSPECTED" : "PROGRAMMABILITY_ARTIFACT_INVALID",
+        kind: "vprog",
+        path: result.path,
+        ...result.artifactSchema ? { artifactSchema: result.artifactSchema } : {},
+        ...result.artifactHash ? { contentHash: result.artifactHash } : {},
+        sourceStatus: result.status,
+        claims: programmabilityClaims(),
+        issues: result.issues
+      };
+    }
+    return inspectJsonArtifact(this.sdk.cwd, options.path, "silver");
+  }
+  async verify(options) {
+    if (options.kind === "zk") {
+      const result2 = await this.sdk.zk.proof.verifyLocal(options.path);
+      return {
+        ok: result2.ok,
+        schema: HardkasSchemas9.ProgrammabilityVerifyV1,
+        status: result2.ok ? "PROGRAMMABILITY_VERIFY_PASS" : "PROGRAMMABILITY_VERIFY_PARTIAL",
+        kind: "zk",
+        path: result2.path,
+        sourceStatus: result2.status,
+        claims: programmabilityClaims(),
+        issues: result2.issues
+      };
+    }
+    if (options.kind === "vprog") {
+      const inspected = await this.sdk.vprogs.inspect(options.path);
+      return {
+        ok: inspected.ok,
+        schema: HardkasSchemas9.ProgrammabilityVerifyV1,
+        status: inspected.ok ? "PROGRAMMABILITY_VERIFY_PASS" : "PROGRAMMABILITY_VERIFY_FAIL",
+        kind: "vprog",
+        path: inspected.path,
+        sourceStatus: inspected.status,
+        claims: programmabilityClaims(),
+        issues: inspected.issues
+      };
+    }
+    const resolved = path8.resolve(this.sdk.cwd, options.path);
+    const result = verifyArtifactIntegritySync(resolved, { strict: false });
+    return {
+      ok: result.ok,
+      schema: HardkasSchemas9.ProgrammabilityVerifyV1,
+      status: result.ok ? "PROGRAMMABILITY_VERIFY_PASS" : "PROGRAMMABILITY_VERIFY_FAIL",
+      kind: "silver",
+      path: path8.relative(this.sdk.cwd, resolved).replace(/\\/g, "/"),
+      sourceStatus: result.ok ? "ARTIFACT_INTEGRITY_PASS" : "ARTIFACT_INTEGRITY_FAIL",
+      claims: programmabilityClaims(),
+      issues: result.issues.map((issue) => ({
+        code: String(issue.code),
+        message: issue.message,
+        ...issue.path ? { file: issue.path } : {}
+      }))
+    };
+  }
+  async verifyCorpus(options) {
+    const root = path8.resolve(this.sdk.cwd, options.path ?? "fixtures/toccata-v2");
+    const include = new Set(options.include ?? ["silver", "zk", "vprogs"]);
+    const issues = [];
+    const manifestPath = path8.join(root, "manifest.json");
+    const manifest = readJson2(manifestPath, issues);
+    if (manifest) {
+      expectEqual3(
+        manifest.schema,
+        HardkasSchemas9.ToccataProgrammabilityCorpusV1,
+        issues,
+        "PROGRAMMABILITY_CORPUS_SCHEMA_INVALID",
+        manifestPath
+      );
+      expectEqual3(
+        manifest.network,
+        "simnet",
+        issues,
+        "PROGRAMMABILITY_CORPUS_NETWORK_INVALID",
+        manifestPath
+      );
+      expectEqual3(
+        manifest.profile,
+        "toccata-v2",
+        issues,
+        "PROGRAMMABILITY_CORPUS_PROFILE_INVALID",
+        manifestPath
+      );
+      expectEqual3(
+        manifest.claims?.artifactCoherence,
+        "READY_MATCH",
+        issues,
+        "PROGRAMMABILITY_CLAIM_INVALID",
+        manifestPath
+      );
+      expectEqual3(
+        manifest.claims?.runtimeOutcome,
+        "PARTIAL",
+        issues,
+        "PROGRAMMABILITY_CLAIM_INVALID",
+        manifestPath
+      );
+      expectEqual3(
+        manifest.claims?.vmConsensusEquivalence,
+        "NOT_CLAIMED",
+        issues,
+        "PROGRAMMABILITY_CLAIM_INVALID",
+        manifestPath
+      );
+      expectEqual3(
+        manifest.claims?.mainnet,
+        "BLOCKED_BY_POLICY",
+        issues,
+        "PROGRAMMABILITY_CLAIM_INVALID",
+        manifestPath
+      );
+      if (!Array.isArray(manifest.expectedKnownLimitations) || !manifest.expectedKnownLimitations.includes("PARTIAL_VM_SIMULATION")) {
+        issues.push({
+          code: "PROGRAMMABILITY_LIMITATION_NOT_DECLARED",
+          message: "Root corpus must declare PARTIAL_VM_SIMULATION.",
+          file: manifestPath
+        });
+      }
+    }
+    let silver = "SKIPPED";
+    let zk = "SKIPPED";
+    let vprogs = "SKIPPED";
+    if (include.has("silver")) {
+      const result = await this.sdk.corpus.verify(
+        path8.join(path8.relative(this.sdk.cwd, root), "silver")
+      );
+      silver = result.ok ? "PASS" : "FAIL";
+      issues.push(...result.issues);
+    }
+    if (include.has("zk")) {
+      const result = await this.sdk.zk.corpus.verify(
+        path8.join(path8.relative(this.sdk.cwd, root), "zk")
+      );
+      zk = result.ok ? "PASS" : "FAIL";
+      issues.push(...result.issues);
+    }
+    if (include.has("vprogs")) {
+      const artifact = manifest?.components?.vprogs?.artifact ?? "vprogs/inspect-only-artifact.json";
+      const result = await this.sdk.vprogs.inspect(
+        path8.join(path8.relative(this.sdk.cwd, root), artifact)
+      );
+      vprogs = result.ok ? "PASS" : "FAIL";
+      issues.push(...result.issues);
+    }
+    const ok = issues.length === 0;
+    return {
+      ok,
+      schema: HardkasSchemas9.ProgrammabilityCorpusReportV1,
+      path: path8.relative(this.sdk.cwd, root).replace(/\\/g, "/"),
+      status: ok ? "PROGRAMMABILITY_CORPUS_PASS" : "PROGRAMMABILITY_CORPUS_FAIL",
+      summary: {
+        silver,
+        zk,
+        vprogs,
+        rootManifest: manifest ? "PASS" : "FAIL",
+        knownLimitations: Array.isArray(manifest?.expectedKnownLimitations) ? manifest.expectedKnownLimitations : []
+      },
+      claims: programmabilityClaims(),
+      issues
+    };
+  }
+  planApp(options) {
+    const kind = options.kind ?? "full-lab";
+    const template = options.template ?? defaultTemplate(kind);
+    return {
+      ok: true,
+      schema: HardkasSchemas9.ProgrammabilityAppPlanV1,
+      status: "PROGRAMMABILITY_APP_PLAN_READY",
+      kind,
+      template,
+      commands: commandsForKind(kind),
+      sdkSurfaces: sdkSurfacesForKind(kind),
+      claims: programmabilityClaims(),
+      nonClaims: nonClaims()
+    };
+  }
+};
+function createProgrammabilityCapabilities() {
+  return {
+    ok: true,
+    schema: HardkasSchemas9.ProgrammabilityCapabilitiesV1,
+    status: "PROGRAMMABILITY_SURFACE_READY",
+    surfaces: {
+      silverScript: "SILVERSCRIPT_BUILDER_READY",
+      zkCorpus: "ZK_CORPUS_SURFACE_READY",
+      groth16FixtureCoherence: "READY_GROTH16_FIXTURE_COHERENCE",
+      risc0Inspect: "RISC0_INSPECT_SURFACE_READY",
+      vProgsInspect: "VPROGS_INSPECT_SURFACE_READY"
+    },
+    claims: programmabilityClaims(),
+    nonClaims: nonClaims()
+  };
+}
+function programmabilityClaims() {
+  return {
+    artifactCoherence: "READY_MATCH",
+    silverScriptBuilder: "SILVERSCRIPT_BUILDER_READY",
+    zkCorpusSurface: "ZK_CORPUS_SURFACE_READY",
+    zkLocalVerification: "READY_GROTH16_FIXTURE_COHERENCE",
+    risc0InspectSurface: "RISC0_INSPECT_SURFACE_READY",
+    vProgsInspectSurface: "VPROGS_INSPECT_SURFACE_READY",
+    runtimeOutcome: "PARTIAL",
+    vmConsensusEquivalence: "NOT_CLAIMED",
+    zkOnchainVerification: "NOT_CLAIMED",
+    vProgsRuntime: "NOT_CLAIMED",
+    vProgsStableApi: "NOT_CLAIMED",
+    mainnet: "BLOCKED_BY_POLICY"
+  };
+}
+function inspectJsonArtifact(workspaceRoot, targetPath, kind) {
+  const resolved = path8.resolve(workspaceRoot, targetPath);
+  const issues = [];
+  const artifact = readJson2(resolved, issues);
+  const ok = Boolean(artifact);
+  return {
+    ok,
+    schema: HardkasSchemas9.ProgrammabilityInspectV1,
+    status: ok ? "PROGRAMMABILITY_ARTIFACT_INSPECTED" : "PROGRAMMABILITY_ARTIFACT_INVALID",
+    kind,
+    path: path8.relative(workspaceRoot, resolved).replace(/\\/g, "/"),
+    ...artifact?.schema ? { artifactSchema: artifact.schema } : {},
+    ...artifact ? { contentHash: calculateContentHash6(artifact, artifact.hashVersion ?? 4) } : {},
+    claims: programmabilityClaims(),
+    issues
+  };
+}
+function readJson2(filePath, issues) {
+  if (!fs8.existsSync(filePath)) {
+    issues.push({
+      code: "PROGRAMMABILITY_FILE_MISSING",
+      message: `Missing ${filePath}.`,
+      file: filePath
+    });
+    return void 0;
+  }
+  try {
+    return JSON.parse(fs8.readFileSync(filePath, "utf8"));
+  } catch (error) {
+    issues.push({
+      code: "PROGRAMMABILITY_JSON_INVALID",
+      message: error?.message || `Invalid JSON in ${filePath}.`,
+      file: filePath
+    });
+    return void 0;
+  }
+}
+function expectEqual3(actual, expected, issues, code, file) {
+  if (actual !== expected) {
+    issues.push({
+      code,
+      message: `Expected ${String(expected)}, got ${String(actual)}.`,
+      file
+    });
+  }
+}
+function defaultTemplate(kind) {
+  if (kind === "silver") return "templates/programmability/silver-policy-app";
+  if (kind === "zk") return "templates/programmability/zk-fixture-app";
+  if (kind === "vprog") return "templates/programmability/vprogs-inspect-app";
+  return "templates/programmability/full-lab-app";
+}
+function commandsForKind(kind) {
+  const common = [
+    "hardkas programmability capabilities --json",
+    "hardkas programmability corpus verify fixtures/toccata-v2 --json"
+  ];
+  if (kind === "silver") return [...common, "hardkas silver inspect <artifact>"];
+  if (kind === "zk")
+    return [...common, "hardkas zk corpus verify fixtures/toccata-v2/zk --json"];
+  if (kind === "vprog") return [...common, "hardkas vprogs inspect <artifact> --json"];
+  return [
+    ...common,
+    "hardkas silver inspect <artifact>",
+    "hardkas zk corpus verify fixtures/toccata-v2/zk --json",
+    "hardkas vprogs inspect <artifact> --json"
+  ];
+}
+function sdkSurfacesForKind(kind) {
+  const common = [
+    "hardkas.programmability.capabilities()",
+    "hardkas.programmability.corpus.verify()"
+  ];
+  if (kind === "silver") return [...common, "hardkas.silver.*"];
+  if (kind === "zk")
+    return [...common, "hardkas.zk.proof.*", "hardkas.zk.corpus.verify()"];
+  if (kind === "vprog") return [...common, "hardkas.vprogs.inspect()"];
+  return [...common, "hardkas.silver.*", "hardkas.zk.*", "hardkas.vprogs.*"];
+}
+function nonClaims() {
+  return [
+    "no mainnet",
+    "no testnet claim",
+    "no bridge",
+    "no trustless exit",
+    "no on-chain ZK verification",
+    "no full vProgs runtime",
+    "no VM/consensus equivalence"
+  ];
+}
+
 // src/index.ts
 import { defineHardkasConfig as defineHardkasConfig2 } from "@hardkas/config";
 
@@ -2012,16 +3970,16 @@ var defineTask = taskRegistry.defineTask.bind(taskRegistry);
 import { buildPaymentPlan as buildPaymentPlan2 } from "@hardkas/tx-builder";
 import { signTxPlanArtifact as signTxPlanArtifact2 } from "@hardkas/accounts";
 import {
-  writeArtifact as writeArtifact3,
+  writeArtifact as writeArtifact4,
   createTxPlanArtifact as createTxPlanArtifact2,
   ARTIFACT_SCHEMAS as ARTIFACT_SCHEMAS2,
-  HARDKAS_VERSION as HARDKAS_VERSION3
+  HARDKAS_VERSION as HARDKAS_VERSION5
 } from "@hardkas/artifacts";
 import {
   SOMPI_PER_KAS,
   HardkasError as HardkasError4,
-  parseKasToSompi as parseKasToSompi2,
-  formatSompi as formatSompi2
+  parseKasToSompi as parseKasToSompi3,
+  formatSompiToKas as formatSompiToKas2
 } from "@hardkas/core";
 var Hardkas = class _Hardkas {
   constructor(config, options, rpc) {
@@ -2047,6 +4005,12 @@ var Hardkas = class _Hardkas {
     this.replay = new HardkasReplay(this);
     this.lineage = new HardkasLineage(this);
     this.workflow = new HardkasWorkflow(this);
+    this.capabilitiesApi = new HardkasCapabilitiesApi();
+    this.corpus = new HardkasCorpus(this);
+    this.silver = new HardkasSilver(this);
+    this.zk = new HardkasZk(this);
+    this.vprogs = new HardkasVprogs(this);
+    this.programmability = new HardkasProgrammability(this);
   }
   config;
   workspace;
@@ -2059,6 +4023,12 @@ var Hardkas = class _Hardkas {
   replay;
   lineage;
   workflow;
+  capabilitiesApi;
+  corpus;
+  silver;
+  zk;
+  vprogs;
+  programmability;
   signer;
   mode;
   policy;
@@ -2080,21 +4050,23 @@ var Hardkas = class _Hardkas {
     const activeNetwork = options.network || loaded.config.defaultNetwork || "simnet";
     const isSimulated = activeNetwork === "simulated" || loaded.config.networks?.[activeNetwork]?.kind === "simulated";
     const autoBootstrap = options.autoBootstrap ?? (isSimulated ? true : false);
-    const fs4 = await import("fs");
-    const path4 = await import("path");
+    const fs9 = await import("fs");
+    const path9 = await import("path");
     const cwd = options.cwd || process.cwd();
-    const hardkasDir = path4.join(cwd, ".hardkas");
+    const hardkasDir = path9.join(cwd, ".hardkas");
     if (autoBootstrap) {
       if (!isSimulated) {
         if (options.logger) {
-          options.logger.warn("[HardKAS] autoBootstrap ignored for non-simulated network");
+          options.logger.warn(
+            "[HardKAS] autoBootstrap ignored for non-simulated network"
+          );
         }
       } else {
-        if (!fs4.existsSync(hardkasDir)) {
+        if (!fs9.existsSync(hardkasDir)) {
           if (options.logger) {
             options.logger.info("[HardKAS] Auto-bootstrapping simulated workspace");
           }
-          fs4.mkdirSync(hardkasDir, { recursive: true });
+          fs9.mkdirSync(hardkasDir, { recursive: true });
         }
         try {
           const { loadOrCreateLocalnetState } = await import("@hardkas/localnet");
@@ -2103,8 +4075,11 @@ var Hardkas = class _Hardkas {
         }
       }
     } else {
-      if (!fs4.existsSync(hardkasDir)) {
-        throw new HardkasError3("NOT_INITIALIZED", "Workspace not initialized. Run npx hardkas init . or pass autoBootstrap: true.");
+      if (!fs9.existsSync(hardkasDir)) {
+        throw new HardkasError3(
+          "NOT_INITIALIZED",
+          "Workspace not initialized. Run npx hardkas init . or pass autoBootstrap: true."
+        );
       }
     }
     if (options.network) {
@@ -2135,6 +4110,9 @@ var Hardkas = class _Hardkas {
   get cwd() {
     return this.config.cwd;
   }
+  async capabilities() {
+    return this.capabilitiesApi.get();
+  }
   /**
    * Validates an action against the active security policy.
    * Throws HardkasError if the policy is violated.
@@ -2164,26 +4142,43 @@ var Hardkas = class _Hardkas {
 };
 export {
   ARTIFACT_SCHEMAS2 as ARTIFACT_SCHEMAS,
-  HARDKAS_VERSION3 as HARDKAS_VERSION,
+  HARDKAS_VERSION5 as HARDKAS_VERSION,
   Hardkas,
   HardkasAccounts,
   HardkasArtifactsManager,
+  HardkasCapabilitiesApi,
+  HardkasCorpus,
   HardkasError4 as HardkasError,
   HardkasL2,
   HardkasLineage,
   HardkasLocalnet,
+  HardkasProgrammability,
   HardkasQuery,
   HardkasReplay,
+  HardkasSilver,
   HardkasTx,
+  HardkasVprogs,
   HardkasWorkspace,
+  HardkasZk,
   SOMPI_PER_KAS,
   buildPaymentPlan2 as buildPaymentPlan,
+  createHardkasCapabilities,
   createHardkasClient,
+  createProgrammabilityCapabilities,
   createTxPlanArtifact2 as createTxPlanArtifact,
+  createVprogsCapabilities,
+  createVprogsStatus,
+  createZkCapabilities,
   defineHardkasConfig2 as defineHardkasConfig,
   defineTask,
-  formatSompi2 as formatSompi,
-  parseKasToSompi2 as parseKasToSompi,
+  formatSompiToKas2 as formatSompiToKas,
+  inspectVprogsArtifact,
+  inspectZkProof,
+  parseKasToSompi3 as parseKasToSompi,
+  programmabilityClaims,
   signTxPlanArtifact2 as signTxPlanArtifact,
-  writeArtifact3 as writeArtifact
+  verifyToccataCorpus,
+  verifyZkCorpus,
+  verifyZkProofLocal,
+  writeArtifact4 as writeArtifact
 };