@lopecode/channel 0.1.3 → 0.1.5

package/lopecode-channel.ts

@@ -60,6 +60,8 @@ const mcp = new Server(
     },
     instructions: `You are connected to Lopecode notebooks via the lopecode channel.
 
+Lopecode notebooks are self-contained HTML files built on the Observable runtime. Each notebook contains modules (collections of reactive cells). The Observable runtime provides reactive dataflow: cells automatically recompute when their dependencies change, like a spreadsheet.
+
 ## Starting a lopecode notebook
 
 When the user asks to start/open a lopecode notebook, or start a pairing/collaboration session:
@@ -71,6 +73,72 @@ When the user asks to start/open a lopecode notebook, or start a pairing/collabo
 
 If channels are not enabled, tell the user to restart with: claude --channels server:lopecode
 
+## Observable Cell Syntax
+
+Cells use Observable JavaScript. The define_cell tool accepts this syntax directly.
+
+### Named cells
+x = 42
+greeting = \`Hello, \${name}!\`   // depends on 'name' cell — auto-recomputes when name changes
+
+### Markdown
+md\`# Title\nSome **bold** text\`
+
+### HTML
+htl.html\`<div style="color: red">Hello</div>\`
+
+### Imports (from other modules in the notebook)
+import {md} from "@tomlarkworthy/editable-md"
+import {chart, data} from "@tomlarkworthy/my-viz"
+
+### viewof — interactive inputs (creates TWO cells: "viewof X" for DOM, "X" for value)
+viewof slider = Inputs.range([0, 100], {label: "Value", value: 50})
+viewof name = Inputs.text({label: "Name"})
+viewof choice = Inputs.select(["a", "b", "c"])
+
+### mutable — imperative state
+mutable counter = 0
+// Other cells can do: mutable counter++
+
+### Block cells (multi-statement)
+result = {
+  const data = await fetch(url).then(r => r.json());
+  return data.filter(d => d.value > 10);
+}
+
+### Generator cells (streaming values)
+ticker = {
+  let i = 0;
+  while (true) { yield i++; await Promises.delay(1000); }
+}
+
+## Testing
+
+Any cell named test_* is a test. It passes if it doesn't throw:
+test_addition = {
+  if (add(2, 2) !== 4) throw new Error("Expected 4");
+  return "2 + 2 = 4";
+}
+
+Use run_tests to execute all test_* cells.
+
+## Typical workflow
+
+1. create_module("@tomlarkworthy/my-app")
+2. define_cell('import {md} from "@tomlarkworthy/editable-md"', module: "...")
+3. define_cell('title = md\`# My App\`', module: "...")
+4. define_cell('viewof name = Inputs.text({label: "Name"})', module: "...")
+5. define_cell('greeting = md\`Hello, **\${name}**!\`', module: "...")
+6. export_notebook() to persist cells to disk
+
+## Tool guidance
+
+- define_cell: PRIMARY tool for creating content. Accepts Observable source, compiles via toolchain. Use for almost everything.
+- eval_code: For throwaway/ephemeral actions (DOM hacks, debugging, location.reload()). Lost on reload. NEVER use define_cell for one-off side effects.
+- define_variable: Low-level escape hatch with explicit function string + inputs array. Rarely needed.
+- export_notebook: Persists all runtime state to the HTML file. Call after defining cells so they survive reloads.
+- fork_notebook: Creates a sibling HTML copy (checkpoint).
+
 ## Message formats
 
 User chat messages:
@@ -86,15 +154,6 @@ Lifecycle:
 Variable updates (when watching):
   <channel source="lopecode" type="variable_update" notebook="..." name="varName" module="@author/mod">value</channel>
 
-## Tools
-
-- reply: Send markdown to notebook chat
-- get_variable / define_variable / delete_variable / list_variables: Interact with runtime
-- watch_variable / unwatch_variable: Subscribe to reactive variable updates
-- run_tests: Run test_* variables
-- eval_code: Evaluate JS in browser context
-- fork_notebook: Create a copy as sibling HTML file
-
 IMPORTANT: Always specify the module parameter when calling define_variable, get_variable, etc.
 Use the currentModules watch to identify the user's content module (not lopepage, module-selection, or claude-code-pairing).
 When multiple notebooks are connected, specify notebook_id (the URL). When only one is connected, it's used automatically.`,
@@ -191,6 +250,24 @@ mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
         required: ["name", "definition"],
       },
     },
+    {
+      name: "define_cell",
+      description:
+        "Define a cell using Observable source code. Supports full Observable syntax including imports (e.g. 'import {md} from \"@tomlarkworthy/editable-md\"'), named cells ('x = 42'), markdown ('md`# Hello`'), viewof, mutable, etc. The source is compiled via the Observable toolchain and may produce multiple runtime variables.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          notebook_id: { type: "string" },
+          source: {
+            type: "string",
+            description:
+              'Observable source code, e.g. \'import {md} from "@tomlarkworthy/editable-md"\' or \'x = 42\'',
+          },
+          module: { type: "string", description: "Target module name (optional)" },
+        },
+        required: ["source"],
+      },
+    },
     {
       name: "delete_variable",
       description: "Delete a variable from the runtime.",
@@ -215,6 +292,22 @@ mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
         },
       },
     },
+    {
+      name: "list_cells",
+      description:
+        "List all cells in a module with their names, inputs, and definition source. More detailed than list_variables — shows the cell's dependency inputs and function definition.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          notebook_id: { type: "string" },
+          module: {
+            type: "string",
+            description: "Module name (required)",
+          },
+        },
+        required: ["module"],
+      },
+    },
     {
       name: "run_tests",
       description: "Run test_* variables and return results.",
@@ -239,6 +332,16 @@ mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
         required: ["code"],
       },
     },
+    {
+      name: "export_notebook",
+      description: "Export/save the notebook in place. Serializes the current runtime state (all modules, cells, file attachments) back to the HTML file, overwriting it. Use this to persist cells created via define_cell.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          notebook_id: { type: "string" },
+        },
+      },
+    },
     {
       name: "fork_notebook",
       description: "Create a copy of the notebook as a sibling HTML file. Returns the new file path.",
@@ -250,6 +353,30 @@ mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
         },
       },
     },
+    {
+      name: "create_module",
+      description: "Create a new empty module in the runtime. The module is registered in runtime.mains so it appears in moduleMap/currentModules.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          notebook_id: { type: "string" },
+          name: { type: "string", description: "Module name, e.g. '@tomlarkworthy/my-module'" },
+        },
+        required: ["name"],
+      },
+    },
+    {
+      name: "delete_module",
+      description: "Delete a module and all its variables from the runtime.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          notebook_id: { type: "string" },
+          name: { type: "string", description: "Module name to delete" },
+        },
+        required: ["name"],
+      },
+    },
     {
       name: "watch_variable",
       description: "Subscribe to reactive updates for a variable. Changes are pushed as notifications.",
@@ -323,6 +450,10 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
         };
         break;
       }
+      case "define_cell":
+        action = "define-cell";
+        params = { source: args.source, module: args.module || null };
+        break;
       case "delete_variable":
         action = "delete-variable";
         params = { name: args.name, module: args.module || null };
@@ -331,6 +462,10 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
         action = "list-variables";
         params = { module: args.module || null };
         break;
+      case "list_cells":
+        action = "list-cells";
+        params = { module: args.module };
+        break;
       case "run_tests":
         action = "run-tests";
         timeout = (args.timeout as number) || 30000;
@@ -345,6 +480,19 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
         timeout = 120000;
         params = { suffix: args.suffix || null };
         break;
+      case "export_notebook":
+        action = "fork";
+        timeout = 120000;
+        params = { _save_in_place: true };
+        break;
+      case "create_module":
+        action = "create-module";
+        params = { name: args.name };
+        break;
+      case "delete_module":
+        action = "delete-module";
+        params = { name: args.name };
+        break;
       case "watch_variable":
         action = "watch";
         params = { name: args.name, module: args.module || null };
@@ -365,13 +513,27 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
 
     // Fork special handling: write the HTML to disk
     if (action === "fork" && result.result?.html) {
-      const originalUrl = target.url;
+      // Strip hash and query fragments before extracting the file path
+      const originalUrl = target.url.split("#")[0].split("?")[0];
       let originalPath: string;
       if (originalUrl.startsWith("file://")) {
         originalPath = decodeURIComponent(originalUrl.replace("file://", ""));
       } else {
         originalPath = originalUrl;
       }
+      if (params._save_in_place) {
+        // Export: overwrite the original file
+        const html = result.result.html;
+        const htmlStr = typeof html === "string" ? html : String(html);
+        if (typeof html !== "string") {
+          console.error(`[export] WARNING: html is ${typeof html}, keys: ${html && typeof html === "object" ? Object.keys(html).join(",") : "N/A"}`);
+        }
+        if (htmlStr.length < 1000) {
+          return { content: [{ type: "text", text: `Export failed: HTML content too small (${htmlStr.length} bytes). Type was: ${typeof html}` }], isError: true };
+        }
+        await Bun.write(originalPath, htmlStr);
+        return { content: [{ type: "text", text: `Exported to ${originalPath} (${(htmlStr.length / 1024 / 1024).toFixed(2)} MB)` }] };
+      }
       const dir = dirname(originalPath);
       const base = basename(originalPath, ".html");
       const suffix = params.suffix || Date.now().toString();
@@ -544,7 +706,7 @@ await mcp.connect(new StdioServerTransport());
 const server = Bun.serve({
   port: REQUESTED_PORT,
   hostname: "127.0.0.1",
-  fetch(req, server) {
+  async fetch(req, server) {
     const url = new URL(req.url);
     if (url.pathname === "/ws") {
       if (server.upgrade(req)) return;
@@ -556,6 +718,51 @@ const server = Bun.serve({
         pending: pendingConnections.size,
       }), { headers: { "content-type": "application/json" } });
     }
+
+    // Tool activity endpoint — receives PostToolUse hook data and broadcasts to notebooks
+    if (url.pathname === "/tool-activity" && req.method === "POST") {
+      try {
+        const body = await req.json();
+        const toolName = body.tool_name || "unknown";
+        const toolInput = body.tool_input || {};
+        const toolResponse = body.tool_response;
+
+        // Build a compact summary for the chat widget
+        let summary = toolName;
+        if (toolName === "Read" && toolInput.file_path) {
+          summary = `Read ${toolInput.file_path}`;
+        } else if (toolName === "Edit" && toolInput.file_path) {
+          summary = `Edit ${toolInput.file_path}`;
+        } else if (toolName === "Write" && toolInput.file_path) {
+          summary = `Write ${toolInput.file_path}`;
+        } else if (toolName === "Bash" && toolInput.command) {
+          summary = `$ ${toolInput.command.slice(0, 120)}`;
+        } else if (toolName === "Grep" && toolInput.pattern) {
+          summary = `Grep "${toolInput.pattern}"`;
+        } else if (toolName === "Glob" && toolInput.pattern) {
+          summary = `Glob "${toolInput.pattern}"`;
+        } else if (toolName === "Agent" && toolInput.description) {
+          summary = `Agent: ${toolInput.description}`;
+        } else if (toolName.startsWith("mcp__lopecode__")) {
+          // Our own MCP tools — skip broadcasting to avoid echo
+          return new Response("ok", { status: 200 });
+        }
+
+        // Broadcast to all paired notebooks
+        const msg = JSON.stringify({
+          type: "tool-activity",
+          tool_name: toolName,
+          summary,
+          timestamp: Date.now(),
+        });
+        for (const ws of pairedConnections.values()) {
+          ws.send(msg);
+        }
+        return new Response("ok", { status: 200 });
+      } catch (e) {
+        return new Response("bad request", { status: 400 });
+      }
+    }
     if (url.pathname === "/") {
       const notebookUrl = `https://tomlarkworthy.github.io/lopecode/notebooks/@tomlarkworthy_blank-notebook.html#view=R100(S50(@tomlarkworthy/blank-notebook),S25(@tomlarkworthy/module-selection),S25(@tomlarkworthy/claude-code-pairing))&cc=${PAIRING_TOKEN}`;
       return new Response(null, {
@@ -576,5 +783,11 @@ const server = Bun.serve({
 
 PORT = server.port; // read actual port (important when REQUESTED_PORT is 0)
 PAIRING_TOKEN = generateToken();
+
+// Write port file so hooks can find us
+const portFilePath = join(import.meta.dir, ".lopecode-port");
+await Bun.write(portFilePath, String(PORT));
+process.on("exit", () => { try { require("fs").unlinkSync(portFilePath); } catch {} });
+
 process.stderr.write(`lopecode-channel: pairing token: ${PAIRING_TOKEN}\n`);
 process.stderr.write(`lopecode-channel: WebSocket server on ws://127.0.0.1:${PORT}/ws\n`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lopecode/channel",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Pair program with Claude inside Lopecode notebooks. MCP server bridging browser notebooks and Claude Code.",
   "type": "module",
   "bin": {
@@ -10,7 +10,8 @@
   "files": [
     "lopecode-channel.ts",
     "claude-code-pairing-module.js",
-    "inject-module.js"
+    "sync-module.ts",
+    "README.md"
   ],
   "keywords": [
     "mcp",

package/sync-module.ts

@@ -0,0 +1,190 @@
+#!/usr/bin/env bun
+/**
+ * Syncs a module between files. Works with .js module files and .html notebook files.
+ *
+ * Usage:
+ *   bun tools/channel/sync-module.ts --module @author/name --source src --target dest.html
+ *   bun tools/channel/sync-module.ts --module @author/name --source src --target dest.html --watch
+ *
+ * Source can be:
+ *   - A .js file containing the module's define() function
+ *   - A .html notebook file containing a <script id="@author/name"> block
+ *
+ * If source is a .js file that doesn't exist, extracts the module from target first,
+ * creating the .js file as a starting point for editing.
+ *
+ * Target must be an .html notebook file.
+ *
+ * This:
+ * 1. Reads module content from source (.js file or .html <script> block)
+ * 2. If the module <script> already exists in target, replaces its content (upsert)
+ * 3. If not, inserts it before the bootloader marker
+ * 4. Ensures the module is in bootconf.json mains
+ * 5. Updates the hash URL to include the module in the layout
+ */
+
+import { readFileSync, writeFileSync, existsSync, watch } from "fs";
+import { resolve, extname } from "path";
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  let moduleName = "";
+  let sourcePath = "";
+  let targetPath = "";
+  let watchMode = false;
+
+  for (let i = 0; i < args.length; i++) {
+    switch (args[i]) {
+      case "--module":
+        moduleName = args[++i];
+        break;
+      case "--source":
+        sourcePath = args[++i];
+        break;
+      case "--target":
+        targetPath = args[++i];
+        break;
+      case "--watch":
+        watchMode = true;
+        break;
+    }
+  }
+
+  if (!moduleName || !sourcePath || !targetPath) {
+    console.error(
+      "Usage: bun tools/channel/sync-module.ts --module <@author/name> --source <file> --target <notebook.html> [--watch]"
+    );
+    process.exit(1);
+  }
+
+  return {
+    moduleName,
+    sourcePath: resolve(sourcePath),
+    targetPath: resolve(targetPath),
+    watchMode,
+  };
+}
+
+function extractModuleFromHtml(html: string, moduleId: string): string | null {
+  const escaped = moduleId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = new RegExp(
+    `<script\\s+id="${escaped}"[^>]*>[\\s\\S]*?</script>`
+  );
+  const m = html.match(pattern);
+  return m ? m[0] : null;
+}
+
+function extractModuleContent(html: string, moduleId: string): string | null {
+  const escaped = moduleId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = new RegExp(
+    `<script\\s+id="${escaped}"[^>]*>([\\s\\S]*?)</script>`
+  );
+  const m = html.match(pattern);
+  return m ? m[1].replace(/^\n/, "").replace(/\n$/, "") : null;
+}
+
+function readModuleSource(
+  sourcePath: string,
+  moduleId: string
+): { content: string; isJs: boolean } {
+  const ext = extname(sourcePath).toLowerCase();
+
+  if (ext === ".js" || ext === ".ts") {
+    return { content: readFileSync(sourcePath, "utf8"), isJs: true };
+  } else if (ext === ".html") {
+    const html = readFileSync(sourcePath, "utf8");
+    const content = extractModuleContent(html, moduleId);
+    if (!content) {
+      console.error(
+        `Module ${moduleId} not found in ${sourcePath}`
+      );
+      process.exit(1);
+    }
+    return { content, isJs: false };
+  } else {
+    console.error(`Unsupported source file type: ${ext}`);
+    process.exit(1);
+  }
+}
+
+function inject(
+  sourcePath: string,
+  targetPath: string,
+  moduleId: string
+): void {
+  let html = readFileSync(targetPath, "utf8");
+  const { content, isJs } = readModuleSource(sourcePath, moduleId);
+
+  // Build the script block
+  const scriptBlock = `<script id="${moduleId}"\n  type="text/plain"\n  data-mime="application/javascript"\n>\n${content}\n</script>`;
+
+  // Check if module already exists in target
+  const escaped = moduleId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const scriptPattern = new RegExp(
+    `<script\\s+id="${escaped}"[^>]*>[\\s\\S]*?</script>`
+  );
+  const existing = html.match(scriptPattern);
+
+  if (existing) {
+    // Replace in-place using indexOf+slice (avoids $ interpretation in String.replace)
+    const idx = html.indexOf(existing[0]);
+    html = html.slice(0, idx) + scriptBlock + html.slice(idx + existing[0].length);
+    console.log(`Updated existing ${moduleId} module`);
+  } else {
+    // Insert before bootloader
+    const bootconfMarker = "<!-- Bootloader -->";
+    const bootconfIdx = html.lastIndexOf(bootconfMarker);
+    if (bootconfIdx === -1) {
+      console.error("Could not find '<!-- Bootloader -->' marker in HTML");
+      process.exit(1);
+    }
+    html = html.slice(0, bootconfIdx) + scriptBlock + "\n\n" + html.slice(bootconfIdx);
+    console.log(`Inserted new ${moduleId} module`);
+  }
+
+  writeFileSync(targetPath, html);
+  const size = (html.length / 1024 / 1024).toFixed(2);
+  console.log(`Wrote ${targetPath} (${size} MB)`);
+}
+
+function extractToJs(targetPath: string, moduleId: string, jsPath: string): void {
+  const html = readFileSync(targetPath, "utf8");
+  const content = extractModuleContent(html, moduleId);
+  if (!content) {
+    console.error(`Module ${moduleId} not found in ${targetPath} — cannot extract`);
+    process.exit(1);
+  }
+  writeFileSync(jsPath, content);
+  console.log(`Extracted ${moduleId} from ${targetPath} → ${jsPath}`);
+}
+
+// CLI
+const { moduleName, sourcePath, targetPath, watchMode } = parseArgs();
+
+// If source is .js and doesn't exist, extract from target first
+const sourceExt = extname(sourcePath).toLowerCase();
+if ((sourceExt === ".js" || sourceExt === ".ts") && !existsSync(sourcePath)) {
+  console.log(`Source ${sourcePath} not found — extracting from target`);
+  extractToJs(targetPath, moduleName, sourcePath);
+}
+
+// Initial injection
+inject(sourcePath, targetPath, moduleName);
+
+if (watchMode) {
+  console.log(`Watching ${sourcePath} for changes...`);
+  let debounce: ReturnType<typeof setTimeout> | null = null;
+  watch(sourcePath, () => {
+    if (debounce) clearTimeout(debounce);
+    debounce = setTimeout(() => {
+      console.log(
+        `\n${new Date().toLocaleTimeString()} — source changed, re-injecting...`
+      );
+      try {
+        inject(sourcePath, targetPath, moduleName);
+      } catch (e: any) {
+        console.error("Injection failed:", e.message);
+      }
+    }, 200);
+  });
+}

package/inject-module.js

@@ -1,131 +0,0 @@
-#!/usr/bin/env node
-/**
- * Injects the @tomlarkworthy/claude-code-pairing module into a lopecode notebook HTML.
- *
- * Usage: node tools/channel/inject-module.js <input.html> <output.html>
- *
- * This:
- * 1. Reads the source notebook HTML
- * 2. Inserts the claude-code-pairing module as a <script> block before the bootloader
- * 3. Adds "@tomlarkworthy/claude-code-pairing" to bootconf.json mains
- * 4. Updates the hash URL to include the channel module in the layout
- * 5. Writes the result to output.html
- */
-
-import { readFileSync, writeFileSync } from "fs";
-import { resolve } from "path";
-
-const [,, inputPath, outputPath] = process.argv;
-
-if (!inputPath || !outputPath) {
-  console.error("Usage: node tools/channel/inject-module.js <input.html> <output.html>");
-  process.exit(1);
-}
-
-const html = readFileSync(resolve(inputPath), "utf8");
-const moduleSource = readFileSync(resolve(import.meta.dirname, "claude-code-pairing-module.js"), "utf8");
-
-// 1. Find the bootconf.json script and insert our module before it
-const bootconfMarker = '<!-- Bootloader -->';
-const bootconfIdx = html.lastIndexOf(bootconfMarker);
-if (bootconfIdx === -1) {
-  console.error("Could not find '<!-- Bootloader -->' marker in HTML");
-  process.exit(1);
-}
-
-const moduleScript = `
-<script id="@tomlarkworthy/claude-code-pairing"
-  type="text/plain"
-  data-mime="application/javascript"
->
-${moduleSource}
-</script>
-
-`;
-
-let result = html.slice(0, bootconfIdx) + moduleScript + html.slice(bootconfIdx);
-
-// 2. Find the actual bootconf.json script block
-//    Look for the specific pattern: <script id="bootconf.json" with type="text/plain" and data-mime="application/json"
-//    Use lastIndexOf to skip templates embedded in exporter modules
-const bootconfPattern = 'id="bootconf.json" \n        type="text/plain"\n        data-mime="application/json"';
-let bootconfScriptStart = result.lastIndexOf(bootconfPattern);
-if (bootconfScriptStart === -1) {
-  // Try alternative formatting
-  bootconfScriptStart = result.lastIndexOf('id="bootconf.json"');
-  // Verify it's followed by data-mime="application/json"
-  const next200 = result.substring(bootconfScriptStart, bootconfScriptStart + 200);
-  if (!next200.includes('application/json')) {
-    console.error("Could not find bootconf.json with application/json mime type");
-    process.exit(1);
-  }
-}
-if (bootconfScriptStart === -1) {
-  console.error("Could not find bootconf.json script block");
-  process.exit(1);
-}
-const bootconfContentStart = result.indexOf('>', bootconfScriptStart) + 1;
-const bootconfContentEnd = result.indexOf('</script>', bootconfContentStart);
-let bootconfContent = result.slice(bootconfContentStart, bootconfContentEnd);
-
-// Parse the JSON-like content
-try {
-  const bootconf = JSON.parse(bootconfContent);
-
-  // Add claude-code-pairing to mains
-  if (!bootconf.mains.includes("@tomlarkworthy/claude-code-pairing")) {
-    bootconf.mains.push("@tomlarkworthy/claude-code-pairing");
-  }
-
-  // Update hash to include claude-code-pairing in layout
-  // Lopepage only supports flat R(S,S,...) — no nesting
-  // Extract existing module references and add ours as a new panel
-  const currentHash = bootconf.hash || "";
-  if (!currentHash.includes("claude-code-pairing")) {
-    // Parse existing modules from hash like R100(S70(@mod1),S30(@mod2))
-    const moduleRefs = [];
-    const modulePattern = /S(\d+)\(([^)]+)\)/g;
-    let m;
-    while ((m = modulePattern.exec(currentHash)) !== null) {
-      moduleRefs.push({ weight: parseInt(m[1]), module: m[2] });
-    }
-
-    if (moduleRefs.length > 0) {
-      // Scale existing weights to 75% and add claude-code-pairing at 25%
-      const totalWeight = moduleRefs.reduce((sum, r) => sum + r.weight, 0);
-      const scaled = moduleRefs.map(r => ({
-        weight: Math.round((r.weight / totalWeight) * 75),
-        module: r.module,
-      }));
-      scaled.push({ weight: 25, module: "@tomlarkworthy/claude-code-pairing" });
-      const parts = scaled.map(r => `S${r.weight}(${r.module})`).join(",");
-      bootconf.hash = `#view=R100(${parts})`;
-    } else {
-      // Simple fallback
-      bootconf.hash = "#view=R100(S75(@tomlarkworthy/debugger),S25(@tomlarkworthy/claude-code-pairing))";
-    }
-  }
-
-  const newBootconfContent = "\n" + JSON.stringify(bootconf, null, 2) + "\n";
-  result = result.slice(0, bootconfContentStart) + newBootconfContent + result.slice(bootconfContentEnd);
-} catch (e) {
-  console.error("Failed to parse bootconf.json:", e.message);
-  console.error("Content:", bootconfContent.slice(0, 200));
-  process.exit(1);
-}
-
-// 4. Update the title
-const titleRegex = /<title>[^<]*<\/title>/;
-const titleMatch = result.match(titleRegex);
-if (titleMatch) {
-  const currentTitle = titleMatch[0].replace(/<\/?title>/g, "");
-  if (!currentTitle.includes("claude-channel")) {
-    result = result.replace(titleRegex, `<title>${currentTitle} + claude-channel</title>`);
-  }
-}
-
-writeFileSync(resolve(outputPath), result);
-const inputSize = (html.length / 1024 / 1024).toFixed(2);
-const outputSize = (result.length / 1024 / 1024).toFixed(2);
-console.log(`Injected @tomlarkworthy/claude-code-pairing into ${outputPath}`);
-console.log(`Input: ${inputSize} MB → Output: ${outputSize} MB`);