diff --git a/Cargo.lock b/Cargo.lock
index 91265a8b..84cdfc4a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -478,7 +478,7 @@ checksum = "fc652a48c352aef3ea3aed32080501cf3ef6ed5da78602a020c991775b0aff04"
 
 [[package]]
 name = "c0mpute-api"
-version = "0.2.66"
+version = "0.2.67"
 dependencies = [
  "anyhow",
  "c0mpute-proto",
@@ -493,7 +493,7 @@ dependencies = [
 
 [[package]]
 name = "c0mpute-bench"
-version = "0.2.66"
+version = "0.2.67"
 dependencies = [
  "anyhow",
  "blake3",
@@ -504,7 +504,7 @@ dependencies = [
 
 [[package]]
 name = "c0mpute-cli"
-version = "0.2.66"
+version = "0.2.67"
 dependencies = [
  "anyhow",
  "axum",
@@ -534,7 +534,7 @@ dependencies = [
 
 [[package]]
 name = "c0mpute-core"
-version = "0.2.66"
+version = "0.2.67"
 dependencies = [
  "aes-gcm",
  "anyhow",
@@ -578,7 +578,7 @@ dependencies = [
 
 [[package]]
 name = "c0mpute-doctor"
-version = "0.2.66"
+version = "0.2.67"
 dependencies = [
  "anyhow",
  "serde",
@@ -590,7 +590,7 @@ dependencies = [
 
 [[package]]
 name = "c0mpute-envelope"
-version = "0.2.66"
+version = "0.2.67"
 dependencies = [
  "blake3",
  "bs58",
@@ -603,7 +603,7 @@ dependencies = [
 
 [[package]]
 name = "c0mpute-gateway"
-version = "0.2.66"
+version = "0.2.67"
 dependencies = [
  "anyhow",
  "axum",
@@ -625,7 +625,7 @@ dependencies = [
 
 [[package]]
 name = "c0mpute-market"
-version = "0.2.66"
+version = "0.2.67"
 dependencies = [
  "c0mpute-envelope",
  "serde",
@@ -635,7 +635,7 @@ dependencies = [
 
 [[package]]
 name = "c0mpute-net"
-version = "0.2.66"
+version = "0.2.67"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -652,7 +652,7 @@ dependencies = [
 
 [[package]]
 name = "c0mpute-placement"
-version = "0.2.66"
+version = "0.2.67"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -673,7 +673,7 @@ dependencies = [
 
 [[package]]
 name = "c0mpute-proto"
-version = "0.2.66"
+version = "0.2.67"
 dependencies = [
  "blake3",
  "hex",
@@ -685,7 +685,7 @@ dependencies = [
 
 [[package]]
 name = "c0mpute-secure-chat"
-version = "0.2.66"
+version = "0.2.67"
 dependencies = [
  "aes-gcm",
  "anyhow",
@@ -708,7 +708,7 @@ dependencies = [
 
 [[package]]
 name = "c0mpute-store"
-version = "0.2.66"
+version = "0.2.67"
 dependencies = [
  "anyhow",
  "blake3",
@@ -726,7 +726,7 @@ dependencies = [
 
 [[package]]
 name = "c0mpute-transcode"
-version = "0.2.66"
+version = "0.2.67"
 dependencies = [
  "anyhow",
  "c0mpute-proto",
@@ -739,7 +739,7 @@ dependencies = [
 
 [[package]]
 name = "c0mpute-update"
-version = "0.2.66"
+version = "0.2.67"
 dependencies = [
  "anyhow",
  "hex",
@@ -753,7 +753,7 @@ dependencies = [
 
 [[package]]
 name = "c0mpute-verify"
-version = "0.2.66"
+version = "0.2.67"
 dependencies = [
  "anyhow",
  "blake3",
diff --git a/Cargo.toml b/Cargo.toml
index f39beda4..6e39d486 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -23,7 +23,7 @@ members = [
 ]
 
 [workspace.package]
-version = "0.2.66"
+version = "0.2.67"
 edition = "2024"
 license = "MIT"
 repository = "https://github.com/profullstack/c0mpute"
diff --git a/apps/tui/package.json b/apps/tui/package.json
index 0ed320ba..267c28d3 100644
--- a/apps/tui/package.json
+++ b/apps/tui/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@c0mpute/tui",
-  "version": "0.2.66",
+  "version": "0.2.67",
   "private": true,
   "type": "module",
   "bin": {
diff --git a/apps/web/package.json b/apps/web/package.json
index 4f0e2948..357ebc88 100644
--- a/apps/web/package.json
+++ b/apps/web/package.json
@@ -1,6 +1,6 @@
 {
   "name": "c0mpute",
-  "version": "0.2.66",
+  "version": "0.2.67",
   "private": true,
   "type": "module",
   "scripts": {
diff --git a/apps/web/src/app/api/plugins/route.ts b/apps/web/src/app/api/plugins/route.ts
index cf89594b..f3c7073d 100644
--- a/apps/web/src/app/api/plugins/route.ts
+++ b/apps/web/src/app/api/plugins/route.ts
@@ -12,6 +12,7 @@ import {
   loadAllPlugins,
   tagline,
   installCommand,
+  installedByDefault,
   modelOptions,
 } from "@/lib/plugins";
 
@@ -20,19 +21,30 @@ export function GET() {
     // Omitted rather than sent as [] for the plugins that have no model to
     // choose, which is most of them.
     const models = modelOptions(p).map(({ id, model }) => ({ id, ...model }));
+    const install = installCommand(p);
 
     return {
       id: p.id,
       name: p.name,
       version: p.version,
       kind: p.kind,
+      // available | partial | coming-soon. A coming-soon plugin is a spec
+      // with no implementation behind it yet.
+      status: p.status,
+      status_note: p.statusNote,
+      builtin: p.builtin,
+      installed_by_default: installedByDefault(p),
       tagline: tagline(p),
       description: p.description,
       keywords: p.keywords ?? [],
       homepage: p.homepage,
       source: p.source,
-      install_command: installCommand(p),
-      install_url: `https://c0mpute.com/plugins/${p.id}/install.sh`,
+      // null when there is nothing to install: built in, coming soon, or no
+      // install.sh in the repo.
+      install_command: install,
+      install_url: install
+        ? `https://c0mpute.com/plugins/${p.id}/install.sh`
+        : null,
       web: `https://c0mpute.com/plugins/${p.id}`,
       models: models.length > 0 ? models : undefined,
     };
diff --git a/apps/web/src/app/plugins/page.tsx b/apps/web/src/app/plugins/page.tsx
index 1bacaa1d..07369c32 100644
--- a/apps/web/src/app/plugins/page.tsx
+++ b/apps/web/src/app/plugins/page.tsx
@@ -6,6 +6,7 @@ import {
   byCategory,
   tagline,
   installCommand,
+  installedByDefault,
   modelOptions,
   CATEGORY_LABELS,
   CATEGORY_BLURBS,
@@ -16,7 +17,7 @@ import {
 export const metadata = {
   title: "plugins — c0mpute",
   description:
-    "c0mpute workload plugins, network services and applications: AI inference, embeddings, image and video generation, speech and OCR; transcoding, rendering and streaming; crawling, storage and hosting. MIT-licensed, manifest-driven.",
+    "c0mpute workload plugins, network services and applications: AI inference, image and video generation, speech, transcoding, web fetching, workflow steps, webhooks and OpenDisk storage, with more marked coming soon. MIT-licensed, manifest-driven.",
   alternates: { canonical: "https://c0mpute.com/plugins" },
 };
 
@@ -64,6 +65,12 @@ export default function PluginsPage() {
           <Badge label="application" /> is a product built <em>on</em>{" "}
           c0mpute — useful, and not something the protocol depends on.
         </p>
+        <p>
+          <Badge label="partial" /> runs today with a caveat noted on the
+          card.{" "}
+          <Badge label="coming soon" /> is a published spec with no
+          implementation yet — nothing to install or run.
+        </p>
       </section>
 
       {groups.map(({ category, plugins }) => (
@@ -74,6 +81,8 @@ export default function PluginsPage() {
               <span className="text-[var(--color-dim)] font-normal">
                 {" "}
                 · {plugins.length}
+                {comingSoonCount(plugins) > 0 &&
+                  ` (${comingSoonCount(plugins)} coming soon)`}
               </span>
             </h2>
             <p className="text-xs text-[var(--color-dim)]">
@@ -119,6 +128,10 @@ function kindLabel(p: PluginManifest): string {
   return p.category === "applications" ? "application" : "service";
 }
 
+function comingSoonCount(plugins: PluginManifest[]): number {
+  return plugins.filter((p) => p.status === "coming-soon").length;
+}
+
 function Badge({ label }: { label: string }) {
   return (
     <span className="border border-[var(--color-rule)] rounded px-1.5 py-0.5 accent whitespace-nowrap">
@@ -134,15 +147,27 @@ function PluginCard({ p }: { p: PluginManifest }) {
       : p.dispatch?.mode === "container"
         ? "container"
         : "subprocess";
+  const comingSoon = p.status === "coming-soon";
+  const install = installCommand(p);
 
   return (
-    <article className="border border-[var(--color-rule)] bg-[var(--color-card)] rounded p-5 space-y-3">
+    <article
+      className={`border border-[var(--color-rule)] bg-[var(--color-card)] rounded p-5 space-y-3${comingSoon ? " opacity-70" : ""}`}
+    >
       <header className="flex items-baseline justify-between gap-3">
         <h3 className="text-lg accent">
           <span className="text-[var(--color-dim)]">[</span>
           {p.id}
           <span className="text-[var(--color-dim)]">]</span>{" "}
           <span className="text-[var(--color-fg)]">{p.name}</span>
+          {p.status !== "available" && (
+            <>
+              {" "}
+              <span className="text-xs align-middle">
+                <Badge label={comingSoon ? "coming soon" : "partial"} />
+              </span>
+            </>
+          )}
         </h3>
         <span className="text-xs text-[var(--color-dim)] whitespace-nowrap">
           v{p.version} · {kindLabel(p)} · {dispatchLabel}
@@ -161,14 +186,24 @@ function PluginCard({ p }: { p: PluginManifest }) {
 
       <ModelList p={p} />
 
-      {p.dispatch?.mode === "in-process" ? (
-        <p className="text-xs accent">ships with c0mpute · installed by default</p>
-      ) : (
-        <CodeBlock>{`$ ${installCommand(p)}`}</CodeBlock>
+      {p.status === "partial" && p.statusNote && (
+        <p className="text-xs text-[var(--color-dim)]">
+          <span className="accent">partial:</span> {p.statusNote}
+        </p>
       )}
 
+      {comingSoon ? (
+        <p className="text-xs text-[var(--color-dim)]">
+          coming soon · spec only, not yet implemented
+        </p>
+      ) : installedByDefault(p) ? (
+        <p className="text-xs accent">ships with c0mpute · installed by default</p>
+      ) : install ? (
+        <CodeBlock>{`$ ${install}`}</CodeBlock>
+      ) : null}
+
       <footer className="flex flex-wrap gap-x-4 gap-y-1 text-xs text-[var(--color-dim)]">
-        {p.surfaces?.cli && (
+        {p.surfaces?.cli && !comingSoon && (
           <span>
             cli: <code className="text-[var(--color-fg)]">{p.surfaces.cli}</code>
           </span>
diff --git a/apps/web/src/app/releases/latest.json/route.ts b/apps/web/src/app/releases/latest.json/route.ts
index 96a6fc78..67b35208 100644
--- a/apps/web/src/app/releases/latest.json/route.ts
+++ b/apps/web/src/app/releases/latest.json/route.ts
@@ -28,7 +28,7 @@ export const dynamic = "force-dynamic";
  * this in sync with the workspace version in `Cargo.toml` on each release so a
  * freshly built CLI reports "already latest" rather than a phantom upgrade.
  */
-const FALLBACK_VERSION = "0.2.66";
+const FALLBACK_VERSION = "0.2.67";
 const FALLBACK_MIN_REQUIRED = "0.0.1";
 
 type Channel = "stable" | "beta" | "nightly";
diff --git a/apps/web/src/components/webmcp-provider.tsx b/apps/web/src/components/webmcp-provider.tsx
index de413bf8..da1ad1ad 100644
--- a/apps/web/src/components/webmcp-provider.tsx
+++ b/apps/web/src/components/webmcp-provider.tsx
@@ -95,15 +95,38 @@ const TOOLS: WebMcpToolDescriptor[] = [
       },
       additionalProperties: false,
     },
-    execute: (args) => {
+    execute: async (args) => {
       const plugin =
         typeof args.plugin === "string" ? args.plugin.trim() : "";
       if (plugin) {
-        return json({
-          plugin,
-          command: `c0mpute plugin install ${plugin}`,
-          install_url: `https://c0mpute.com/plugins/${plugin}/install.sh`,
-        });
+        // Answer from the live listing, so a plugin that is built in or not
+        // built yet never gets an install command that would 404.
+        try {
+          const list = (await fetchJson("/api/plugins")) as {
+            plugins?: Array<{
+              id: string;
+              status?: string;
+              builtin?: boolean;
+              install_command?: string | null;
+              install_url?: string | null;
+            }>;
+          };
+          const found = list.plugins?.find((p) => p.id === plugin);
+          if (!found) return errorResult(`No plugin named "${plugin}".`);
+          if (found.status === "coming-soon") {
+            return json({ plugin, status: "coming-soon", note: "Not implemented yet; nothing to install." });
+          }
+          if (found.builtin) {
+            return json({ plugin, builtin: true, note: "Ships inside the c0mpute binary; no install needed." });
+          }
+          return json({
+            plugin,
+            command: found.install_command ?? null,
+            install_url: found.install_url ?? null,
+          });
+        } catch (e) {
+          return errorResult(`Failed to look up plugin: ${(e as Error).message}`);
+        }
       }
       return json({
         command: "curl -fsSL https://c0mpute.com/install.sh | sh",
diff --git a/apps/web/src/lib/plugins.ts b/apps/web/src/lib/plugins.ts
index 98adb305..be09bf39 100644
--- a/apps/web/src/lib/plugins.ts
+++ b/apps/web/src/lib/plugins.ts
@@ -1,4 +1,4 @@
-import { readFileSync, readdirSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
 import path from "node:path";
 import toml from "@iarna/toml";
 
@@ -75,12 +75,33 @@ export interface ModelOption {
   distilled?: boolean;
 }
 
+/**
+ * How much of a plugin actually ships. A manifest describes a contract; this
+ * says whether the code behind it exists. `available` runs today, `partial`
+ * runs with a caveat (see `statusNote`), `coming-soon` is a spec with no
+ * implementation yet. A manifest without `status` is treated as available.
+ */
+export const PLUGIN_STATUSES = ["available", "partial", "coming-soon"] as const;
+
+export type PluginStatus = (typeof PLUGIN_STATUSES)[number];
+
 export interface PluginManifest {
   id: string;
   name: string;
   version: string;
   kind: "workload" | "service" | "sdk";
   category: Category;
+  status: PluginStatus;
+  /** One sentence on what is missing; set for partial plugins. */
+  statusNote?: string;
+  /**
+   * Compiled into the c0mpute binary (`builtin = true` under [module]).
+   * Explicit rather than inferred from dispatch mode: an in-process manifest
+   * says how the code would run, not that the code exists.
+   */
+  builtin: boolean;
+  /** `plugins/<id>/install.sh` exists, so `c0mpute plugin install <id>` works. */
+  hasInstallScript: boolean;
   description: string;
   author?: string;
   license?: string;
@@ -139,6 +160,13 @@ function loadOne(id: string): PluginManifest | null {
     version: String(m.version ?? "0.0.0"),
     kind: (m.kind as PluginManifest["kind"]) ?? "workload",
     category: toCategory(m.category),
+    status: toStatus(m.status),
+    statusNote:
+      typeof m.status_note === "string" && m.status_note.length > 0
+        ? m.status_note
+        : undefined,
+    builtin: m.builtin === true,
+    hasInstallScript: existsSync(path.join(PLUGINS_DIR, id, "install.sh")),
     description: String(m.description ?? ""),
     author: typeof m.author === "string" ? m.author : undefined,
     license: typeof m.license === "string" ? m.license : undefined,
@@ -163,6 +191,12 @@ function toCategory(value: unknown): Category {
   return CATEGORIES.includes(value as Category) ? (value as Category) : "other";
 }
 
+function toStatus(value: unknown): PluginStatus {
+  return PLUGIN_STATUSES.includes(value as PluginStatus)
+    ? (value as PluginStatus)
+    : "available";
+}
+
 /**
  * Group plugins for display, preserving CATEGORIES order and dropping
  * groups that are empty.
@@ -172,7 +206,16 @@ export function byCategory(
 ): { category: Category; plugins: PluginManifest[] }[] {
   return CATEGORIES.map((category) => ({
     category,
-    plugins: plugins.filter((p) => p.category === category),
+    // Coming-soon cards sort after the ones that run today; each half keeps
+    // the incoming (id) order.
+    plugins: [
+      ...plugins.filter(
+        (p) => p.category === category && p.status !== "coming-soon",
+      ),
+      ...plugins.filter(
+        (p) => p.category === category && p.status === "coming-soon",
+      ),
+    ],
   })).filter((g) => g.plugins.length > 0);
 }
 
@@ -185,15 +228,24 @@ export function tagline(p: PluginManifest): string {
 }
 
 /**
- * Install command shown on each plugin card. Uniform across plugins:
- * `c0mpute plugin install <id>`. The CLI resolves the id to
- * `https://c0mpute.com/plugins/<id>/install.sh`. For in-process plugins
- * (transcode) the script informs the user it's built into c0mpute.
+ * Install command for a plugin, or null when there is nothing to install.
+ * `c0mpute plugin install <id>` resolves the id to
+ * `https://c0mpute.com/plugins/<id>/install.sh`, so the command is only
+ * offered when that script exists, the plugin is not already compiled into
+ * the binary, and it is not a coming-soon spec.
  */
-export function installCommand(p: PluginManifest): string {
+export function installCommand(p: PluginManifest): string | null {
+  if (p.status === "coming-soon" || p.builtin || !p.hasInstallScript) {
+    return null;
+  }
   return `c0mpute plugin install ${p.id}`;
 }
 
+/** Ships inside the c0mpute binary and works today. */
+export function installedByDefault(p: PluginManifest): boolean {
+  return p.builtin && p.status === "available";
+}
+
 /**
  * Model options for a card, default first then alphabetical. A plugin with
  * no `[module.models]` table returns an empty list and renders nothing —
diff --git a/docs/storage-opendisk.md b/docs/storage-opendisk.md
new file mode 100644
index 00000000..df4985bd
--- /dev/null
+++ b/docs/storage-opendisk.md
@@ -0,0 +1,39 @@
+# Storage on every node, listed on OpenDisk
+
+Storage is a default role. Every node that runs it (that is every node unless
+`--roles` leaves it out) serves two things on its gateway, `0.0.0.0:7777`:
+
+| Path | What |
+|---|---|
+| `/storage/v1/objects/{hash}`, `/shards/{hash}`, `/manifests/{hash}`, `/status` | The CIP-002 storage API. Reads are open: a blake3 hash is the capability, and private-tier objects are ciphertext. Writes need an `x-coinpay-auth` envelope signed by the node's own ed25519 key or a key in `storage.trusted_writers`, so a stranger cannot fill the disk. |
+| `/.well-known/opendisk.json` | The node's [OpenDisk 0.1](https://d1sks.pwa.pit.world/docs) descriptor: `key` (`ed25519:` + the node's identity key), live `capacity.free_gib` / `total_gib`, `price.per_gib_month`, and a `c0mpute` block with the peer id and storage API URL. |
+
+## Listing on d1sks
+
+A node lists itself; nothing central does it for the node. When the gateway announces a
+public **https** origin, the node submits that origin to the OpenDisk marketplace
+(`storage.d1sks_url`, default `https://d1sks.pwa.pit.world`) a few seconds after
+start and again every 24 hours. d1sks then reads the descriptor itself, every hour,
+and dedupes on the node's key.
+
+```toml
+# ~/.config/c0mpute/config.toml
+[gateway]
+bind     = "0.0.0.0:7777"
+announce = "https://disk.example.net"   # TLS in front of :7777
+
+[storage]
+cap_bytes               = 500_000_000_000  # offer 500 GB, not the whole disk
+price_usd_per_gib_month = 0.004            # the default
+trusted_writers         = []               # extra ed25519 keys (64 hex) allowed to write
+opendisk                = true             # false: no descriptor, no listing
+```
+
+A node without a public https origin (most home nodes, behind NAT) still serves its
+descriptor locally and still stores shards for the network; it is simply not on the
+marketplace until it has an origin d1sks can reach.
+
+## On the node board
+
+The capability ad carries `storage: { free_bytes, total_bytes, per_gib_month }`, and
+`c0mpute.com/api/nodes` shows it per node (numbers only, re-validated by the aggregator).
diff --git a/node/crates/c0mpute-cli/src/main.rs b/node/crates/c0mpute-cli/src/main.rs
index c41957e9..bf640da8 100644
--- a/node/crates/c0mpute-cli/src/main.rs
+++ b/node/crates/c0mpute-cli/src/main.rs
@@ -172,6 +172,12 @@ enum Cmd {
         #[command(subcommand)]
         cmd: JobsCmd,
     },
+    /// Crawl plugin: fetch a public web page through a c0mpute worker
+    /// (`crawl.fetch`: static, robots.txt-aware, private addresses refused).
+    Crawl {
+        #[command(subcommand)]
+        cmd: CrawlCmd,
+    },
     /// Coinpay plugin — delegates to the `coinpay` peer CLI.
     Coinpay {
         /// Arguments forwarded to `coinpay`.
@@ -450,6 +456,24 @@ struct DmCli {
     cmd: ChatCmd,
 }
 
+#[derive(Subcommand, Debug)]
+enum CrawlCmd {
+    /// Fetch one URL from a worker and print the result JSON
+    /// (`{v, ok, output: {url, status, headers, body}}`).
+    Fetch {
+        url: String,
+        /// Highest price in USD you will pay for the fetch.
+        #[arg(long, default_value_t = 0.01)]
+        max_price: f64,
+        /// Skip the robots.txt check (only for a site you own).
+        #[arg(long)]
+        ignore_robots: bool,
+        /// Give up after this many seconds.
+        #[arg(long, default_value_t = 60)]
+        timeout_secs: u64,
+    },
+}
+
 #[derive(Subcommand, Debug)]
 enum JobsCmd {
     /// Serve POST /v1/jobs as a P2P buyer bridge (meshhook workflow steps).
@@ -730,6 +754,7 @@ async fn run_app(cli: Cli) -> Result<()> {
             start_auto_update_poller(cfg.update_auto);
             run_jobs(cmd).await
         }
+        Cmd::Crawl { cmd } => run_crawl(cmd).await,
         Cmd::Dm { cmd } => run_chat(cmd),
         // The old secure-chat forms (`c0mpute chat keygen|send|...`) keep working.
         Cmd::Chat { args } if args.first().is_some_and(|a| SECURE_CHAT_CMDS.contains(&a.as_str())) => {
@@ -979,11 +1004,25 @@ async fn run_worker(cmd: WorkerCmd, config_path: &std::path::Path) -> Result<()>
             if let Some(rs) = roles {
                 cfg.roles = rs.iter().filter_map(|s| parse_role(s)).collect();
             } else {
-                for role in [Role::Tts, Role::Stt, Role::WorkflowStep, Role::Diffusion] {
+                for role in [
+                    Role::Storage,
+                    Role::Tts,
+                    Role::Stt,
+                    Role::WorkflowStep,
+                    Role::Diffusion,
+                    Role::Crawl,
+                ] {
                     if !cfg.roles.contains(&role) {
                         cfg.roles.push(role);
                     }
                 }
+                // Transcoding needs nothing but ffmpeg: a node that has it
+                // serves it, CPU encoders included, without `--gpu`.
+                if c0mpute_core::supervisor::which_ffmpeg().is_some()
+                    && !cfg.roles.contains(&Role::Transcode)
+                {
+                    cfg.roles.push(Role::Transcode);
+                }
             }
             if gpu && !cfg.roles.contains(&Role::Transcode) {
                 cfg.roles.push(Role::Transcode);
@@ -1654,7 +1693,7 @@ async fn run_transcode(cmd: TranscodeCmd) -> Result<()> {
             // Boot a buyer-mode libp2p node — this CLI invocation is
             // ephemeral, no roles, no advertise.
             let cfg = Config::default();
-            let sup = Supervisor::boot(cfg).await?;
+            let sup = Supervisor::boot_buyer(cfg).await?;
             let net = sup.libp2p.clone();
             // Tiny grace period so peer discovery (mDNS) sees us.
             tokio::time::sleep(std::time::Duration::from_secs(2)).await;
@@ -1934,6 +1973,29 @@ async fn run_speech(cmd: SpeechCmd) -> Result<()> {
     }
 }
 
+async fn run_crawl(cmd: CrawlCmd) -> Result<()> {
+    match cmd {
+        CrawlCmd::Fetch {
+            url,
+            max_price,
+            ignore_robots,
+            timeout_secs,
+        } => {
+            let spec = serde_json::json!({ "v": 1, "url": url, "ignore_robots": ignore_robots });
+            c0mpute_core::crawl::parse_spec(&spec).map_err(|e| anyhow::anyhow!(e))?;
+            let result = c0mpute_core::jobs_gateway::submit_once(
+                c0mpute_core::crawl::WORKLOAD,
+                spec,
+                max_price,
+                std::time::Duration::from_secs(timeout_secs.clamp(5, 300)),
+            )
+            .await?;
+            println!("{}", serde_json::to_string_pretty(&result)?);
+            Ok(())
+        }
+    }
+}
+
 async fn run_jobs(cmd: JobsCmd) -> Result<()> {
     match cmd {
         JobsCmd::Serve {
@@ -2318,6 +2380,7 @@ fn parse_role(s: &str) -> Option<Role> {
         "workflow-step" | "workflow_step" | "workflow" => Some(Role::WorkflowStep),
         "video" => Some(Role::Video),
         "diffusion" | "image" | "images" => Some(Role::Diffusion),
+        "crawl" | "fetch" => Some(Role::Crawl),
         other => {
             eprintln!("warning: unknown role '{other}' ignored");
             None
diff --git a/node/crates/c0mpute-core/src/capabilities.rs b/node/crates/c0mpute-core/src/capabilities.rs
index 6c3a9954..ef77f4f0 100644
--- a/node/crates/c0mpute-core/src/capabilities.rs
+++ b/node/crates/c0mpute-core/src/capabilities.rs
@@ -89,6 +89,7 @@ pub fn role_tags(config: &Config) -> Vec<String> {
             Role::Gateway => tags.push("c0mpute:role:gateway".to_string()),
             Role::Verifier => tags.push("c0mpute:role:verifier".to_string()),
             Role::WorkflowStep => tags.push(crate::workflow::ROLE_TAG.to_string()),
+            Role::Crawl => tags.push(crate::crawl::ROLE_TAG.to_string()),
             Role::Video => {
                 // Same rule as TTS: advertise only what this box can do now.
                 // A node without the GPU, the runtime or the image would win
@@ -191,6 +192,14 @@ pub fn hardware_blob(config: &Config) -> serde_json::Value {
         blob["name"] = serde_json::Value::String(name);
     }
     blob["pricing"] = config.pricing.listing();
+    if config.roles.contains(&c0mpute_proto::Role::Storage) {
+        let cap = crate::opendisk::capacity(&config.storage, 0);
+        blob["storage"] = serde_json::json!({
+            "free_bytes": cap.free_bytes,
+            "total_bytes": cap.total_bytes,
+            "per_gib_month": crate::opendisk::price(&config.storage),
+        });
+    }
     blob
 }
 
diff --git a/node/crates/c0mpute-core/src/config.rs b/node/crates/c0mpute-core/src/config.rs
index dd7b5f41..aef8e6c4 100644
--- a/node/crates/c0mpute-core/src/config.rs
+++ b/node/crates/c0mpute-core/src/config.rs
@@ -175,6 +175,7 @@ impl Default for Config {
                 Role::Stt,
                 Role::WorkflowStep,
                 Role::Diffusion,
+                Role::Crawl,
             ],
             update_channel: default_update_channel(),
             update_auto: default_auto_update(),
@@ -208,6 +209,30 @@ impl Default for ApiConfig {
 pub struct StorageConfig {
     pub root: PathBuf,
     pub cap_bytes: Option<u64>,
+    /// The price this node asks to hold data, per GiB-month in USD. Published
+    /// in its OpenDisk descriptor (`/.well-known/opendisk.json`).
+    #[serde(default = "default_storage_price")]
+    pub price_usd_per_gib_month: f64,
+    /// Hex ed25519 public keys allowed to write to this node's storage API,
+    /// besides the node's own identity. Reads are open (a blake3 hash is the
+    /// capability); writes are signed so a stranger cannot fill the disk.
+    #[serde(default)]
+    pub trusted_writers: Vec<String>,
+    /// Serve `/.well-known/opendisk.json` and list this disk on d1sks when
+    /// the gateway announces a public https origin. On by default.
+    #[serde(default = "default_true")]
+    pub opendisk: bool,
+    /// The OpenDisk marketplace this node registers with.
+    #[serde(default = "default_d1sks_url")]
+    pub d1sks_url: String,
+}
+
+fn default_storage_price() -> f64 {
+    crate::opendisk::DEFAULT_PRICE_USD_PER_GIB_MONTH
+}
+
+fn default_d1sks_url() -> String {
+    crate::opendisk::DEFAULT_D1SKS_URL.to_string()
 }
 
 impl Default for StorageConfig {
@@ -215,6 +240,10 @@ impl Default for StorageConfig {
         Self {
             root: data_dir().unwrap_or_else(|| PathBuf::from("./c0mpute-data")),
             cap_bytes: None,
+            price_usd_per_gib_month: default_storage_price(),
+            trusted_writers: Vec::new(),
+            opendisk: true,
+            d1sks_url: default_d1sks_url(),
         }
     }
 }
diff --git a/node/crates/c0mpute-core/src/crawl.rs b/node/crates/c0mpute-core/src/crawl.rs
new file mode 100644
index 00000000..bdc9952c
--- /dev/null
+++ b/node/crates/c0mpute-core/src/crawl.rs
@@ -0,0 +1,319 @@
+//! `crawl.fetch`: fetch one public web page for a buyer, from a worker's
+//! own connection. Static fetches only (no JS rendering).
+//!
+//! The HTTP side is the guarded client `workflow.step` already uses: public
+//! addresses only (re-checked on every redirect), capped body, wall-clock
+//! timeout, no hop-by-hop or credential headers. On top of that a crawl
+//! honours the site's robots.txt unless the buyer says it owns the site.
+
+use std::collections::BTreeMap;
+use std::net::IpAddr;
+use std::sync::Arc;
+use std::time::Instant;
+
+use anyhow::{Context, Result};
+use c0mpute_net::topics::JobStatus;
+use c0mpute_net::{Libp2pNetwork, Network};
+use c0mpute_store::ChunkStore;
+use serde::Deserialize;
+use serde_json::{Value, json};
+use tokio::sync::mpsc;
+use tracing::{info, warn};
+
+use crate::net_guard;
+use crate::runner::{AcceptedJob, WorkerLoad, publish_receipt};
+use crate::workflow::{self, HttpCallConfig};
+
+pub const WORKLOAD: &str = "crawl.fetch";
+/// Capability tag: this node fetches pages for buyers.
+pub const ROLE_TAG: &str = "c0mpute:role:crawl";
+/// User agent robots.txt rules are matched against (besides `*`).
+pub const ROBOTS_AGENT: &str = "c0mpute";
+/// Concurrent fetches per node. Network-bound, so its own slots.
+pub const MAX_CONCURRENT_FETCHES: usize = 8;
+
+/// What a buyer asks for.
+#[derive(Debug, Clone, Deserialize)]
+pub struct FetchSpec {
+    pub v: u32,
+    pub url: String,
+    #[serde(default)]
+    pub headers: BTreeMap<String, String>,
+    #[serde(default)]
+    pub timeout_ms: Option<u64>,
+    /// Skip the robots.txt check. For a buyer fetching its own site.
+    #[serde(default)]
+    pub ignore_robots: bool,
+}
+
+pub fn parse_spec(spec: &Value) -> std::result::Result<FetchSpec, String> {
+    let s: FetchSpec =
+        serde_json::from_value(spec.clone()).map_err(|e| format!("invalid crawl.fetch spec: {e}"))?;
+    if s.v != 1 {
+        return Err(format!("unsupported crawl.fetch spec version {}", s.v));
+    }
+    let url = reqwest::Url::parse(&s.url).map_err(|e| format!("invalid url: {e}"))?;
+    if !matches!(url.scheme(), "http" | "https") {
+        return Err("url must be http or https".into());
+    }
+    Ok(s)
+}
+
+/// Run a fetch and return the result blob.
+pub async fn execute(spec: &Value) -> Value {
+    execute_with(spec, net_guard::is_public_ip).await
+}
+
+pub async fn execute_with(spec: &Value, allow: fn(IpAddr) -> bool) -> Value {
+    let started = Instant::now();
+    let outcome = run(spec, allow).await;
+    let duration_ms = started.elapsed().as_millis() as u64;
+    let blob = match outcome {
+        Ok(page) => json!({ "v": 1, "ok": true, "output": page, "duration_ms": duration_ms }),
+        Err(error) => json!({ "v": 1, "ok": false, "error": error, "duration_ms": duration_ms }),
+    };
+    let size = serde_json::to_vec(&blob).map(|b| b.len()).unwrap_or(usize::MAX);
+    if size > workflow::MAX_RESULT_BYTES {
+        return json!({
+            "v": 1,
+            "ok": false,
+            "error": format!("result is over the {}-byte limit", workflow::MAX_RESULT_BYTES),
+            "duration_ms": duration_ms,
+        });
+    }
+    blob
+}
+
+async fn run(spec: &Value, allow: fn(IpAddr) -> bool) -> std::result::Result<Value, String> {
+    let spec = parse_spec(spec)?;
+    let url = reqwest::Url::parse(&spec.url).map_err(|e| e.to_string())?;
+    if !spec.ignore_robots && !robots_allows(&url, allow).await {
+        return Err(format!("robots.txt disallows {}", url.path()));
+    }
+    let page = workflow::http_call(
+        HttpCallConfig {
+            url: spec.url.clone(),
+            method: "GET".into(),
+            headers: spec.headers,
+            body: None,
+            timeout_ms: spec.timeout_ms,
+        },
+        allow,
+    )
+    .await
+    .map_err(|e| format!("{e:#}"))?;
+    let mut page = page;
+    page["url"] = Value::String(spec.url);
+    Ok(page)
+}
+
+/// Fetch and apply the site's robots.txt. A missing or unreadable file
+/// allows everything, as the robots convention says.
+async fn robots_allows(url: &reqwest::Url, allow: fn(IpAddr) -> bool) -> bool {
+    let Ok(robots_url) = url.join("/robots.txt") else {
+        return true;
+    };
+    let res = workflow::http_call(
+        HttpCallConfig {
+            url: robots_url.to_string(),
+            method: "GET".into(),
+            headers: BTreeMap::new(),
+            body: None,
+            timeout_ms: Some(5_000),
+        },
+        allow,
+    )
+    .await;
+    let Ok(res) = res else { return true };
+    if res["status"].as_u64() != Some(200) {
+        return true;
+    }
+    let text = res["body"].as_str().unwrap_or("");
+    let path = match url.query() {
+        Some(q) => format!("{}?{q}", url.path()),
+        None => url.path().to_string(),
+    };
+    robots_permits(text, ROBOTS_AGENT, &path)
+}
+
+/// Longest-match robots.txt evaluation for `agent` (falling back to `*`).
+/// `Allow` wins a tie, as Google and RFC 9309 specify.
+pub fn robots_permits(robots: &str, agent: &str, path: &str) -> bool {
+    let agent = agent.to_ascii_lowercase();
+    // (agents in this group, rules)
+    let mut groups: Vec<(Vec<String>, Vec<(bool, String)>)> = Vec::new();
+    let mut in_rules = false;
+    for raw in robots.lines() {
+        let line = raw.split('#').next().unwrap_or("").trim();
+        let Some((key, value)) = line.split_once(':') else {
+            continue;
+        };
+        let key = key.trim().to_ascii_lowercase();
+        let value = value.trim().to_string();
+        match key.as_str() {
+            "user-agent" => {
+                if in_rules || groups.is_empty() {
+                    groups.push((Vec::new(), Vec::new()));
+                    in_rules = false;
+                }
+                if let Some(g) = groups.last_mut() {
+                    g.0.push(value.to_ascii_lowercase());
+                }
+            }
+            "allow" | "disallow" => {
+                in_rules = true;
+                if let Some(g) = groups.last_mut() {
+                    g.1.push((key == "allow", value));
+                }
+            }
+            _ => {}
+        }
+    }
+    let specific: Vec<&(bool, String)> = groups
+        .iter()
+        .filter(|(agents, _)| agents.iter().any(|a| a != "*" && agent.contains(a.as_str())))
+        .flat_map(|(_, rules)| rules)
+        .collect();
+    let rules = if specific.is_empty() {
+        groups
+            .iter()
+            .filter(|(agents, _)| agents.iter().any(|a| a == "*"))
+            .flat_map(|(_, rules)| rules)
+            .collect()
+    } else {
+        specific
+    };
+    let mut best: Option<(usize, bool)> = None;
+    for (is_allow, pattern) in rules {
+        if pattern.is_empty() {
+            continue; // "Disallow:" with no value allows everything
+        }
+        if let Some(len) = pattern_match(pattern, path) {
+            let better = match best {
+                None => true,
+                Some((l, a)) => len > l || (len == l && *is_allow && !a),
+            };
+            if better {
+                best = Some((len, *is_allow));
+            }
+        }
+    }
+    best.map(|(_, allow)| allow).unwrap_or(true)
+}
+
+/// Match a robots pattern (`*` wildcard, trailing `$` anchor) against the
+/// start of `path`; returns the pattern length on a match.
+fn pattern_match(pattern: &str, path: &str) -> Option<usize> {
+    let (pat, anchored) = match pattern.strip_suffix('$') {
+        Some(p) => (p, true),
+        None => (pattern, false),
+    };
+    let parts: Vec<&str> = pat.split('*').collect();
+    let mut pos = 0usize;
+    for (i, part) in parts.iter().enumerate() {
+        if i == 0 {
+            if !path.starts_with(part) {
+                return None;
+            }
+            pos = part.len();
+        } else if part.is_empty() {
+            continue;
+        } else {
+            let found = path[pos..].find(part)?;
+            pos += found + part.len();
+        }
+    }
+    if anchored {
+        let ends_ok = if pat.ends_with('*') { true } else { pos == path.len() };
+        if !ends_ok {
+            return None;
+        }
+    }
+    Some(pattern.len())
+}
+
+// ─── worker runner ────────────────────────────────────────────────────────
+
+pub fn worker_load() -> WorkerLoad {
+    WorkerLoad::new(
+        Arc::new(tokio::sync::Semaphore::new(MAX_CONCURRENT_FETCHES)),
+        MAX_CONCURRENT_FETCHES,
+    )
+}
+
+pub fn spawn_crawl_runner(
+    net: Arc<Libp2pNetwork>,
+    store: ChunkStore,
+    load: WorkerLoad,
+) -> mpsc::Sender<AcceptedJob> {
+    let (tx, mut rx) = mpsc::channel::<AcceptedJob>(MAX_CONCURRENT_FETCHES);
+    tokio::spawn(async move {
+        while let Some(job) = rx.recv().await {
+            let Ok(slot) = load.compute_slots().acquire_owned().await else {
+                return;
+            };
+            let net = net.clone();
+            let store = store.clone();
+            let load = load.clone();
+            tokio::spawn(async move {
+                let _slot = slot;
+                let started = Instant::now();
+                let job_id = job.accept.job_id.clone();
+                match run_fetch_job(&net, &store, &job).await {
+                    Ok(hash) => {
+                        load.record_job(started.elapsed());
+                        info!(%job_id, %hash, "crawl runner: fetch complete");
+                        publish_receipt(&net, &job.accept, Some(hash), JobStatus::Completed).await;
+                    }
+                    Err(error) => {
+                        warn!(%job_id, err = %error, "crawl runner: fetch failed");
+                        publish_receipt(&net, &job.accept, None, JobStatus::Failed).await;
+                    }
+                }
+            });
+        }
+    });
+    tx
+}
+
+async fn run_fetch_job(net: &Libp2pNetwork, store: &ChunkStore, job: &AcceptedJob) -> Result<String> {
+    let spec = workflow::resolve_spec(net, job).await?;
+    let result = execute(&spec).await;
+    let bytes = serde_json::to_vec(&result)?;
+    let hash = store.put(&bytes).await.context("store crawl result")?;
+    net.announce(&hash).await.context("announce crawl result")?;
+    Ok(hash.to_hex())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn spec_validation() {
+        assert!(parse_spec(&json!({"v":1,"url":"https://example.com/"})).is_ok());
+        assert!(parse_spec(&json!({"v":2,"url":"https://example.com/"})).unwrap_err().contains("version"));
+        assert!(parse_spec(&json!({"v":1,"url":"ftp://example.com/"})).unwrap_err().contains("http"));
+        assert!(parse_spec(&json!({"v":1})).is_err());
+    }
+
+    #[test]
+    fn robots_rules() {
+        let robots = "User-agent: *\nDisallow: /private\nAllow: /private/ok\n\nUser-agent: badbot\nDisallow: /\n";
+        assert!(robots_permits(robots, ROBOTS_AGENT, "/"));
+        assert!(!robots_permits(robots, ROBOTS_AGENT, "/private/x"));
+        assert!(robots_permits(robots, ROBOTS_AGENT, "/private/ok/y"));
+        assert!(!robots_permits(robots, "badbot", "/anything"));
+        assert!(robots_permits("User-agent: *\nDisallow:\n", ROBOTS_AGENT, "/x"));
+        assert!(!robots_permits("User-agent: c0mpute\nDisallow: /\n", ROBOTS_AGENT, "/x"));
+        assert!(!robots_permits("User-agent: *\nDisallow: /*.pdf$\n", ROBOTS_AGENT, "/a/b.pdf"));
+        assert!(robots_permits("User-agent: *\nDisallow: /*.pdf$\n", ROBOTS_AGENT, "/a/b.pdf?x"));
+        assert!(robots_permits("", ROBOTS_AGENT, "/x"));
+    }
+
+    #[tokio::test]
+    async fn refuses_private_addresses() {
+        let r = execute(&json!({"v":1,"url":"http://127.0.0.1:1/","ignore_robots":true})).await;
+        assert_eq!(r["ok"], false, "{r}");
+    }
+}
diff --git a/node/crates/c0mpute-core/src/dispatch.rs b/node/crates/c0mpute-core/src/dispatch.rs
index 742c6a1a..51783ba9 100644
--- a/node/crates/c0mpute-core/src/dispatch.rs
+++ b/node/crates/c0mpute-core/src/dispatch.rs
@@ -542,6 +542,9 @@ pub fn workload_types_from_roles(roles: &[c0mpute_proto::Role]) -> Vec<String> {
     if roles.contains(&c0mpute_proto::Role::Diffusion) {
         types.push(crate::diffusion::WORKLOAD_TXT2IMG.to_string());
     }
+    if roles.contains(&c0mpute_proto::Role::Crawl) {
+        types.push(crate::crawl::WORKLOAD.to_string());
+    }
     types
 }
 
diff --git a/node/crates/c0mpute-core/src/jobs_gateway.rs b/node/crates/c0mpute-core/src/jobs_gateway.rs
index 9688250a..f946221a 100644
--- a/node/crates/c0mpute-core/src/jobs_gateway.rs
+++ b/node/crates/c0mpute-core/src/jobs_gateway.rs
@@ -48,10 +48,11 @@ const MAX_ALLOW_PEERS: usize = 64;
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 enum Workload {
     WorkflowStep,
+    CrawlFetch,
 }
 
 impl Workload {
-    const ALL: &'static [Workload] = &[Workload::WorkflowStep];
+    const ALL: &'static [Workload] = &[Workload::WorkflowStep, Workload::CrawlFetch];
 
     fn parse(name: &str) -> Option<Self> {
         Self::ALL.iter().copied().find(|w| w.name() == name)
@@ -59,21 +60,23 @@ impl Workload {
     fn name(self) -> &'static str {
         match self {
             Workload::WorkflowStep => workflow::WORKLOAD,
+            Workload::CrawlFetch => crate::crawl::WORKLOAD,
         }
     }
     fn required_capabilities(self) -> Vec<String> {
         match self {
             Workload::WorkflowStep => vec![workflow::ROLE_TAG.to_string()],
+            Workload::CrawlFetch => vec![crate::crawl::ROLE_TAG.to_string()],
         }
     }
     fn max_result_bytes(self) -> usize {
         match self {
-            Workload::WorkflowStep => workflow::MAX_RESULT_BYTES,
+            Workload::WorkflowStep | Workload::CrawlFetch => workflow::MAX_RESULT_BYTES,
         }
     }
     fn valid_result(self, value: &Value) -> bool {
         match self {
-            Workload::WorkflowStep => {
+            Workload::WorkflowStep | Workload::CrawlFetch => {
                 value.get("v").and_then(Value::as_u64) == Some(1)
                     && value.get("ok").is_some_and(Value::is_boolean)
             }
@@ -125,6 +128,36 @@ impl JobsBridge {
         self.bid_window = window;
         self
     }
+
+    /// Run one job without the HTTP layer (for one-shot CLI submits such as
+    /// `c0mpute crawl fetch`). Returns the same body `POST /v1/jobs` would.
+    pub async fn submit_once(&self, workload: &str, spec: Value, timeout: Duration) -> Result<Value> {
+        let w = Workload::parse(workload)
+            .with_context(|| format!("unsupported workload {workload:?}"))?;
+        let spec_bytes = serde_json::to_vec(&spec)?;
+        run_job(
+            self,
+            w,
+            spec,
+            spec_bytes,
+            self.max_price_usd,
+            (*self.allow_peers).clone(),
+            timeout,
+        )
+        .await
+        .map_err(|ApiError(status, body)| anyhow::anyhow!("{status}: {body}"))
+    }
+}
+
+/// Boot a buyer and run one job: what `c0mpute crawl fetch` uses.
+pub async fn submit_once(workload: &str, spec: Value, max_price_usd: f64, timeout: Duration) -> Result<Value> {
+    let supervisor = Supervisor::boot_buyer(Config::default()).await?;
+    // Any token: the HTTP layer is not mounted.
+    let token: String = std::iter::repeat_n('x', 32).collect();
+    let bridge = JobsBridge::new(supervisor.libp2p, supervisor.store, token, max_price_usd, Vec::new())?;
+    // Give the swarm a moment to reach peers before the auction.
+    tokio::time::sleep(Duration::from_secs(5)).await;
+    bridge.submit_once(workload, spec, timeout).await
 }
 
 /// Parse `C0MPUTE_JOBS_ALLOW_PEERS` (comma-separated peer ids).
@@ -157,7 +190,7 @@ pub async fn serve(
     if token.len() < 24 || token.len() > 256 {
         bail!("C0MPUTE_JOBS_TOKEN must be between 24 and 256 characters");
     }
-    let supervisor = Supervisor::boot(Config::default()).await?;
+    let supervisor = Supervisor::boot_buyer(Config::default()).await?;
     let state = JobsBridge::new(
         supervisor.libp2p,
         supervisor.store,
diff --git a/node/crates/c0mpute-core/src/lib.rs b/node/crates/c0mpute-core/src/lib.rs
index 73e4be7d..f2378b16 100644
--- a/node/crates/c0mpute-core/src/lib.rs
+++ b/node/crates/c0mpute-core/src/lib.rs
@@ -7,11 +7,13 @@
 pub mod buyer;
 pub mod capabilities;
 pub mod config;
+pub mod crawl;
 pub mod diffusion;
 pub mod dispatch;
 pub(crate) mod gateway_util;
 pub mod jobs_gateway;
 pub mod net_guard;
+pub mod opendisk;
 pub mod pricing;
 pub mod reachability;
 pub mod private;
diff --git a/node/crates/c0mpute-core/src/opendisk.rs b/node/crates/c0mpute-core/src/opendisk.rs
new file mode 100644
index 00000000..8bf5e79a
--- /dev/null
+++ b/node/crates/c0mpute-core/src/opendisk.rs
@@ -0,0 +1,306 @@
+//! OpenDisk: every storage node describes its own disk at
+//! `/.well-known/opendisk.json` on its gateway, and lists itself on an OpenDisk
+//! marketplace (d1sks) when it has a public https origin.
+//!
+//! There is no central registry in this path. A node states its own name,
+//! identity key, free space and price; the marketplace only reads what the
+//! node serves, and re-reads it every hour. A node behind NAT still serves the
+//! descriptor locally, it just has no origin a marketplace can reach yet.
+
+use std::path::Path;
+use std::time::Duration;
+
+use serde_json::{Value, json};
+use tracing::{info, warn};
+
+use crate::config::{Config, StorageConfig};
+
+/// What a node asks per GiB-month when the operator has not set a price.
+/// Below the big object stores, since the data is erasure-coded across peers.
+pub const DEFAULT_PRICE_USD_PER_GIB_MONTH: f64 = 0.004;
+
+/// The OpenDisk marketplace nodes list themselves on.
+pub const DEFAULT_D1SKS_URL: &str = "https://d1sks.pwa.pit.world";
+
+/// The descriptor path the OpenDisk spec fixes.
+pub const WELL_KNOWN_PATH: &str = "/.well-known/opendisk.json";
+
+/// How often a node re-submits itself, so a marketplace that lost it (or a
+/// node whose origin changed) catches up without anyone stepping in.
+pub const REREGISTER_EVERY: Duration = Duration::from_secs(24 * 60 * 60);
+
+const GIB: f64 = 1024.0 * 1024.0 * 1024.0;
+
+/// Free and total bytes this node offers for storage.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Capacity {
+    pub free_bytes: u64,
+    pub total_bytes: u64,
+}
+
+/// The filesystem under `root`: (available, total). Picks the deepest mount
+/// that contains the root; falls back to the largest disk.
+fn disk_for(root: &Path) -> (u64, u64) {
+    let disks = sysinfo::Disks::new_with_refreshed_list();
+    let mut best: Option<(usize, u64, u64)> = None;
+    let mut largest = (0u64, 0u64);
+    for disk in disks.list() {
+        if disk.total_space() > largest.1 {
+            largest = (disk.available_space(), disk.total_space());
+        }
+        let mount = disk.mount_point();
+        if root.starts_with(mount) {
+            let depth = mount.components().count();
+            if best.is_none_or(|(d, _, _)| depth > d) {
+                best = Some((depth, disk.available_space(), disk.total_space()));
+            }
+        }
+    }
+    best.map(|(_, free, total)| (free, total)).unwrap_or(largest)
+}
+
+/// What this node offers: the operator's cap when set (minus what is already
+/// held), never more than the disk really has free.
+pub fn capacity(storage: &StorageConfig, used_bytes: u64) -> Capacity {
+    let (disk_free, disk_total) = disk_for(&storage.root);
+    offered(storage.cap_bytes, used_bytes, disk_free, disk_total)
+}
+
+fn offered(cap: Option<u64>, used: u64, disk_free: u64, disk_total: u64) -> Capacity {
+    match cap {
+        Some(cap) => Capacity {
+            free_bytes: cap.saturating_sub(used).min(disk_free),
+            total_bytes: cap,
+        },
+        None => Capacity {
+            free_bytes: disk_free,
+            total_bytes: disk_total,
+        },
+    }
+}
+
+fn gib(bytes: u64) -> f64 {
+    // Two decimals is plenty for a listing and keeps the JSON stable.
+    ((bytes as f64 / GIB) * 100.0).floor() / 100.0
+}
+
+/// The price to publish: the operator's, or the default when it is not a
+/// usable number.
+pub fn price(storage: &StorageConfig) -> f64 {
+    let p = storage.price_usd_per_gib_month;
+    if p.is_finite() && p >= 0.0 {
+        p
+    } else {
+        DEFAULT_PRICE_USD_PER_GIB_MONTH
+    }
+}
+
+/// The OpenDisk 0.1 descriptor for this node.
+///
+/// `key_hex` is the node's ed25519 identity (from its peer id); `origin` is the
+/// public origin the gateway announces, if any.
+pub fn descriptor(
+    config: &Config,
+    peer_id: &str,
+    key_hex: Option<&str>,
+    origin: Option<&str>,
+    cap: Capacity,
+) -> Value {
+    let short: String = peer_id
+        .chars()
+        .rev()
+        .take(8)
+        .collect::<Vec<_>>()
+        .into_iter()
+        .rev()
+        .collect();
+    let name = match crate::capabilities::node_name() {
+        Some(n) => format!("{n} · c0mpute node {short}"),
+        None => format!("c0mpute node {short}"),
+    };
+    let mut doc = json!({
+        "opendisk": "0.1",
+        "name": name,
+        "web": "https://c0mpute.com/nodes",
+        "capacity": {
+            "free_gib": gib(cap.free_bytes),
+            "total_gib": gib(cap.total_bytes),
+        },
+        "price": {
+            "currency": "USD",
+            "per_gib_month": price(&config.storage),
+        },
+        "accepts": {
+            "visibility": ["public", "private"],
+            "encrypted_only": false,
+        },
+        "updated": chrono_now(),
+        // Unknown to OpenDisk, kept by readers: how to reach this disk on
+        // the c0mpute network itself.
+        "c0mpute": {
+            "peer_id": peer_id,
+            "version": env!("CARGO_PKG_VERSION"),
+            "storage_api": origin.map(|o| format!("{}/storage/v1", o.trim_end_matches('/'))),
+            "redundancy": "reed-solomon 10/14",
+        },
+    });
+    if let Some(k) = key_hex {
+        doc["key"] = Value::String(format!("ed25519:{k}"));
+    }
+    doc
+}
+
+fn chrono_now() -> String {
+    let secs = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .map(|d| d.as_secs())
+        .unwrap_or(0);
+    let days = secs / 86_400;
+    let rem = secs % 86_400;
+    let (y, m, d) = civil_from_days(days as i64);
+    format!(
+        "{y:04}-{m:02}-{d:02}T{:02}:{:02}:{:02}Z",
+        rem / 3600,
+        (rem % 3600) / 60,
+        rem % 60
+    )
+}
+
+/// Days since 1970-01-01 to a civil date (Howard Hinnant's algorithm).
+fn civil_from_days(z: i64) -> (i64, u32, u32) {
+    let z = z + 719_468;
+    let era = z.div_euclid(146_097);
+    let doe = z.rem_euclid(146_097);
+    let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365;
+    let y = yoe + era * 400;
+    let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
+    let mp = (5 * doy + 2) / 153;
+    let d = (doy - (153 * mp + 2) / 5 + 1) as u32;
+    let m = if mp < 10 { mp + 3 } else { mp - 9 } as u32;
+    (if m <= 2 { y + 1 } else { y }, m, d)
+}
+
+/// The origin a marketplace can fetch from: the gateway's announced address,
+/// only when it is https (OpenDisk readers fetch https only).
+pub fn public_origin(config: &Config) -> Option<String> {
+    let announce = config.gateway.announce.as_deref()?.trim();
+    let url = reqwest::Url::parse(announce).ok()?;
+    if url.scheme() != "https" || url.host_str().is_none() {
+        return None;
+    }
+    Some(url.origin().ascii_serialization())
+}
+
+/// Submit `origin` to the marketplace. Returns the marketplace's answer.
+pub async fn register(d1sks_url: &str, origin: &str) -> anyhow::Result<Value> {
+    let client = reqwest::Client::builder()
+        .timeout(Duration::from_secs(20))
+        .user_agent(concat!("c0mpute/", env!("CARGO_PKG_VERSION")))
+        .build()?;
+    let res = client
+        .post(format!("{}/api/v1/disks", d1sks_url.trim_end_matches('/')))
+        .json(&json!({ "url": origin }))
+        .send()
+        .await?;
+    let status = res.status();
+    let body: Value = res.json().await.unwrap_or(Value::Null);
+    if !status.is_success() {
+        anyhow::bail!("d1sks answered {status}: {body}");
+    }
+    Ok(body)
+}
+
+/// Keep this node listed: register now, then once a day. A no-op when the
+/// operator turned OpenDisk off or the gateway has no public https origin.
+pub fn spawn_self_listing(config: &Config) {
+    if !config.storage.opendisk {
+        return;
+    }
+    if config.private.enabled {
+        info!("opendisk: private mode, not listing this disk on d1sks");
+        return;
+    }
+    let Some(origin) = public_origin(config) else {
+        info!(
+            "opendisk: descriptor served at {WELL_KNOWN_PATH}; not listing on d1sks \
+             (set gateway.announce to this node's public https origin to list it)"
+        );
+        return;
+    };
+    let market = config.storage.d1sks_url.clone();
+    tokio::spawn(async move {
+        // Let the gateway bind before the marketplace fetches from it.
+        tokio::time::sleep(Duration::from_secs(15)).await;
+        loop {
+            match register(&market, &origin).await {
+                Ok(_) => info!(%origin, %market, "opendisk: listed on d1sks"),
+                Err(e) => warn!(%origin, %market, err = %e, "opendisk: d1sks listing failed"),
+            }
+            tokio::time::sleep(REREGISTER_EVERY).await;
+        }
+    });
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const G: u64 = 1024 * 1024 * 1024;
+
+    #[test]
+    fn uncapped_offers_the_disk() {
+        let c = offered(None, 5 * G, 100 * G, 500 * G);
+        assert_eq!(c.free_bytes, 100 * G);
+        assert_eq!(c.total_bytes, 500 * G);
+    }
+
+    #[test]
+    fn cap_limits_free_space_and_counts_what_is_held() {
+        let c = offered(Some(50 * G), 20 * G, 400 * G, 500 * G);
+        assert_eq!(c.free_bytes, 30 * G);
+        assert_eq!(c.total_bytes, 50 * G);
+    }
+
+    #[test]
+    fn never_offers_more_than_the_disk_has() {
+        let c = offered(Some(50 * G), 0, 10 * G, 500 * G);
+        assert_eq!(c.free_bytes, 10 * G);
+    }
+
+    #[test]
+    fn descriptor_is_valid_opendisk() {
+        let cfg = Config::default();
+        let key = "a".repeat(64);
+        let d = descriptor(
+            &cfg,
+            "12D3KooWSFxwveBjrGy4n1Djg3vpQD5aHPCXYCQHZWruffig7P4J",
+            Some(&key),
+            Some("https://disk.example"),
+            Capacity {
+                free_bytes: 900 * G,
+                total_bytes: 1000 * G,
+            },
+        );
+        assert!(d["name"].as_str().unwrap().contains("ffig7P4J"));
+        assert_eq!(d["capacity"]["free_gib"], 900.0);
+        assert_eq!(d["price"]["per_gib_month"], DEFAULT_PRICE_USD_PER_GIB_MONTH);
+        assert_eq!(d["key"], format!("ed25519:{key}"));
+        assert_eq!(d["c0mpute"]["storage_api"], "https://disk.example/storage/v1");
+        assert!(d["updated"].as_str().unwrap().ends_with('Z'));
+    }
+
+    #[test]
+    fn only_https_origins_are_listable() {
+        let mut cfg = Config::default();
+        cfg.gateway.announce = Some("http://1.2.3.4:7777".into());
+        assert_eq!(public_origin(&cfg), None);
+        cfg.gateway.announce = Some("https://disk.example/some/path".into());
+        assert_eq!(public_origin(&cfg).as_deref(), Some("https://disk.example"));
+    }
+
+    #[test]
+    fn civil_dates() {
+        assert_eq!(civil_from_days(0), (1970, 1, 1));
+        assert_eq!(civil_from_days(20_765), (2026, 11, 8));
+    }
+}
diff --git a/node/crates/c0mpute-core/src/runner.rs b/node/crates/c0mpute-core/src/runner.rs
index 47bc56a6..cb690ff2 100644
--- a/node/crates/c0mpute-core/src/runner.rs
+++ b/node/crates/c0mpute-core/src/runner.rs
@@ -573,6 +573,30 @@ pub(crate) fn is_public_ip(ip: std::net::IpAddr) -> bool {
     crate::net_guard::is_public_ip(ip)
 }
 
+/// Before telling a buyer its result is ready, open a connection to the
+/// buyer. A worker behind NAT cannot be dialed, but it can dial out; the
+/// buyer's fetch of the result then uses this connection instead of failing
+/// with "Failed to dial the requested peer". Best effort, bounded to 5 s.
+async fn reach_buyer(net: &Libp2pNetwork, buyer_peer_id: &str) {
+    let Ok(buyer) = buyer_peer_id.parse::<c0mpute_net::PeerId>() else {
+        return;
+    };
+    if net.is_connected(buyer).await {
+        return;
+    }
+    if let Err(e) = net.connect(buyer).await {
+        tracing::debug!(%buyer, err = %e, "could not dial buyer before receipt");
+        return;
+    }
+    let deadline = tokio::time::Instant::now() + std::time::Duration::from_secs(5);
+    while tokio::time::Instant::now() < deadline {
+        if net.is_connected(buyer).await {
+            return;
+        }
+        tokio::time::sleep(std::time::Duration::from_millis(100)).await;
+    }
+}
+
 pub(crate) async fn publish_receipt(
     net: &Libp2pNetwork,
     accept: &JobAccept,
@@ -605,6 +629,10 @@ pub(crate) async fn publish_receipt(
                 }
             }
             tokio::time::sleep(std::time::Duration::from_millis(1500)).await;
+        } else {
+            // The buyer advertised no address: dial it by peer id, using
+            // whatever addresses Kad and identify have learned for it.
+            reach_buyer(net, &accept.buyer_peer_id).await;
         }
     }
     let topic = job_topic(&accept.workload_type);
diff --git a/node/crates/c0mpute-core/src/speech_gateway.rs b/node/crates/c0mpute-core/src/speech_gateway.rs
index c31cc30d..63f09ef5 100644
--- a/node/crates/c0mpute-core/src/speech_gateway.rs
+++ b/node/crates/c0mpute-core/src/speech_gateway.rs
@@ -118,7 +118,7 @@ pub async fn serve(bind: std::net::SocketAddr, token: String, max_price_usd: f64
         bail!("maximum job price must be a non-negative number");
     }
 
-    let supervisor = Supervisor::boot(Config::default()).await?;
+    let supervisor = Supervisor::boot_buyer(Config::default()).await?;
     let state = GatewayState {
         net: supervisor.libp2p,
         store: supervisor.store,
@@ -137,6 +137,7 @@ pub async fn serve(bind: std::net::SocketAddr, token: String, max_price_usd: f64
         .route("/v1/tts", post(synthesize))
         .route("/v1/stt", post(transcribe))
         .route("/v1/images", post(generate_image))
+        .route("/v1/videos", post(generate_video))
         // Warm, pinned sessions: open once per call, then say a sentence at a
         // time with no auction and no model reload in the way.
         .route("/v1/sessions", post(open_session).get(list_sessions))
@@ -445,8 +446,16 @@ async fn run_speech_auction(
         .with_excluded_bidders(excluded_bidders.to_vec())
         .with_max_price_usd(state.max_price_usd)
         .with_bid_window(Duration::from_secs(4))
-        .with_deadline(Duration::from_secs(20 * 60))
-        .with_receipt_timeout(Duration::from_secs(15 * 60));
+        .with_deadline(if is_video(workload) {
+            crate::video::JOB_TIMEOUT + Duration::from_secs(5 * 60)
+        } else {
+            Duration::from_secs(20 * 60)
+        })
+        .with_receipt_timeout(if is_video(workload) {
+            crate::video::JOB_TIMEOUT
+        } else {
+            Duration::from_secs(15 * 60)
+        });
     run_auction(state.net.clone(), auction)
         .await
         .map_err(|error| {
@@ -531,8 +540,13 @@ async fn run_speech_job(
     }))
 }
 
+fn is_video(workload: &str) -> bool {
+    workload == crate::video::WORKLOAD_TXT2VID || workload == crate::video::WORKLOAD_IMG2VID
+}
+
 fn valid_speech_result(workload: &str, bytes: &[u8]) -> bool {
     match workload {
+        w if is_video(w) => crate::video::is_mp4(bytes),
         "tts.synthesize" => bytes.len() >= 44 && &bytes[..4] == b"RIFF" && &bytes[8..12] == b"WAVE",
         crate::diffusion::WORKLOAD_TXT2IMG => crate::diffusion::is_png(bytes),
         "stt.transcribe" => {
@@ -554,7 +568,12 @@ async fn fetch_result(
         hash,
         provider_peer_id,
         max_bytes,
-        Duration::from_secs(20),
+        // A video result can be hundreds of MB; speech and images are small.
+        if max_bytes > MAX_AUDIO_BYTES {
+            Duration::from_secs(10 * 60)
+        } else {
+            Duration::from_secs(20)
+        },
     )
     .await
     {
@@ -754,6 +773,90 @@ fn audio_format(headers: &HeaderMap) -> ApiResult<&'static str> {
 /// `POST /v1/images`: CPU txt2img on a c0mpute worker (`diffusion.txt2img`).
 /// Body: `{prompt, width?, height?, steps?, seed?}` (see `diffusion::Txt2ImgSpec`).
 /// Returns `image/png`. Expect ~90-150 s.
+/// `POST /v1/videos`: a video job (Wan 2.2 / LTX-2.3) as a JSON body of
+/// [`crate::video::VideoJobInline`] fields. Send `image_base64` for
+/// image-to-video; this gateway stores and serves the image to the worker
+/// itself. Answers `video/mp4`.
+#[derive(Debug, Deserialize)]
+struct VideoRequest {
+    #[serde(flatten)]
+    job: crate::video::VideoJobInline,
+    #[serde(default)]
+    image_base64: Option<String>,
+}
+
+async fn generate_video(
+    State(state): State<GatewayState>,
+    headers: HeaderMap,
+    Json(input): Json<VideoRequest>,
+) -> ApiResult<Response> {
+    use base64::Engine;
+    authenticate(&state, &headers)?;
+    let mut job = input.job;
+    let workload = match input.image_base64.as_deref() {
+        Some(b64) => {
+            let bytes = base64::engine::general_purpose::STANDARD
+                .decode(b64.trim())
+                .map_err(|_| ApiError(StatusCode::BAD_REQUEST, "image_base64 is not base64".into()))?;
+            if bytes.is_empty() || bytes.len() > crate::video::MAX_IMAGE_BYTES {
+                return Err(ApiError(
+                    StatusCode::BAD_REQUEST,
+                    "image must be 1 byte to 32 MiB".into(),
+                ));
+            }
+            let hash = state
+                .store
+                .put(&bytes)
+                .await
+                .map_err(|error| gateway_failure(error.into()))?;
+            state
+                .net
+                .announce(&hash)
+                .await
+                .map_err(gateway_failure)?;
+            job.image_hash = Some(hash.to_hex());
+            job.image_provider_peer_id = Some(state.net.peer_id().to_base58());
+            crate::video::WORKLOAD_IMG2VID
+        }
+        None => crate::video::WORKLOAD_TXT2VID,
+    };
+    job.validate(workload)
+        .map_err(|message| ApiError(StatusCode::BAD_REQUEST, message))?;
+    let _slot = state
+        .image_slots
+        .clone()
+        .acquire_owned()
+        .await
+        .map_err(|_| {
+            ApiError(
+                StatusCode::SERVICE_UNAVAILABLE,
+                "video queue is unavailable".into(),
+            )
+        })?;
+    let spec = serde_json::to_value(&job).map_err(|error| gateway_failure(error.into()))?;
+    let (outcome, bytes) = run_speech_job(
+        &state,
+        workload,
+        spec,
+        vec![crate::video::ROLE_TAG.to_string()],
+        crate::video::MAX_RESULT_BYTES,
+    )
+    .await?;
+    let mut response = (StatusCode::OK, bytes).into_response();
+    response
+        .headers_mut()
+        .insert(header::CONTENT_TYPE, HeaderValue::from_static("video/mp4"));
+    response
+        .headers_mut()
+        .insert(header::CACHE_CONTROL, HeaderValue::from_static("no-store"));
+    set_job_headers(
+        response.headers_mut(),
+        &outcome.job_id,
+        &outcome.accepted_bid.bidder_peer_id,
+    );
+    Ok(response)
+}
+
 async fn generate_image(
     State(state): State<GatewayState>,
     headers: HeaderMap,
diff --git a/node/crates/c0mpute-core/src/status_aggregator.rs b/node/crates/c0mpute-core/src/status_aggregator.rs
index 4be2709b..aff09a9f 100644
--- a/node/crates/c0mpute-core/src/status_aggregator.rs
+++ b/node/crates/c0mpute-core/src/status_aggregator.rs
@@ -388,6 +388,9 @@ struct NodeRow {
     /// The operator's listing (`mode`, `min_usd`, `fixed_usd`), if the node
     /// advertises one. Re-validated here: only known fields, sane numbers.
     pricing: Option<serde_json::Value>,
+    /// What the node offers as storage (`free_bytes`, `total_bytes`,
+    /// `per_gib_month`), when it runs the storage role. Numbers only.
+    storage: Option<serde_json::Value>,
     last_seen_s: u64,
 }
 
@@ -494,6 +497,23 @@ fn short_id(peer_id: &str) -> String {
     peer_id[n.saturating_sub(8)..].to_string()
 }
 
+/// The storage offer a node advertises, re-validated: only the three known
+/// fields, finite and non-negative, so a node cannot inject anything else.
+fn storage_offer(hardware: &serde_json::Value) -> Option<serde_json::Value> {
+    let s = hardware.get("storage")?;
+    let free = s.get("free_bytes")?.as_u64()?;
+    let total = s.get("total_bytes")?.as_u64()?;
+    let price = s.get("per_gib_month")?.as_f64()?;
+    if !price.is_finite() || price < 0.0 || price > 1_000.0 {
+        return None;
+    }
+    Some(serde_json::json!({
+        "free_bytes": free.min(total),
+        "total_bytes": total,
+        "per_gib_month": price,
+    }))
+}
+
 fn build_nodes(ads: &[(String, c0mpute_net::topics::CapabilityAd)], now: u64) -> NodesPayload {
     let mut nodes: Vec<NodeRow> = ads
         .iter()
@@ -525,6 +545,7 @@ fn build_nodes(ads: &[(String, c0mpute_net::topics::CapabilityAd)], now: u64) ->
                 .and_then(|v| v.as_str())
                 .and_then(crate::capabilities::sanitize_ref),
             pricing: listing(&ad.hardware),
+            storage: storage_offer(&ad.hardware),
             last_seen_s: now.saturating_sub(ad.published_at_ms) / 1000,
         })
         .collect();
@@ -962,3 +983,23 @@ mod tests {
         assert_eq!(jobs.completed.read().await.len(), 0);
     }
 }
+
+#[cfg(test)]
+mod storage_offer_tests {
+    use super::storage_offer;
+    use serde_json::json;
+
+    #[test]
+    fn keeps_only_sane_numbers() {
+        let hw = json!({"storage": {"free_bytes": 900, "total_bytes": 1000, "per_gib_month": 0.004, "evil": "<script>"}});
+        assert_eq!(
+            storage_offer(&hw),
+            Some(json!({"free_bytes": 900, "total_bytes": 1000, "per_gib_month": 0.004}))
+        );
+        let negative = json!({"storage": {"free_bytes": 1, "total_bytes": 2, "per_gib_month": -1.0}});
+        assert_eq!(storage_offer(&negative), None);
+        assert_eq!(storage_offer(&json!({})), None);
+        let over = json!({"storage": {"free_bytes": 5000, "total_bytes": 1000, "per_gib_month": 0.0}});
+        assert_eq!(storage_offer(&over).unwrap()["free_bytes"], 1000);
+    }
+}
diff --git a/node/crates/c0mpute-core/src/supervisor.rs b/node/crates/c0mpute-core/src/supervisor.rs
index 0c21f711..0045a7e1 100644
--- a/node/crates/c0mpute-core/src/supervisor.rs
+++ b/node/crates/c0mpute-core/src/supervisor.rs
@@ -25,15 +25,34 @@ pub struct Supervisor {
 }
 
 impl Supervisor {
+    /// Boot as this machine's worker: identity at `<config_dir>/identity.key`.
     pub async fn boot(config: Config) -> Result<Self> {
+        let identity_dir = config::config_dir().unwrap_or_else(|| std::path::PathBuf::from("."));
+        Self::boot_with_identity(config, identity_dir).await
+    }
+
+    /// Boot as a buyer (the speech and jobs bridges, one-shot submits) with
+    /// its own identity at `<data_dir>/buyer/identity.key` (where private mode
+    /// already looks for this machine's buyer identities, so a private node
+    /// still trusts its own bridges).
+    ///
+    /// A buyer must not reuse the worker's key: two processes with one peer
+    /// id on the same box make remote peers keep only one connection, and
+    /// the buyer's auctions fail with `NoPeersSubscribedToTopic` while the
+    /// network has plenty of workers on the topic.
+    pub async fn boot_buyer(config: Config) -> Result<Self> {
+        let identity_dir = config::data_dir()
+            .unwrap_or_else(|| std::path::PathBuf::from("."))
+            .join("buyer");
+        std::fs::create_dir_all(&identity_dir)?;
+        Self::boot_with_identity(config, identity_dir).await
+    }
+
+    async fn boot_with_identity(config: Config, identity_dir: std::path::PathBuf) -> Result<Self> {
         std::fs::create_dir_all(&config.storage.root)?;
         let store = ChunkStore::open(&config.storage.root).await?;
 
-        // Real libp2p network. Identity persists at
-        // <config_dir>/identity.key. Bootstrap list is empty for now —
-        // DIP-0010 wires up c0mpute.com/bootstrap.json once we run
-        // public seed nodes.
-        let identity_dir = config::config_dir().unwrap_or_else(|| std::path::PathBuf::from("."));
+        // Real libp2p network. The identity persists in `identity_dir`.
 
         let local_source: Arc<dyn ChunkSource> = Arc::new(StoreSource(store.clone()));
 
@@ -144,6 +163,8 @@ impl Supervisor {
             // workflow.step draws on its own light-work slots instead.
             let load = if workload_type == crate::workflow::WORKLOAD {
                 crate::workflow::worker_load()
+            } else if workload_type == crate::crawl::WORKLOAD {
+                crate::crawl::worker_load()
             } else {
                 runner::WorkerLoad::new(compute_slots.clone(), total_slots)
             };
@@ -244,6 +265,11 @@ impl Supervisor {
                     self.store.clone(),
                     load.clone(),
                 )),
+                crate::crawl::WORKLOAD => Some(crate::crawl::spawn_crawl_runner(
+                    net.clone(),
+                    self.store.clone(),
+                    load.clone(),
+                )),
                 crate::video::WORKLOAD_TXT2VID | crate::video::WORKLOAD_IMG2VID => {
                     // The only container workload, so unlike the in-process
                     // runners it can be unservable on a box that configured
@@ -286,8 +312,12 @@ impl Supervisor {
                 store: self.store.clone(),
                 net: self.net.clone(),
             };
+            let mut app = c0mpute_gateway::router(state);
+            if self.config.roles.contains(&c0mpute_proto::Role::Storage) {
+                app = app.merge(self.storage_router());
+            }
             tokio::spawn(async move {
-                if let Err(e) = c0mpute_gateway::serve(state, bind).await {
+                if let Err(e) = c0mpute_gateway::serve_router(app, bind).await {
                     tracing::error!(err = %e, "gateway server exited");
                 }
             });
@@ -314,9 +344,84 @@ impl Supervisor {
         info!("ctrl-c received; shutting down");
         Ok(())
     }
+
+    /// The storage API (CIP-002) and this node's OpenDisk descriptor, served
+    /// by the gateway on every node with the `storage` role.
+    ///
+    /// Reads are open: a blake3 hash is the capability, and private-tier
+    /// objects are ciphertext. Writes must be signed by this node's own
+    /// identity or a key the operator listed in `storage.trusted_writers`,
+    /// so a stranger cannot fill the disk.
+    fn storage_router(&self) -> axum::Router {
+        use axum::routing::get;
+        use c0mpute_gateway::auth::SignedEnvelope;
+        use c0mpute_gateway::storage_api::{self, Limits, StorageApiState};
+
+        let peer = self.libp2p.peer_id();
+        let key_hex = c0mpute_net::identity::ed25519_public_hex(&peer);
+        let mut writers: Vec<&str> = self
+            .config
+            .storage
+            .trusted_writers
+            .iter()
+            .map(String::as_str)
+            .collect();
+        if let Some(own) = key_hex.as_deref() {
+            writers.push(own);
+        }
+        let (auth, rejected) = SignedEnvelope::from_hex_keys(writers);
+        for bad in rejected {
+            tracing::warn!(key = %bad, "storage: ignoring trusted_writers entry that is not an ed25519 key");
+        }
+        let limits = Limits {
+            disk_budget_bytes: self.config.storage.cap_bytes,
+            ..Limits::default()
+        };
+        let state = StorageApiState::new(
+            c0mpute_store::Storage::new(self.store.clone()),
+            Arc::new(auth),
+            limits,
+        );
+        let budget = state.budget.clone();
+        let mut app = storage_api::router(state);
+        info!("storage API on the gateway: /storage/v1 (signed writes)");
+
+        if self.config.storage.opendisk {
+            let config = self.config.clone();
+            let peer_id = peer.to_string();
+            let origin = crate::opendisk::public_origin(&config);
+            app = app.route(
+                crate::opendisk::WELL_KNOWN_PATH,
+                get(move || {
+                    let config = config.clone();
+                    let peer_id = peer_id.clone();
+                    let key_hex = key_hex.clone();
+                    let origin = origin.clone();
+                    let budget = budget.clone();
+                    async move {
+                        let cap = crate::opendisk::capacity(&config.storage, budget.used());
+                        let doc = crate::opendisk::descriptor(
+                            &config,
+                            &peer_id,
+                            key_hex.as_deref(),
+                            origin.as_deref(),
+                            cap,
+                        );
+                        (
+                            [(axum::http::header::CACHE_CONTROL, "public, max-age=300")],
+                            axum::Json(doc),
+                        )
+                    }
+                }),
+            );
+            crate::opendisk::spawn_self_listing(&self.config);
+        }
+        app
+    }
 }
 
-fn which_ffmpeg() -> Option<std::path::PathBuf> {
+/// The ffmpeg on PATH, if any. A node with one serves transcodes by default.
+pub fn which_ffmpeg() -> Option<std::path::PathBuf> {
     use std::env;
     let path = env::var_os("PATH")?;
     for dir in env::split_paths(&path) {
diff --git a/node/crates/c0mpute-core/src/video.rs b/node/crates/c0mpute-core/src/video.rs
index 0a7f0917..28d54cad 100644
--- a/node/crates/c0mpute-core/src/video.rs
+++ b/node/crates/c0mpute-core/src/video.rs
@@ -494,7 +494,7 @@ async fn run_video_job(
 /// `ftyp` at offset 4 is the ISO-BMFF marker. The runner already ffprobed the
 /// file; this is the node refusing to store something that is not a clip at
 /// all, which is cheap and catches a broken image rather than a bad model.
-fn is_mp4(bytes: &[u8]) -> bool {
+pub(crate) fn is_mp4(bytes: &[u8]) -> bool {
     bytes.len() > 12 && &bytes[4..8] == b"ftyp"
 }
 
diff --git a/node/crates/c0mpute-core/src/workflow.rs b/node/crates/c0mpute-core/src/workflow.rs
index 7e9150ae..36356a5a 100644
--- a/node/crates/c0mpute-core/src/workflow.rs
+++ b/node/crates/c0mpute-core/src/workflow.rs
@@ -508,7 +508,7 @@ pub fn spec_ref(hash: &Hash, bytes: usize) -> Value {
 
 /// Resolve `spec_inline` to the real spec: itself, or the chunk its
 /// `spec_ref` names, fetched from the buyer and checked against the hash.
-async fn resolve_spec(net: &Libp2pNetwork, job: &AcceptedJob) -> Result<Value> {
+pub(crate) async fn resolve_spec(net: &Libp2pNetwork, job: &AcceptedJob) -> Result<Value> {
     let spec = job
         .accept
         .spec_inline
diff --git a/node/crates/c0mpute-core/tests/workflow_e2e.rs b/node/crates/c0mpute-core/tests/workflow_e2e.rs
index 3e1daa99..dd28d26e 100644
--- a/node/crates/c0mpute-core/tests/workflow_e2e.rs
+++ b/node/crates/c0mpute-core/tests/workflow_e2e.rs
@@ -106,7 +106,7 @@ async fn transform_step_round_trips_through_the_bridge() {
         .unwrap();
     assert_eq!(health["ok"], true);
     assert_eq!(health["peer_id"], buyer.peer_id().to_base58());
-    assert_eq!(health["workloads"], json!(["workflow.step"]));
+    assert_eq!(health["workloads"], json!(["workflow.step", "crawl.fetch"]));
 
     let post = |body: Value, token: &'static str| {
         let http = http.clone();
diff --git a/node/crates/c0mpute-gateway/src/auth.rs b/node/crates/c0mpute-gateway/src/auth.rs
index b2887a9f..50c7e3f6 100644
--- a/node/crates/c0mpute-gateway/src/auth.rs
+++ b/node/crates/c0mpute-gateway/src/auth.rs
@@ -120,6 +120,31 @@ impl SignedEnvelope {
         self
     }
 
+    /// Trust each ed25519 public key given as 64 hex characters, under the
+    /// DID `ed25519:<hex>`. Entries that are not valid keys are skipped and
+    /// handed back so the caller can warn about them.
+    pub fn from_hex_keys<'a>(keys: impl IntoIterator<Item = &'a str>) -> (Self, Vec<String>) {
+        let mut out = Self::new();
+        let mut rejected = Vec::new();
+        for raw in keys {
+            let hex = raw.trim().trim_start_matches("ed25519:").to_ascii_lowercase();
+            match decode_key(&hex) {
+                Some(key) => out = out.with_key(format!("ed25519:{hex}"), key),
+                None => rejected.push(raw.to_string()),
+            }
+        }
+        (out, rejected)
+    }
+
+    /// How many keys may write.
+    pub fn len(&self) -> usize {
+        self.keys.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.keys.is_empty()
+    }
+
     #[cfg(test)]
     fn at_time(mut self, now: u64) -> Self {
         self.now_override = Some(now);
@@ -136,6 +161,17 @@ impl SignedEnvelope {
     }
 }
 
+fn decode_key(hex: &str) -> Option<VerifyingKey> {
+    if hex.len() != 64 || !hex.bytes().all(|b| b.is_ascii_hexdigit()) {
+        return None;
+    }
+    let mut bytes = [0u8; 32];
+    for (i, chunk) in hex.as_bytes().chunks(2).enumerate() {
+        bytes[i] = u8::from_str_radix(std::str::from_utf8(chunk).ok()?, 16).ok()?;
+    }
+    VerifyingKey::from_bytes(&bytes).ok()
+}
+
 impl Authorizer for SignedEnvelope {
     fn authorize(&self, req: &AuthRequest<'_>) -> Result<Identity, AuthError> {
         let raw = req.header.ok_or(AuthError::Missing)?;
@@ -200,6 +236,31 @@ mod tests {
     const DID: &str = "did:coinpay:test";
     const NOW: u64 = 1_756_512_000;
 
+    #[test]
+    fn hex_keys_authorize_under_their_ed25519_did() {
+        let sk = keypair();
+        let hex: String = sk
+            .verifying_key()
+            .to_bytes()
+            .iter()
+            .map(|b| format!("{b:02x}"))
+            .collect();
+        let (auth, rejected) =
+            SignedEnvelope::from_hex_keys([hex.as_str(), "not-a-key", "ed25519:zz"]);
+        assert_eq!(auth.len(), 1);
+        assert_eq!(rejected.len(), 2);
+        let auth = auth.at_time(NOW);
+        let did = format!("ed25519:{hex}");
+        let header = sign_envelope(&did, &sk, "PUT", "/storage/v1/objects/x", NOW, "00");
+        let req = AuthRequest {
+            method: "PUT",
+            path: "/storage/v1/objects/x",
+            body_hash_hex: "00",
+            header: Some(&header),
+        };
+        assert_eq!(auth.authorize(&req).unwrap().did, did);
+    }
+
     fn keypair() -> SigningKey {
         SigningKey::from_bytes(&[7u8; 32])
     }
diff --git a/node/crates/c0mpute-gateway/src/lib.rs b/node/crates/c0mpute-gateway/src/lib.rs
index e52e0c30..6274a032 100644
--- a/node/crates/c0mpute-gateway/src/lib.rs
+++ b/node/crates/c0mpute-gateway/src/lib.rs
@@ -53,6 +53,15 @@ pub async fn serve_with_storage(
     Ok(())
 }
 
+/// Serve an already-assembled gateway router (the worker merges in storage
+/// and its OpenDisk descriptor before calling this).
+pub async fn serve_router(app: Router, addr: SocketAddr) -> Result<()> {
+    info!(%addr, "gateway listening");
+    let listener = tokio::net::TcpListener::bind(addr).await?;
+    axum::serve(listener, app).await?;
+    Ok(())
+}
+
 pub async fn serve(state: GatewayState, addr: SocketAddr) -> Result<()> {
     let app = router(state);
     info!(%addr, "gateway listening");
diff --git a/node/crates/c0mpute-net/src/identity.rs b/node/crates/c0mpute-net/src/identity.rs
index 71596da2..2e605a12 100644
--- a/node/crates/c0mpute-net/src/identity.rs
+++ b/node/crates/c0mpute-net/src/identity.rs
@@ -63,10 +63,41 @@ fn write_locked_down(path: &Path, bytes: &[u8]) -> Result<()> {
         .with_context(|| format!("write {}", path.display()))
 }
 
+/// The raw ed25519 public key behind a peer id, as lowercase hex, when the
+/// peer id inlines one (every c0mpute identity does: ed25519 keys are small
+/// enough to sit in an identity multihash). This is the key an OpenDisk
+/// descriptor states as `ed25519:<hex>`.
+pub fn ed25519_public_hex(peer: &libp2p::PeerId) -> Option<String> {
+    let mh: &libp2p::multihash::Multihash<64> = peer.as_ref();
+    if mh.code() != 0x00 {
+        return None;
+    }
+    let public = libp2p::identity::PublicKey::try_decode_protobuf(mh.digest()).ok()?;
+    let ed = public.try_into_ed25519().ok()?;
+    Some(ed.to_bytes().iter().map(|b| format!("{b:02x}")).collect())
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
 
+    #[test]
+    fn peer_id_yields_its_ed25519_key() {
+        let kp = Keypair::generate_ed25519();
+        let peer = kp.public().to_peer_id();
+        let got = ed25519_public_hex(&peer).expect("ed25519 peer id");
+        let want: String = kp
+            .public()
+            .try_into_ed25519()
+            .unwrap()
+            .to_bytes()
+            .iter()
+            .map(|b| format!("{b:02x}"))
+            .collect();
+        assert_eq!(got, want);
+        assert_eq!(got.len(), 64);
+    }
+
     #[test]
     fn generate_and_reload_yields_same_peer_id() {
         let dir = tempdir();
diff --git a/node/crates/c0mpute-net/src/swarm.rs b/node/crates/c0mpute-net/src/swarm.rs
index 51922c8b..b61acc71 100644
--- a/node/crates/c0mpute-net/src/swarm.rs
+++ b/node/crates/c0mpute-net/src/swarm.rs
@@ -42,6 +42,16 @@ enum Cmd {
         addr: Multiaddr,
         reply: oneshot::Sender<Result<()>>,
     },
+    /// Make sure there is a connection to `peer`, dialing it by id (Kad and
+    /// identify supply its addresses).
+    Connect {
+        peer: PeerId,
+        reply: oneshot::Sender<Result<()>>,
+    },
+    IsConnected {
+        peer: PeerId,
+        reply: oneshot::Sender<bool>,
+    },
     Announce {
         hash: Hash,
         reply: oneshot::Sender<Result<()>>,
@@ -256,6 +266,33 @@ impl Libp2pNetwork {
         rx.await.map_err(|_| anyhow!("swarm task closed"))?
     }
 
+    /// Open (or reuse) a connection to `peer` by id. A worker uses this to
+    /// reach its buyer before publishing a result: a worker behind NAT can
+    /// dial out, and the buyer's result fetch then rides that connection.
+    /// Returns once the dial is issued.
+    pub async fn connect(&self, peer: PeerId) -> Result<()> {
+        let (tx, rx) = oneshot::channel();
+        self.cmd_tx
+            .send(Cmd::Connect { peer, reply: tx })
+            .await
+            .map_err(|_| anyhow!("swarm task closed"))?;
+        rx.await.map_err(|_| anyhow!("swarm task closed"))?
+    }
+
+    /// Whether a connection to `peer` is open now.
+    pub async fn is_connected(&self, peer: PeerId) -> bool {
+        let (tx, rx) = oneshot::channel();
+        if self
+            .cmd_tx
+            .send(Cmd::IsConnected { peer, reply: tx })
+            .await
+            .is_err()
+        {
+            return false;
+        }
+        rx.await.unwrap_or(false)
+    }
+
     pub async fn dial(&self, addr: Multiaddr) -> Result<()> {
         let (tx, rx) = oneshot::channel();
         self.cmd_tx
@@ -448,6 +485,18 @@ impl SwarmTask {
                 let r = self.swarm.lock().await.dial(addr).map_err(Into::into);
                 let _ = reply.send(r);
             }
+            Cmd::IsConnected { peer, reply } => {
+                let _ = reply.send(self.swarm.lock().await.is_connected(&peer));
+            }
+            Cmd::Connect { peer, reply } => {
+                let mut swarm = self.swarm.lock().await;
+                let r = if swarm.is_connected(&peer) {
+                    Ok(())
+                } else {
+                    swarm.dial(peer).map_err(Into::into)
+                };
+                let _ = reply.send(r);
+            }
             Cmd::Addrs { reply } => {
                 let addrs: Vec<Multiaddr> = self.swarm.lock().await.listeners().cloned().collect();
                 let _ = reply.send(addrs);
diff --git a/node/crates/c0mpute-proto/src/lib.rs b/node/crates/c0mpute-proto/src/lib.rs
index e2e1d27d..d828341a 100644
--- a/node/crates/c0mpute-proto/src/lib.rs
+++ b/node/crates/c0mpute-proto/src/lib.rs
@@ -191,6 +191,9 @@ pub enum Role {
     /// Z-Image-Turbo). On by default; the node installs it only when it has
     /// the RAM and disk, and bids only while it has free memory.
     Diffusion,
+    /// `crawl.fetch`: fetch one public web page for a buyer (static, robots
+    /// aware, SSRF-guarded). On by default; it needs nothing but a network.
+    Crawl,
 }
 
 #[cfg(test)]
diff --git a/package.json b/package.json
index 7199b696..fb1d3cf6 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "c0mpute-monorepo",
-  "version": "0.2.66",
+  "version": "0.2.67",
   "private": true,
   "workspaces": [
     "apps/*",
diff --git a/packages/shared/package.json b/packages/shared/package.json
index c5358510..b53736f2 100644
--- a/packages/shared/package.json
+++ b/packages/shared/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@c0mpute/shared",
-  "version": "0.2.66",
+  "version": "0.2.67",
   "private": true,
   "type": "module",
   "main": "./dist/index.js",
diff --git a/plugins/ad-generator-agent/module.toml b/plugins/ad-generator-agent/module.toml
index 15ccd5b1..3dcb088b 100644
--- a/plugins/ad-generator-agent/module.toml
+++ b/plugins/ad-generator-agent/module.toml
@@ -21,9 +21,10 @@
 [module]
 id          = "ad-generator-agent"
 name        = "Ad Generator Agent — every ad type from one URL"
-version     = "0.2.66"
+version     = "0.2.67"
 kind        = "service"
 category    = "applications"
+status      = "available"
 description = "Turns a landing-page URL into a complete ad set (display banners, text link, terminal, feed item, image, GIF, 5-second video pre-roll and audio) by buying c0mpute work: copy from Infernet inference, voiceover from CPU text-to-speech, artwork from diffusion when workers offer it. No paid AI API by default."
 author      = "Profullstack"
 license     = "MIT"
diff --git a/plugins/ads-manager/module.toml b/plugins/ads-manager/module.toml
index 51081b93..090da2a5 100644
--- a/plugins/ads-manager/module.toml
+++ b/plugins/ads-manager/module.toml
@@ -18,9 +18,10 @@
 [module]
 id          = "ads-manager"
 name        = "Ads Manager — shared ad operations layer"
-version     = "0.2.66"
+version     = "0.2.67"
 kind        = "service"
 category    = "applications"
+status      = "coming-soon"
 description = "Unified ad operations for the c0mpute network: campaign management, creative registry, publisher inventory, OpenRTB auction primitives, CoinPay escrow, and reporting. Required dependency for ctv-ads and all future ad format plugins."
 author      = "Profullstack"
 license     = "MIT"
diff --git a/plugins/coinpay/module.toml b/plugins/coinpay/module.toml
index d61cbc62..a53b0d6d 100644
--- a/plugins/coinpay/module.toml
+++ b/plugins/coinpay/module.toml
@@ -7,9 +7,10 @@
 [module]
 id          = "coinpay"
 name        = "CoinPay — DID, payments, escrow, reputation"
-version     = "0.2.66"
+version     = "0.2.67"
 kind        = "service"
 category    = "applications"
+status      = "available"
 description = "Decentralized identifiers, wallet linking, escrow, signed receipts, and worker reputation. The trust spine of the c0mpute network."
 author      = "Profullstack"
 license     = "MIT"
diff --git a/plugins/crawl/module.toml b/plugins/crawl/module.toml
index 1b0e1e8c..924189a2 100644
--- a/plugins/crawl/module.toml
+++ b/plugins/crawl/module.toml
@@ -1,40 +1,34 @@
 # c0mpute plugin manifest. See dips/0006-module-model.md.
 #
-# CANDIDATE plugin — implementation not yet scaffolded.
-# Brief for the implementer:
-#   Distributed web fetching. Suggested upstreams: a Rust HTTP fetcher
-#   (reqwest + scraper) for static pages, plus Playwright/Chromium
-#   sidecar for JS-rendered pages. Jobs declare URL set + render mode +
-#   robots.txt policy. Outputs: WARC or per-URL {status, headers, body,
-#   final_url, fetched_at} JSON. This is also the canonical worker
-#   pool for the CrawlProof demand generator.
-#   Validation: status-code + content-hash agreement across two workers
-#   for a sample of the URL set (re-fetched independently).
+# Built into the c0mpute binary as the in-process `crawl.fetch` workload
+# (static HTTP fetch, robots-aware). CLI: `c0mpute crawl fetch <url>`.
+# JS-rendered pages (a Playwright/Chromium `crawl.render` workload) are not
+# implemented yet and are deliberately not declared here.
 
 [module]
 id          = "crawl"
 name        = "Crawl — distributed web fetching"
-version     = "0.2.66"
+version     = "0.2.67"
 kind        = "workload"
 category    = "data"
-description = "Decentralized web crawling and page-rendering pool. Static fetches and JS-rendered pages, robots-aware, WARC-capable."
+status      = "available"
+builtin     = true
+description = "Decentralized web fetching pool. Static page fetches, robots-aware."
 author      = "Profullstack"
 license     = "MIT"
-keywords    = ["crawl", "scrape", "fetch", "warc", "playwright", "crawlproof"]
+keywords    = ["crawl", "scrape", "fetch", "crawlproof"]
 
 [module.requirements]
 c0mpute      = ">=0.1.0"
 os           = ["linux", "darwin"]
 arch         = ["x86_64", "aarch64"]
-capabilities = ["network:egress", "browser:chromium?"]
+capabilities = ["network:egress"]
 
 [module.workloads]
-"crawl.fetch"  = { command = "fetch",  validation = "status_and_content_hash_spotcheck" }
-"crawl.render" = { command = "render", validation = "status_and_dom_hash_spotcheck" }
+"crawl.fetch" = { command = "fetch", validation = "result_schema" }
 
 [module.dispatch]
-mode   = "subprocess"
-binary = "c0mpute-crawl"
+mode = "in-process"
 
 [module.surfaces]
 cli = "c0mpute crawl"
diff --git a/plugins/ctv-ads/module.toml b/plugins/ctv-ads/module.toml
index 5e4679c6..9a37616a 100644
--- a/plugins/ctv-ads/module.toml
+++ b/plugins/ctv-ads/module.toml
@@ -20,9 +20,10 @@
 [module]
 id          = "ctv-ads"
 name        = "CTV Ads — Connected TV ad marketplace"
-version     = "0.2.66"
+version     = "0.2.67"
 kind        = "service"
 category    = "applications"
+status      = "coming-soon"
 description = "Decentralised Connected TV advertising on the c0mpute network. VAST 4.x endpoint, OpenRTB real-time auction, cryptographically verified impressions, CoinPay settlement. Supports Roku, Fire TV, Apple TV, Smart TVs, and FAST channels. Live-stream integration for ad-monetised broadcasts."
 author      = "Profullstack"
 license     = "MIT"
diff --git a/plugins/diffusion/module.toml b/plugins/diffusion/module.toml
index 003704c9..19855a24 100644
--- a/plugins/diffusion/module.toml
+++ b/plugins/diffusion/module.toml
@@ -11,9 +11,11 @@
 [module]
 id          = "diffusion"
 name        = "Diffusion — image generation"
-version     = "0.2.66"
+version     = "0.2.67"
 kind        = "workload"
 category    = "ai"
+status      = "available"
+builtin     = true
 description = "Decentralized text-to-image on plain CPUs: Z-Image-Turbo through stable-diffusion.cpp, provisioned by every node with the RAM for it."
 author      = "Profullstack"
 license     = "MIT"
diff --git a/plugins/embed/module.toml b/plugins/embed/module.toml
index 7bcb5ab9..37aca4ea 100644
--- a/plugins/embed/module.toml
+++ b/plugins/embed/module.toml
@@ -13,9 +13,10 @@
 [module]
 id          = "embed"
 name        = "Embeddings — vector generation"
-version     = "0.2.66"
+version     = "0.2.67"
 kind        = "workload"
 category    = "ai"
+status      = "coming-soon"
 description = "Bulk text-embedding generation (sentence-transformers, BGE, Nomic) with CPU fallback and optional GPU acceleration."
 author      = "Profullstack"
 license     = "MIT"
diff --git a/plugins/gameserver/module.toml b/plugins/gameserver/module.toml
index b8596fda..6dbe41be 100644
--- a/plugins/gameserver/module.toml
+++ b/plugins/gameserver/module.toml
@@ -14,9 +14,10 @@
 [module]
 id          = "gameserver"
 name        = "Game server — Minecraft / Factorio / Valheim"
-version     = "0.2.66"
+version     = "0.2.67"
 kind        = "workload"
 category    = "infrastructure"
+status      = "coming-soon"
 description = "Continuous-reservation hosting for game servers. Multi-replica placement, persistent world state on c0mpute storage, proof-of-serve settlement."
 author      = "Profullstack"
 license     = "MIT"
diff --git a/plugins/hosting/module.toml b/plugins/hosting/module.toml
index 47e044c0..fc4af38e 100644
--- a/plugins/hosting/module.toml
+++ b/plugins/hosting/module.toml
@@ -12,9 +12,10 @@
 [module]
 id          = "hosting"
 name        = "Hosting — censorship-resistant static sites"
-version     = "0.2.66"
+version     = "0.2.67"
 kind        = "workload"
 category    = "data"
+status      = "coming-soon"
 description = "Static-site hosting with multi-replica placement, mutable naming, epoch settlement, and slashable proof-of-serve. See DIP-0015."
 author      = "Profullstack"
 license     = "MIT"
diff --git a/plugins/infernet/module.toml b/plugins/infernet/module.toml
index 8a21aa16..ddf2b1e7 100644
--- a/plugins/infernet/module.toml
+++ b/plugins/infernet/module.toml
@@ -10,9 +10,11 @@
 [module]
 id          = "infernet"
 name        = "Infernet Protocol — AI inference"
-version     = "0.2.66"
+version     = "0.2.67"
 kind        = "workload"
 category    = "ai"
+status      = "partial"
+status_note = "Chat runs through the separate infernet CLI, not the c0mpute binary."
 description = "Decentralized AI inference workloads on c0mpute. Runs models on consumer/prosumer GPUs with model-hash and runtime-image verification. Also trains and serves temporal policies (CfC/LTC liquid networks, GRU baseline) and fine-tunes language models (LoRA) with live progress, on CPU or GPU."
 author      = "Infernet Protocol"
 license     = "MIT"
diff --git a/plugins/live-stream/module.toml b/plugins/live-stream/module.toml
index de07dfbc..d8cea775 100644
--- a/plugins/live-stream/module.toml
+++ b/plugins/live-stream/module.toml
@@ -23,9 +23,10 @@
 [module]
 id          = "live-stream"
 name        = "Live Stream — p2p HLS live streaming"
-version     = "0.2.66"
+version     = "0.2.67"
 kind        = "service"
 category    = "media"
+status      = "coming-soon"
 description = "Decentralized live video streaming via BitTorrent-style HLS segment swarming. Broadcaster pushes RTMP/SRT; c0mpute nodes swarm segments to viewers. No central CDN. Censorship-resistant. Per-GB micropayments via CoinPay."
 author      = "Profullstack"
 license     = "MIT"
diff --git a/plugins/ocr/module.toml b/plugins/ocr/module.toml
index 48df133f..5cd7b82d 100644
--- a/plugins/ocr/module.toml
+++ b/plugins/ocr/module.toml
@@ -12,9 +12,10 @@
 [module]
 id          = "ocr"
 name        = "OCR — document text extraction"
-version     = "0.2.66"
+version     = "0.2.67"
 kind        = "workload"
 category    = "ai"
+status      = "coming-soon"
 description = "Decentralized OCR for PDFs and scanned documents (Tesseract, PaddleOCR, docTR) with CPU or GPU runners."
 author      = "Profullstack"
 license     = "MIT"
diff --git a/plugins/podcast-ads/module.toml b/plugins/podcast-ads/module.toml
index c88da7e3..284ab51b 100644
--- a/plugins/podcast-ads/module.toml
+++ b/plugins/podcast-ads/module.toml
@@ -22,9 +22,10 @@
 [module]
 id          = "podcast-ads"
 name        = "Podcast Ads — audio ad marketplace"
-version     = "0.2.66"
+version     = "0.2.67"
 kind        = "service"
 category    = "applications"
+status      = "coming-soon"
 description = "Decentralised audio advertising for c0mpute-hosted podcasts. DAAST 1.0 endpoint, dynamic ad insertion, Podcasting 2.0 <podcast:value> revenue splits, and CoinPay settlement. Publishers sell ad slots; advertisers run campaigns — zero platform cut beyond protocol split."
 author      = "Profullstack"
 license     = "MIT"
diff --git a/plugins/podcasting/module.toml b/plugins/podcasting/module.toml
index bb77998a..96904dd6 100644
--- a/plugins/podcasting/module.toml
+++ b/plugins/podcasting/module.toml
@@ -20,9 +20,10 @@
 [module]
 id          = "podcasting"
 name        = "Podcasting — p2p podcast publishing"
-version     = "0.2.66"
+version     = "0.2.67"
 kind        = "service"
 category    = "media"
+status      = "coming-soon"
 description = "Censorship-resistant podcast hosting on the c0mpute network. Upload episodes, stream live shows, auto-transcribe, and monetise via CoinPay subscriptions, pay-per-episode, value-for-value, and audio ads — with zero platform cut. RSS 2.0 + Podcasting 2.0 compatible with all major podcast apps."
 author      = "Profullstack"
 license     = "MIT"
diff --git a/plugins/podcasts/module.toml b/plugins/podcasts/module.toml
index 9df2636e..f8bb37fb 100644
--- a/plugins/podcasts/module.toml
+++ b/plugins/podcasts/module.toml
@@ -19,9 +19,10 @@
 [module]
 id          = "podcasts"
 name        = "Podcasts — p2p podcast listener"
-version     = "0.2.66"
+version     = "0.2.67"
 kind        = "service"
 category    = "media"
+status      = "coming-soon"
 description = "Discover, subscribe to, and play podcasts hosted on the c0mpute network or any standard RSS feed. Stream live episodes, tip creators directly via CoinPay, and participate in value-for-value streaming payments. Works alongside any existing podcast app via OPML export and local RSS proxy."
 author      = "Profullstack"
 license     = "MIT"
diff --git a/plugins/render/module.toml b/plugins/render/module.toml
index bbf6162d..c8916390 100644
--- a/plugins/render/module.toml
+++ b/plugins/render/module.toml
@@ -13,9 +13,10 @@
 [module]
 id          = "render"
 name        = "Render — Blender 3D rendering"
-version     = "0.2.66"
+version     = "0.2.67"
 kind        = "workload"
 category    = "media"
+status      = "coming-soon"
 description = "Decentralized 3D rendering using Blender headless (Cycles/Eevee) across consumer GPUs and CPUs."
 author      = "Profullstack"
 license     = "MIT"
diff --git a/plugins/secure-chat/module.toml b/plugins/secure-chat/module.toml
index 39bb771b..2cc74ec3 100644
--- a/plugins/secure-chat/module.toml
+++ b/plugins/secure-chat/module.toml
@@ -18,9 +18,11 @@
 [module]
 id          = "secure-chat"
 name        = "Secure Chat — E2E encrypted p2p messaging"
-version     = "0.2.66"
+version     = "0.2.67"
 kind        = "service"
 category    = "applications"
+status      = "partial"
+status_note = "Key generation works; sending and receiving messages is not live yet."
 description = "End-to-end encrypted peer-to-peer messaging across the c0mpute network. No central server. Keys stay with the user. Identity and reputation via CoinPay DID. Group chats, sealed-sender mode, and offline store-and-forward included."
 author      = "Profullstack"
 license     = "MIT"
diff --git a/plugins/storage/module.toml b/plugins/storage/module.toml
index d26f4d58..94966e3b 100644
--- a/plugins/storage/module.toml
+++ b/plugins/storage/module.toml
@@ -1,25 +1,35 @@
 # c0mpute plugin manifest. See dips/0006-module-model.md.
 #
-# CANDIDATE plugin — manifest stub for the DIP-0012 storage role.
-# Brief for the implementer:
-#   Reed-Solomon (k=10, n=14) shard storage and HTTP shard endpoints.
-#   Auto-repair re-shards on node failure. Compute-locality is the
-#   value prop — reads from c0mpute storage into a c0mpute worker
-#   are internal-egress-free. First-party in-tree: erasure coding
-#   already lives in c0mpute-store; this stub wires the marketplace
-#   surface (manifest + dashboard listing + capability tag).
+# First-party, compiled into the c0mpute binary and ON BY DEFAULT.
+#
+# Every node with the storage role (a default role) serves, on its gateway
+# (0.0.0.0:7777):
+#   /storage/v1/...                 the CIP-002 storage API: reads open (a
+#                                   blake3 hash is the capability), writes
+#                                   ed25519-signed by the node's own key or a
+#                                   key in storage.trusted_writers
+#   /.well-known/opendisk.json      its OpenDisk 0.1 descriptor: identity key,
+#                                   live free/total space, price per GiB-month
+# A node whose gateway.announce is a public https origin lists itself on the
+# OpenDisk marketplace (d1sks) on start and once a day. Peer to peer: no
+# central registry; storage.opendisk = false opts out.
+#
+# Reed-Solomon 10/14 sharding and placement live in c0mpute-store and
+# c0mpute-placement (`c0mpute storage put|get`).
 
 [module]
 id          = "storage"
 name        = "Storage — Reed-Solomon shard service"
-version     = "0.2.66"
+version     = "0.2.67"
 kind        = "service"
 category    = "data"
-description = "Reed-Solomon 10/14 shard storage with auto-repair. Compute-locality, E2E encryption, content-addressed, pay-as-you-go. See DIP-0012."
+status      = "available"
+builtin     = true
+description = "Reed-Solomon 10/14 shard storage on every node by default, with signed writes and an OpenDisk descriptor so each node lists itself on d1sks. Content-addressed, pay per GiB-month. See DIP-0012."
 author      = "Profullstack"
 license     = "MIT"
 source      = "https://github.com/profullstack/c0mpute/tree/master/plugins/storage"
-keywords    = ["storage", "erasure-coding", "reed-solomon", "shards", "content-addressed"]
+keywords    = ["storage", "erasure-coding", "reed-solomon", "shards", "content-addressed", "opendisk", "d1sks"]
 
 [module.requirements]
 c0mpute      = ">=0.1.0"
diff --git a/plugins/train/module.toml b/plugins/train/module.toml
index b4ca6f35..c8adabf1 100644
--- a/plugins/train/module.toml
+++ b/plugins/train/module.toml
@@ -13,9 +13,10 @@
 [module]
 id          = "train"
 name        = "Fine-tune — LoRA/QLoRA training"
-version     = "0.2.66"
+version     = "0.2.67"
 kind        = "workload"
 category    = "ai"
+status      = "coming-soon"
 description = "Decentralized model fine-tuning (LoRA, QLoRA) on consumer/prosumer GPUs using axolotl or unsloth."
 author      = "Profullstack"
 license     = "MIT"
diff --git a/plugins/transcode/module.toml b/plugins/transcode/module.toml
index aba9ffb8..f1a3f8db 100644
--- a/plugins/transcode/module.toml
+++ b/plugins/transcode/module.toml
@@ -7,9 +7,11 @@
 [module]
 id          = "transcode"
 name        = "FFmpeg Transcoding"
-version     = "0.2.66"
+version     = "0.2.67"
 kind        = "workload"
 category    = "media"
+status      = "available"
+builtin     = true
 description = "Decentralized audio/video transcoding via FFmpeg with hardware acceleration (NVENC, QSV, AMF, VideoToolbox, AV1)."
 author      = "Profullstack"
 license     = "MIT"
diff --git a/plugins/tts/module.toml b/plugins/tts/module.toml
index aae10d76..dece4abc 100644
--- a/plugins/tts/module.toml
+++ b/plugins/tts/module.toml
@@ -15,9 +15,11 @@
 [module]
 id          = "tts"
 name        = "TTS — text-to-speech"
-version     = "0.2.66"
+version     = "0.2.67"
 kind        = "workload"
 category    = "ai"
+status      = "available"
+builtin     = true
 description = "CPU text-to-speech inference over c0mpute using Piper, Kokoro, or Pocket TTS."
 author      = "Profullstack"
 license     = "MIT"
diff --git a/plugins/video/module.toml b/plugins/video/module.toml
index 9695e925..bf786195 100644
--- a/plugins/video/module.toml
+++ b/plugins/video/module.toml
@@ -44,9 +44,11 @@
 [module]
 id          = "video"
 name        = "Video — generation (Wan 2.2, LTX-2.3 with audio)"
-version     = "0.2.66"
+version     = "0.2.67"
 kind        = "workload"
 category    = "ai"
+status      = "partial"
+status_note = "Needs an NVIDIA GPU and the c0mpute video runner image."
 description = "Decentralized video generation on consumer/prosumer GPUs: Wan 2.2 text/image-to-video, and LTX-2.3 video with a synchronized soundtrack."
 author      = "Profullstack"
 license     = "MIT"
diff --git a/plugins/webhook/module.toml b/plugins/webhook/module.toml
index 422400fa..1d874b24 100644
--- a/plugins/webhook/module.toml
+++ b/plugins/webhook/module.toml
@@ -7,9 +7,11 @@
 [module]
 id          = "webhook"
 name        = "Webhooks — paid, end-to-end encrypted delivery"
-version     = "0.2.66"
+version     = "0.2.67"
 kind        = "workload"
 category    = "infrastructure"
+status      = "available"
+builtin     = true
 description = "Send webhooks from c0mpute workers, paid per delivery. The URL, headers, body and signing secret are sealed to the one worker that wins the job; relays and the market see only ciphertext. Standard Webhooks signatures, bounded retries with backoff, SSRF-guarded delivery (public addresses only, no redirects)."
 author      = "Profullstack"
 license     = "MIT"
diff --git a/plugins/whisper/module.toml b/plugins/whisper/module.toml
index 64fcc3e5..e6980735 100644
--- a/plugins/whisper/module.toml
+++ b/plugins/whisper/module.toml
@@ -7,9 +7,11 @@
 [module]
 id          = "whisper"
 name        = "Whisper — speech-to-text"
-version     = "0.2.66"
+version     = "0.2.67"
 kind        = "workload"
 category    = "ai"
+status      = "available"
+builtin     = true
 description = "CPU speech-to-text inference over c0mpute using faster-whisper."
 author      = "Profullstack"
 license     = "MIT"
diff --git a/plugins/workflow-step/module.toml b/plugins/workflow-step/module.toml
index bb92c224..40c1130d 100644
--- a/plugins/workflow-step/module.toml
+++ b/plugins/workflow-step/module.toml
@@ -14,9 +14,11 @@
 [module]
 id          = "workflow-step"
 name        = "Workflow step — webhook workflow steps (meshhook)"
-version     = "0.2.66"
+version     = "0.2.67"
 kind        = "workload"
 category    = "infrastructure"
+status      = "available"
+builtin     = true
 description = "Runs one step of a webhook workflow on a c0mpute worker: a JMESPath transform or a guarded HTTP call. Applications reach it through `c0mpute jobs serve`."
 author      = "Profullstack"
 license     = "MIT"