@tangle-network/starter-foundry 0.7.3 → 0.13.2

package/registry/layers/capability/tangle-remote-provider/files/remote-config.json

@@ -15,7 +15,7 @@
     {
       "id": "router-tangle",
       "baseUrl": "https://router.tangle.tools",
-      "credentialKey": "TANGLE_ROUTER_API_KEY",
+      "credentialKey": "TANGLE_API_KEY",
       "note": "Tangle's own router — prefer this so billing + observability stays inside the platform."
     }
   ],

package/registry/layers/capability/zk-browser/manifest.json

@@ -91,11 +91,11 @@
     "archetypes": [
       "mixer",
       "privacy-preserving mixer",
-      "private voting",
       "anonymous voting",
       "anonymous credential",
       "nullifier",
       "commitment preimage",
+      "merkle proof",
       "merkle root display",
       "zk proof",
       "zk-snark",

package/registry/layers/framework/aptos-move/files/package.json

@@ -5,5 +5,9 @@
   "scripts": {
     "build": "aptos move compile --named-addresses {{projectName}}=default",
     "test": "aptos move test --named-addresses {{projectName}}=default"
+  },
+  "pnpm": {
+    "minimumReleaseAge": 4320,
+    "minimumReleaseAgeExclude": []
   }
 }

package/registry/layers/framework/crm-backend/files/package.json

@@ -18,5 +18,9 @@
     "drizzle-kit": "^0.30.0",
     "typescript": "^5.9.0",
     "@types/node": "^20.17.0"
+  },
+  "pnpm": {
+    "minimumReleaseAge": 4320,
+    "minimumReleaseAgeExclude": []
   }
 }

package/registry/layers/framework/ecommerce-headless/files/package.json

@@ -19,5 +19,9 @@
     "drizzle-kit": "^0.30.0",
     "typescript": "^5.9.0",
     "@types/node": "^20.17.0"
+  },
+  "pnpm": {
+    "minimumReleaseAge": 4320,
+    "minimumReleaseAgeExclude": []
   }
 }

package/registry/layers/framework/electron-native-os/files/package.json

@@ -26,5 +26,9 @@
     "react-dom": "^18.3.1",
     "typescript": "^5.6.3",
     "vite": "^5.4.10"
+  },
+  "pnpm": {
+    "minimumReleaseAge": 4320,
+    "minimumReleaseAgeExclude": []
   }
 }

package/registry/layers/framework/fhenix-foundry/files/Contract.sol

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.25;
+
+import {FHE, euint32, ebool, InEuint32} from "@fhenixprotocol/cofhe-contracts/FHE.sol";
+
+/// @title {{contractName}}
+/// @notice Fhenix FHE contract. State is held as ENCRYPTED types (euint*/ebool)
+///         and only ever touched through FHE.* ops — never decrypted on-chain
+///         except through an authorized seal/permit. This is the real artifact:
+///         replace the placeholder logic below with the product's encrypted flow
+///         (sealed-bid auction, private vote, confidential balance, etc).
+contract {{contractName}} {
+    /// Encrypted state. Stays a ciphertext handle for its whole lifetime.
+    euint32 internal _value;
+    address public owner;
+
+    constructor() {
+        owner = msg.sender;
+        // Trivially-encrypt the initial value, then authorize THIS contract to
+        // keep operating on the resulting ciphertext across calls.
+        _value = FHE.asEuint32(0);
+        FHE.allowThis(_value);
+    }
+
+    /// @notice Fold an encrypted input into encrypted state. The caller encrypts
+    ///         `amount` client-side via cofhejs and submits the sealed handle —
+    ///         the plaintext never touches the chain.
+    /// @dev    TODO: replace this counter fold with the product's real encrypted
+    ///         logic (bid comparison via FHE.gte + FHE.select, vote tally via
+    ///         FHE.add, etc). The shape — decrypt input → FHE op → re-authorize —
+    ///         is the load-bearing pattern.
+    function submit(InEuint32 calldata amount) external {
+        euint32 incoming = FHE.asEuint32(amount);
+        _value = FHE.add(_value, incoming);
+        FHE.allowThis(_value);
+        FHE.allowSender(_value); // let the caller seal/decrypt their own view
+    }
+
+    /// @notice An encrypted comparison the off-chain client can seal and read.
+    /// @dev    Returns an `ebool` ciphertext — NOT a plaintext bool — so the
+    ///         comparison result itself stays private until sealed for an
+    ///         authorized viewer.
+    function isAtLeast(InEuint32 calldata threshold) external returns (ebool result) {
+        euint32 t = FHE.asEuint32(threshold);
+        result = FHE.gte(_value, t);
+        FHE.allowThis(result);
+        FHE.allowSender(result);
+    }
+
+    /// @notice Return the encrypted state handle. The caller seals it client-side
+    ///         (cofhejs unseal) — the contract never exposes plaintext.
+    function encryptedValue() external view returns (euint32) {
+        return _value;
+    }
+}

package/registry/layers/framework/fhenix-foundry/files/Contract.t.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.25;
+
+import {FHE, euint32, ebool, InEuint32} from "@fhenixprotocol/cofhe-contracts/FHE.sol";
+import { {{contractName}} } from "../src/{{contractName}}.sol";
+
+/// @dev Foundry test. With the vendored CoFHE surface, encrypted handles are
+///      deterministic locally, so we can assert end-to-end. Against the real
+///      coprocessor, drive these through the CoFHE test harness instead.
+contract {{contractName}}Test {
+    {{contractName}} internal target;
+
+    function setUp() public {
+        target = new {{contractName}}();
+    }
+
+    function _sealedInput(uint256 value) internal pure returns (InEuint32 memory) {
+        return InEuint32({ ctHash: value, securityZone: 0, utype: 0, signature: "" });
+    }
+
+    function test_submit_accumulates_encrypted_state() public {
+        target.submit(_sealedInput(7));
+        target.submit(_sealedInput(5));
+        // Encrypted state is a ciphertext handle; with the local vendored surface
+        // the handle carries the folded value. On-chain it stays opaque.
+        euint32 handle = target.encryptedValue();
+        assert(euint32.unwrap(handle) == 12);
+    }
+
+    function test_isAtLeast_returns_encrypted_bool() public {
+        target.submit(_sealedInput(10));
+        ebool atLeast = target.isAtLeast(_sealedInput(8));
+        assert(ebool.unwrap(atLeast) == 1);
+    }
+
+    function test_owner_is_deployer() public view {
+        assert(target.owner() == address(this));
+    }
+}

package/registry/layers/framework/fhenix-foundry/files/Deploy.s.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.25;
+
+import { {{contractName}} } from "../src/{{contractName}}.sol";
+
+/// @dev Foundry deploy script. Broadcast against the Fhenix network:
+///      forge script script/Deploy.s.sol --rpc-url $FHENIX_RPC_URL --broadcast
+contract DeployScript {
+    function run() external returns ({{contractName}} deployed) {
+        deployed = new {{contractName}}();
+    }
+}

package/registry/layers/framework/fhenix-foundry/files/foundry.toml

@@ -0,0 +1,25 @@
+[profile.default]
+src = "src"
+out = "out"
+libs = ["lib"]
+test = "test"
+script = "script"
+solc_version = "0.8.25"
+optimizer = true
+optimizer_runs = 200
+
+# CoFHE is vendored under lib/cofhe-contracts/contracts/ so `forge build` resolves
+# the encrypted-type imports offline. On a real Fhenix deploy, swap this for the
+# installed package: "@fhenixprotocol/cofhe-contracts/=node_modules/@fhenixprotocol/cofhe-contracts/contracts/".
+remappings = [
+  "@fhenixprotocol/cofhe-contracts/=lib/cofhe-contracts/contracts/"
+]
+
+# forge lint — `info` severity is naming-convention noise (mixed-case-variable,
+# screaming-snake-case-immutable) that real FHE contracts trip on; test/script
+# are fixture code where casts + raw arithmetic are routine, not real bugs.
+[lint]
+severity = ["high", "med", "gas"]
+ignore = ["test/**/*", "script/**/*"]
+
+# See more at https://book.getfoundry.sh/reference/config/overview

package/registry/layers/framework/fhenix-foundry/files/lib/cofhe-contracts/contracts/FHE.sol

@@ -0,0 +1,94 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.25;
+
+// Vendored minimal CoFHE contracts surface so the scaffold compiles OFFLINE
+// under `forge build`. This mirrors the public @fhenixprotocol/cofhe-contracts
+// API the agent writes against (encrypted types + FHE.* ops + permissions) but
+// is NOT the production FHE coprocessor — the real package ships the host
+// precompiles. On a real Fhenix deployment, install
+// @fhenixprotocol/cofhe-contracts and point the remapping at it. Here it exists
+// so the type checker and the build engage on the agent's own src/*.sol.
+//
+// Lives under lib/cofhe-contracts/contracts/ on purpose: that path is treated
+// as a vendored third-party lib (it is NOT the agent's deliverable artifact),
+// so the agent's src/<Name>.sol is the required real contract.
+
+type euint8 is uint256;
+type euint16 is uint256;
+type euint32 is uint256;
+type euint64 is uint256;
+type euint128 is uint256;
+type euint256 is uint256;
+type ebool is uint256;
+type eaddress is uint256;
+
+struct InEuint8 { uint256 ctHash; uint8 securityZone; uint8 utype; bytes signature; }
+struct InEuint16 { uint256 ctHash; uint8 securityZone; uint8 utype; bytes signature; }
+struct InEuint32 { uint256 ctHash; uint8 securityZone; uint8 utype; bytes signature; }
+struct InEuint64 { uint256 ctHash; uint8 securityZone; uint8 utype; bytes signature; }
+struct InEuint128 { uint256 ctHash; uint8 securityZone; uint8 utype; bytes signature; }
+struct InEuint256 { uint256 ctHash; uint8 securityZone; uint8 utype; bytes signature; }
+struct InEbool { uint256 ctHash; uint8 securityZone; uint8 utype; bytes signature; }
+struct InEaddress { uint256 ctHash; uint8 securityZone; uint8 utype; bytes signature; }
+
+library FHE {
+    // ─── trivial encryption (plaintext → ciphertext handle) ───
+    function asEuint8(uint256 value) internal pure returns (euint8) { return euint8.wrap(value); }
+    function asEuint16(uint256 value) internal pure returns (euint16) { return euint16.wrap(value); }
+    function asEuint32(uint256 value) internal pure returns (euint32) { return euint32.wrap(value); }
+    function asEuint64(uint256 value) internal pure returns (euint64) { return euint64.wrap(value); }
+    function asEuint128(uint256 value) internal pure returns (euint128) { return euint128.wrap(value); }
+    function asEuint256(uint256 value) internal pure returns (euint256) { return euint256.wrap(value); }
+    function asEbool(bool value) internal pure returns (ebool) { return ebool.wrap(value ? 1 : 0); }
+    function asEaddress(address value) internal pure returns (eaddress) { return eaddress.wrap(uint256(uint160(value))); }
+
+    // ─── decrypt a sealed input handle into an in-contract ciphertext ───
+    function asEuint8(InEuint8 memory value) internal pure returns (euint8) { return euint8.wrap(value.ctHash); }
+    function asEuint16(InEuint16 memory value) internal pure returns (euint16) { return euint16.wrap(value.ctHash); }
+    function asEuint32(InEuint32 memory value) internal pure returns (euint32) { return euint32.wrap(value.ctHash); }
+    function asEuint64(InEuint64 memory value) internal pure returns (euint64) { return euint64.wrap(value.ctHash); }
+    function asEuint128(InEuint128 memory value) internal pure returns (euint128) { return euint128.wrap(value.ctHash); }
+    function asEuint256(InEuint256 memory value) internal pure returns (euint256) { return euint256.wrap(value.ctHash); }
+    function asEbool(InEbool memory value) internal pure returns (ebool) { return ebool.wrap(value.ctHash); }
+    function asEaddress(InEaddress memory value) internal pure returns (eaddress) { return eaddress.wrap(value.ctHash); }
+
+    // ─── homomorphic arithmetic (euint32; extend per type as needed) ───
+    function add(euint32 a, euint32 b) internal pure returns (euint32) {
+        return euint32.wrap(euint32.unwrap(a) + euint32.unwrap(b));
+    }
+    function sub(euint32 a, euint32 b) internal pure returns (euint32) {
+        return euint32.wrap(euint32.unwrap(a) - euint32.unwrap(b));
+    }
+    function mul(euint32 a, euint32 b) internal pure returns (euint32) {
+        return euint32.wrap(euint32.unwrap(a) * euint32.unwrap(b));
+    }
+
+    // ─── homomorphic comparison → ebool ───
+    function lte(euint32 a, euint32 b) internal pure returns (ebool) {
+        return ebool.wrap(euint32.unwrap(a) <= euint32.unwrap(b) ? 1 : 0);
+    }
+    function gte(euint32 a, euint32 b) internal pure returns (ebool) {
+        return ebool.wrap(euint32.unwrap(a) >= euint32.unwrap(b) ? 1 : 0);
+    }
+    function eq(euint32 a, euint32 b) internal pure returns (ebool) {
+        return ebool.wrap(euint32.unwrap(a) == euint32.unwrap(b) ? 1 : 0);
+    }
+
+    // ─── oblivious selection (encrypted ternary) ───
+    function select(ebool control, euint32 a, euint32 b) internal pure returns (euint32) {
+        return ebool.unwrap(control) == 1 ? a : b;
+    }
+
+    // ─── access control: grant decryption/seal permission for a ciphertext ───
+    function allowThis(euint32) internal pure {}
+    function allowThis(ebool) internal pure {}
+    function allow(euint32, address) internal pure {}
+    function allow(ebool, address) internal pure {}
+    function allowSender(euint32) internal pure {}
+    function allowSender(ebool) internal pure {}
+
+    // ─── seal an encrypted value for off-chain client-side decryption ───
+    function sealoutput(euint32 value, bytes32) internal pure returns (string memory) {
+        return string(abi.encodePacked(euint32.unwrap(value)));
+    }
+}

package/registry/layers/framework/fhenix-foundry/manifest.json

@@ -0,0 +1,12 @@
+{
+  "id": "fhenix-foundry",
+  "description": "Fhenix FHE contracts framework layer on Foundry: forge-buildable encrypted-type contract + vendored CoFHE so `forge build` compiles offline.",
+  "appliesTo": ["fhenix-foundry"],
+  "files": [
+    { "source": "files/foundry.toml", "target": "foundry.toml" },
+    { "source": "files/lib/cofhe-contracts/contracts/FHE.sol", "target": "lib/cofhe-contracts/contracts/FHE.sol" },
+    { "source": "files/Contract.sol", "target": "src/{{contractName}}.sol" },
+    { "source": "files/Contract.t.sol", "target": "test/{{contractName}}.t.sol" },
+    { "source": "files/Deploy.s.sol", "target": "script/Deploy.s.sol" }
+  ]
+}

package/registry/layers/framework/gdpr-compliance-pack/files/package.json

@@ -15,5 +15,9 @@
     "@types/react": "^18.3.0",
     "@types/react-dom": "^18.3.0",
     "typescript": "^5.9.0"
+  },
+  "pnpm": {
+    "minimumReleaseAge": 4320,
+    "minimumReleaseAgeExclude": []
   }
 }

package/registry/layers/framework/godot-web/files/package.json

@@ -11,5 +11,9 @@
   "devDependencies": {
     "serve": "^14.2.0",
     "typescript": "^5.4.0"
+  },
+  "pnpm": {
+    "minimumReleaseAge": 4320,
+    "minimumReleaseAgeExclude": []
   }
 }

package/registry/layers/framework/healthcare-hipaa-backend/files/package.json

@@ -18,5 +18,9 @@
     "drizzle-kit": "^0.30.0",
     "typescript": "^5.9.0",
     "@types/node": "^20.17.0"
+  },
+  "pnpm": {
+    "minimumReleaseAge": 4320,
+    "minimumReleaseAgeExclude": []
   }
 }

package/registry/layers/framework/hipaa-compliance-pack/files/package.json

@@ -10,5 +10,9 @@
   "devDependencies": {
     "@types/node": "^22.0.0",
     "typescript": "^5.9.0"
+  },
+  "pnpm": {
+    "minimumReleaseAge": 4320,
+    "minimumReleaseAgeExclude": []
   }
 }

package/registry/layers/framework/hugo-static/files/package.json

@@ -9,5 +9,9 @@
   },
   "devDependencies": {
     "hugo-extended": "^0.127.0"
+  },
+  "pnpm": {
+    "minimumReleaseAge": 4320,
+    "minimumReleaseAgeExclude": []
   }
 }

package/registry/layers/framework/legal-case-mgmt/files/package.json

@@ -19,5 +19,9 @@
     "drizzle-kit": "^0.30.0",
     "typescript": "^5.9.0",
     "@types/node": "^20.17.0"
+  },
+  "pnpm": {
+    "minimumReleaseAge": 4320,
+    "minimumReleaseAgeExclude": []
   }
 }

package/registry/layers/framework/move-package/files/Move.toml

@@ -18,8 +18,12 @@ package = "_"
 package = "0xcafe"
 
 # AptosFramework provides std (signer, vector, string, ...) and the
-# aptos_framework namespace (coin, account, event, timestamp). Pinned to
-# `mainnet` branch so the resolved versions match what's actually deployed.
+# aptos_framework namespace (coin, account, event, timestamp). Pinned to a
+# stable framework release tag rather than a moving branch — the `mainnet`
+# branch ships Move 2.2 language features (e.g. ability constraints on
+# function types) that older aptos CLI versions reject. v1.36.1 is the
+# highest framework release that compiles cleanly under aptos CLI 7.x;
+# bump to a newer tag once you upgrade the CLI in lockstep.
 # First `aptos move compile` fetches this git dep (~30s cold, cached after).
 [dependencies]
-AptosFramework = { git = "https://github.com/aptos-labs/aptos-core.git", subdir = "aptos-move/framework/aptos-framework", rev = "mainnet" }
+AptosFramework = { git = "https://github.com/aptos-labs/aptos-core.git", subdir = "aptos-move/framework/aptos-framework", rev = "aptos-framework-v1.36.1" }

package/registry/layers/framework/react-vite-ts/files/index.html

@@ -1,8 +1,8 @@
-<!doctype html>
+<!DOCTYPE html>
 <html lang="en">
   <head>
-    <meta charset="utf-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <link rel="preconnect" href="https://fonts.googleapis.com">
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
     <link href="https://fonts.googleapis.com/css2?family=Inter:ital,opsz,wght@0,14..32,100..900;1,14..32,100..900&display=swap" rel="stylesheet">

package/registry/layers/framework/tangle-blueprint/files/main.rs

@@ -1,8 +1,5 @@
 use {{crateName}}_lib::router;
 use blueprint_sdk::contexts::tangle::TangleClientContext;
-use blueprint_sdk::crypto::tangle_pair_signer::TanglePairSigner;
-use blueprint_sdk::keystore::backends::Backend;
-use blueprint_sdk::keystore::crypto::sp_core::SpSr25519;
 use blueprint_sdk::runner::BlueprintRunner;
 use blueprint_sdk::runner::config::BlueprintEnvironment;
 use blueprint_sdk::runner::tangle::config::TangleConfig;
@@ -21,16 +18,6 @@ async fn main() -> Result<(), blueprint_sdk::Error> {
         .await
         .map_err(|e| blueprint_sdk::Error::Other(e.to_string()))?;
 
-    let sr25519_signer = env
-        .keystore()
-        .first_local::<SpSr25519>()
-        .map_err(|e| blueprint_sdk::Error::Other(e.to_string()))?;
-    let sr25519_pair = env
-        .keystore()
-        .get_secret::<SpSr25519>(&sr25519_signer)
-        .map_err(|e| blueprint_sdk::Error::Other(e.to_string()))?;
-    let tangle_signer = TanglePairSigner::new(sr25519_pair.0);
-
     let service_id = env
         .protocol_settings
         .tangle()
@@ -40,10 +27,8 @@ async fn main() -> Result<(), blueprint_sdk::Error> {
 
     info!("Starting {{blueprintName}} for service {service_id}");
 
-    let tangle_producer = TangleProducer::finalized_blocks(tangle_client.rpc_client.clone())
-        .await
-        .map_err(|e| blueprint_sdk::Error::Other(e.to_string()))?;
-    let tangle_consumer = TangleConsumer::new(tangle_client.rpc_client.clone(), tangle_signer);
+    let tangle_producer = TangleProducer::new(tangle_client.clone(), service_id);
+    let tangle_consumer = TangleConsumer::new(tangle_client);
     let tangle_config = TangleConfig::default();
 
     let result = BlueprintRunner::builder(tangle_config, env)

package/registry/layers/framework/zola-static/files/package.json

@@ -8,5 +8,9 @@
     "check": "zola check",
     "validate": "node validate-zola.mjs"
   },
-  "devDependencies": {}
+  "devDependencies": {},
+  "pnpm": {
+    "minimumReleaseAge": 4320,
+    "minimumReleaseAgeExclude": []
+  }
 }

package/registry/layers/ui-adapter/blocks-renderer/files/lib/blocks-to-artifacts.tsx

@@ -0,0 +1,188 @@
+// blocks-to-artifacts — adapts AgentBlock[] to the
+// SandboxWorkbenchArtifact[] shape consumed by @tangle-network/sandbox-ui's
+// SandboxWorkbench. This is the bridge that lets a starter-foundry agent
+// bundle's :::artifact / :::escalation / :::screener-result / :::audio-cue
+// output land in the workbench's artifact pane without per-app glue code.
+//
+// The mapping is intentionally narrow: each block kind maps to one
+// SandboxWorkbenchArtifact discriminated-union variant. Callers can extend
+// the registry with `registerBlockMapper` when a bundle ships a
+// domain-specific block type.
+
+import type { ReactNode } from 'react'
+import type { AgentBlock, ParsedBlock } from './parse-blocks.js'
+import { isAgentBlock } from './parse-blocks.js'
+
+// SandboxWorkbenchArtifact is the published shape from
+// @tangle-network/sandbox-ui/workspace. We re-state the relevant variants
+// inline so this file has no hard dep on sandbox-ui — UI-family scaffolds
+// import it from sandbox-ui directly.
+export type SandboxWorkbenchArtifact =
+  | {
+      kind: 'markdown'
+      id: string
+      title?: string
+      content: string
+      meta?: Record<string, unknown>
+    }
+  | {
+      kind: 'openui'
+      id: string
+      title?: string
+      schema: unknown
+      meta?: Record<string, unknown>
+    }
+  | {
+      kind: 'custom'
+      id: string
+      title?: string
+      content: ReactNode
+      meta?: Record<string, unknown>
+    }
+
+export type BlockMapper = (block: AgentBlock, index: number) => SandboxWorkbenchArtifact | null
+
+const DEFAULT_MAPPERS: Record<string, BlockMapper> = {
+  artifact: (block, i) => ({
+    kind: 'markdown',
+    id: block.attrs.id ?? `artifact-${i}`,
+    title: block.attrs.title ?? block.attrs.label ?? 'Artifact',
+    content: block.body,
+    meta: { source: 'agent-output:artifact', attrs: block.attrs },
+  }),
+  escalation: (block, i) => ({
+    kind: 'markdown',
+    id: block.attrs.id ?? `escalation-${i}`,
+    title: 'Escalation — see a real expert',
+    content: block.body,
+    meta: { source: 'agent-output:escalation', severity: block.attrs.severity ?? 'high', attrs: block.attrs },
+  }),
+  'screener-result': (block, i) => ({
+    kind: 'markdown',
+    id: block.attrs.id ?? `screener-${i}`,
+    title: `${block.attrs.instrument ?? 'Screener'} result`,
+    content: block.body,
+    meta: { source: 'agent-output:screener-result', band: block.attrs.band, score: block.attrs.score, attrs: block.attrs },
+  }),
+  'audio-cue': (block, i) => ({
+    kind: 'markdown',
+    id: block.attrs.id ?? `audio-${i}`,
+    title: block.attrs.title ?? 'Audio cue',
+    content: block.body,
+    meta: { source: 'agent-output:audio-cue', voiceProfile: block.attrs['voice-profile'], attrs: block.attrs },
+  }),
+  suggestion: (block, i) => ({
+    kind: 'markdown',
+    id: block.attrs.id ?? `suggestion-${i}`,
+    title: block.attrs.title ?? 'Suggestion',
+    content: block.body,
+    meta: { source: 'agent-output:suggestion', priority: block.attrs.priority, attrs: block.attrs },
+  }),
+  proposal: (block, i) => ({
+    kind: 'markdown',
+    id: block.attrs.id ?? `proposal-${i}`,
+    title: block.attrs.title ?? 'Proposal',
+    content: block.body,
+    meta: { source: 'agent-output:proposal', attrs: block.attrs },
+  }),
+  filing: (block, i) => ({
+    kind: 'markdown',
+    id: block.attrs.id ?? `filing-${i}`,
+    title: block.attrs.title ?? 'Filing',
+    content: block.body,
+    meta: { source: 'agent-output:filing', attrs: block.attrs },
+  }),
+  survey: (block, i) => ({
+    kind: 'markdown',
+    id: block.attrs.id ?? `survey-${i}`,
+    title: block.attrs.title ?? 'Survey',
+    content: block.body,
+    meta: { source: 'agent-output:survey', attrs: block.attrs },
+  }),
+}
+
+const customMappers = new Map<string, BlockMapper>()
+
+export function registerBlockMapper(kind: string, mapper: BlockMapper): void {
+  customMappers.set(kind, mapper)
+}
+
+export function clearBlockMappers(): void {
+  customMappers.clear()
+}
+
+/**
+ * Convert a stream of parsed blocks into SandboxWorkbenchArtifact[]. Blocks
+ * with kind `openui` (or attrs.format === 'openui') become openui artifacts
+ * that render via sandbox-ui's OpenUIArtifactRenderer. Unknown block kinds
+ * fall through to the markdown default unless a custom mapper is registered.
+ */
+export function blocksToArtifacts(blocks: ParsedBlock[]): SandboxWorkbenchArtifact[] {
+  const out: SandboxWorkbenchArtifact[] = []
+  let i = 0
+  for (const block of blocks) {
+    if (!isAgentBlock(block)) continue
+    if (block.attrs.format === 'openui') {
+      try {
+        const schema = JSON.parse(block.body)
+        out.push({
+          kind: 'openui',
+          id: block.attrs.id ?? `openui-${i}`,
+          title: block.attrs.title ?? block.kind,
+          schema,
+          meta: { source: `agent-output:${block.kind}`, attrs: block.attrs },
+        })
+        i++
+        continue
+      } catch {
+        // Fall through to default mapper on bad JSON.
+      }
+    }
+    const mapper = customMappers.get(block.kind) ?? DEFAULT_MAPPERS[block.kind]
+    if (mapper) {
+      const artifact = mapper(block, i)
+      if (artifact) out.push(artifact)
+    } else {
+      // Unknown kind — emit as markdown with a debug-friendly title.
+      out.push({
+        kind: 'markdown',
+        id: block.attrs.id ?? `unknown-${i}`,
+        title: `[${block.kind}]`,
+        content: block.body,
+        meta: { source: `agent-output:${block.kind}`, unknown: true, attrs: block.attrs },
+      })
+    }
+    i++
+  }
+  return out
+}
+
+/**
+ * Subscribe to a useSdkSession-style stream and emit artifact updates. The
+ * caller passes the assistant message's accumulated text on each chunk; the
+ * adapter re-parses + re-emits the full artifact list. Idempotent.
+ */
+export function makeArtifactStreamAdapter(): {
+  feed: (assistantText: string) => SandboxWorkbenchArtifact[]
+  reset: () => void
+} {
+  let lastText = ''
+  let lastArtifacts: SandboxWorkbenchArtifact[] = []
+  return {
+    feed(text: string): SandboxWorkbenchArtifact[] {
+      if (text === lastText) return lastArtifacts
+      const blocks = (() => {
+        // Lazy-import to avoid circular reference.
+        const { parseBlocks } = require('./parse-blocks.js') as typeof import('./parse-blocks.js')
+        return parseBlocks(text)
+      })()
+      lastText = text
+      lastArtifacts = blocksToArtifacts(blocks)
+      return lastArtifacts
+    },
+    reset() {
+      lastText = ''
+      lastArtifacts = []
+    },
+  }
+}