chainlesschain 0.162.101 → 0.162.103

package/src/commands/session.js

@@ -4,6 +4,7 @@
  */
 
 import fs from "fs";
+import { numericOption } from "../lib/cli-numeric.js";
 import path from "path";
 import chalk from "chalk";
 import { logger } from "../lib/logger.js";
@@ -187,7 +188,7 @@ export function registerSessionCommand(program) {
 
           let messages = sess.messages;
           if (options.limit) {
-            messages = messages.slice(-parseInt(options.limit));
+            messages = messages.slice(-numericOption(options.limit, { name: "--limit", integer: true, min: 1 }));
           }
 
           for (const msg of messages) {

package/src/commands/sla.js

@@ -4,6 +4,7 @@
  */
 
 import chalk from "chalk";
+import { intArg, floatArg } from "../lib/cli-arg.js";
 import { logger } from "../lib/logger.js";
 import { bootstrap, shutdown } from "../runtime/bootstrap.js";
 import {
@@ -80,7 +81,7 @@ export function registerSlaCommand(program) {
     .command("create <org-id>")
     .description("Create a new SLA contract")
     .option("-t, --tier <tier>", "SLA tier (gold|silver|bronze)", "silver")
-    .option("-d, --duration <ms>", "Contract duration in ms", parseInt)
+    .option("-d, --duration <ms>", "Contract duration in ms", intArg("--duration"))
     .option("-f, --fee <amount>", "Monthly fee", parseFloat, 0)
     .option("--json", "Output as JSON")
     .action(async (orgId, options) => {
@@ -336,8 +337,8 @@ export function registerSlaCommand(program) {
   sla
     .command("report <sla-id>")
     .description("Generate an SLA compliance report")
-    .option("--start <ms>", "Start of window (ms since epoch)", parseInt)
-    .option("--end <ms>", "End of window (ms since epoch)", parseInt)
+    .option("--start <ms>", "Start of window (ms since epoch)", intArg("--start"))
+    .option("--end <ms>", "End of window (ms since epoch)", intArg("--end"))
     .option("--json", "Output as JSON")
     .action(async (slaId, options) => {
       try {
@@ -460,8 +461,8 @@ export function registerSlaCommand(program) {
     .command("create-v2 <org-id>")
     .description("Create a V2 SLA contract (enforces per-org active cap)")
     .option("-t, --tier <tier>", "gold|silver|bronze", "silver")
-    .option("-d, --duration <ms>", "Contract duration in ms", parseInt)
-    .option("-f, --fee <amount>", "Monthly fee", parseFloat)
+    .option("-d, --duration <ms>", "Contract duration in ms", intArg("--duration"))
+    .option("-f, --fee <amount>", "Monthly fee", floatArg("--fee"))
     .option("--json", "Output as JSON")
     .action(async (orgId, options) => {
       try {

package/src/commands/social.js

@@ -4,6 +4,7 @@
  */
 
 import chalk from "chalk";
+import { numericOption } from "../lib/cli-numeric.js";
 import { logger } from "../lib/logger.js";
 import { parseJsonOption } from "../lib/parse-json-option.js";
 import { bootstrap, shutdown } from "../runtime/bootstrap.js";
@@ -475,7 +476,7 @@ export function registerSocialCommand(program) {
         ensureSocialTables(db);
 
         const messages = getChatMessages(threadId, {
-          limit: parseInt(options.limit),
+          limit: numericOption(options.limit, { name: "--limit", integer: true, min: 1, fallback: 50 }),
         });
         if (options.json) {
           console.log(JSON.stringify(messages, null, 2));
@@ -966,10 +967,10 @@ export function registerSocialCommand(program) {
           directed: !!options.directed,
           edgeTypes: _splitEdgeTypes(options.edgeTypes),
           weights: {
-            degree: parseFloat(options.wDegree),
-            closeness: parseFloat(options.wCloseness),
-            betweenness: parseFloat(options.wBetweenness),
-            eigenvector: parseFloat(options.wEigenvector),
+            degree: numericOption(options.wDegree, { name: "--w-degree", fallback: 0.25 }),
+            closeness: numericOption(options.wCloseness, { name: "--w-closeness", fallback: 0.25 }),
+            betweenness: numericOption(options.wBetweenness, { name: "--w-betweenness", fallback: 0.25 }),
+            eigenvector: numericOption(options.wEigenvector, { name: "--w-eigenvector", fallback: 0.25 }),
           },
         });
         if (options.json) console.log(JSON.stringify(scores, null, 2));

package/src/commands/stress.js

@@ -4,6 +4,7 @@
  */
 
 import chalk from "chalk";
+import { intArg, floatArg } from "../lib/cli-arg.js";
 import { logger } from "../lib/logger.js";
 import { bootstrap, shutdown } from "../runtime/bootstrap.js";
 import {
@@ -58,9 +59,9 @@ export function registerStressCommand(program) {
       "Load level (light|medium|heavy|extreme)",
       "medium",
     )
-    .option("-c, --concurrency <n>", "Override concurrency", parseInt)
-    .option("-r, --rps <n>", "Override requests per second", parseInt)
-    .option("-d, --duration <ms>", "Override duration in ms", parseInt)
+    .option("-c, --concurrency <n>", "Override concurrency", intArg("--concurrency"))
+    .option("-r, --rps <n>", "Override requests per second", intArg("--rps"))
+    .option("-d, --duration <ms>", "Override duration in ms", intArg("--duration"))
     .option("--json", "Output as JSON")
     .action(async (options) => {
       try {
@@ -354,9 +355,9 @@ export function registerStressCommand(program) {
       "Load level (light|medium|heavy|extreme)",
       "medium",
     )
-    .option("-c, --concurrency <n>", "Override concurrency", parseInt)
-    .option("-r, --rps <n>", "Override requests per second", parseInt)
-    .option("-d, --duration <ms>", "Override duration in ms", parseInt)
+    .option("-c, --concurrency <n>", "Override concurrency", intArg("--concurrency"))
+    .option("-r, --rps <n>", "Override requests per second", intArg("--rps"))
+    .option("-d, --duration <ms>", "Override duration in ms", intArg("--duration"))
     .option("--json", "Output as JSON")
     .action(async (options) => {
       try {

package/src/commands/sync.js

@@ -4,6 +4,7 @@
  */
 
 import chalk from "chalk";
+import { numericOption } from "../lib/cli-numeric.js";
 import { logger } from "../lib/logger.js";
 import { parseJsonOption } from "../lib/parse-json-option.js";
 import { bootstrap, shutdown } from "../runtime/bootstrap.js";
@@ -220,7 +221,7 @@ export function registerSyncCommand(program) {
           process.exit(1);
         }
         const db = ctx.db.getDatabase();
-        const entries = getSyncLog(db, { limit: parseInt(options.limit) });
+        const entries = getSyncLog(db, { limit: numericOption(options.limit, { name: "--limit", integer: true, min: 1, fallback: 20 }) });
 
         if (options.json) {
           console.log(JSON.stringify(entries, null, 2));

package/src/commands/tenant.js

@@ -6,6 +6,7 @@
  */
 
 import fs from "fs";
+import { intArg, floatArg } from "../lib/cli-arg.js";
 import chalk from "chalk";
 import { logger } from "../lib/logger.js";
 import { parseJsonOption } from "../lib/parse-json-option.js";
@@ -380,8 +381,8 @@ export function registerTenantCommand(program) {
     .command("subscribe <tenant-id>")
     .description("Start a new subscription (cancels any prior active one)")
     .requiredOption("-p, --plan <plan>", "Plan id")
-    .option("-a, --amount <n>", "Override amount", parseFloat)
-    .option("-d, --duration-ms <ms>", "Duration in ms (default 30d)", parseInt)
+    .option("-a, --amount <n>", "Override amount", floatArg("--amount"))
+    .option("-d, --duration-ms <ms>", "Duration in ms (default 30d)", intArg("--duration-ms"))
     .option("--json", "Output as JSON")
     .action(async (tenantId, options) => {
       try {

package/src/commands/trust.js

@@ -3,6 +3,7 @@
  */
 
 import { Command } from "commander";
+import { intArg, floatArg } from "../lib/cli-arg.js";
 
 import {
   TRUST_ANCHOR,
@@ -163,7 +164,7 @@ export function registerTrustCommand(program) {
     .description("List attestations")
     .option("-a, --anchor <type>", "Filter by anchor")
     .option("-s, --status <status>", "Filter by status")
-    .option("--limit <n>", "Max results", parseInt)
+    .option("--limit <n>", "Max results", intArg("--limit"))
     .option("--json", "JSON output")
     .action((opts) => {
       const db = _dbFromCtx(tr);
@@ -186,7 +187,7 @@ export function registerTrustCommand(program) {
   tr.command("interop-test <algorithm>")
     .description("Run PQC interoperability test")
     .option("-p, --peer <id>", "Peer identifier")
-    .option("-l, --latency <ms>", "Latency in ms", parseInt)
+    .option("-l, --latency <ms>", "Latency in ms", intArg("--latency"))
     .option("--json", "JSON output")
     .action((algorithm, opts) => {
       const db = _dbFromCtx(tr);
@@ -207,7 +208,7 @@ export function registerTrustCommand(program) {
   tr.command("interop-tests")
     .description("List PQC interop tests")
     .option("-a, --algorithm <algo>", "Filter by algorithm")
-    .option("--limit <n>", "Max results", parseInt)
+    .option("--limit <n>", "Max results", intArg("--limit"))
     .option("--json", "JSON output")
     .action((opts) => {
       const db = _dbFromCtx(tr);
@@ -229,7 +230,7 @@ export function registerTrustCommand(program) {
   tr.command("sat-send <payload>")
     .description("Send satellite message")
     .option("-p, --provider <name>", "Provider (iridium/starlink/beidou)")
-    .option("-r, --priority <n>", "Priority (1-10)", parseInt)
+    .option("-r, --priority <n>", "Priority (1-10)", intArg("--priority"))
     .option("--json", "JSON output")
     .action((payload, opts) => {
       const db = _dbFromCtx(tr);
@@ -277,7 +278,7 @@ export function registerTrustCommand(program) {
     .description("List satellite messages")
     .option("-p, --provider <name>", "Filter by provider")
     .option("-s, --status <status>", "Filter by status")
-    .option("--limit <n>", "Max results", parseInt)
+    .option("--limit <n>", "Max results", intArg("--limit"))
     .option("--json", "JSON output")
     .action((opts) => {
       const db = _dbFromCtx(tr);
@@ -346,7 +347,7 @@ export function registerTrustCommand(program) {
   tr.command("hsm-devices")
     .description("List HSM devices")
     .option("-v, --vendor <name>", "Filter by vendor")
-    .option("--limit <n>", "Max results", parseInt)
+    .option("--limit <n>", "Max results", intArg("--limit"))
     .option("--json", "JSON output")
     .action((opts) => {
       const db = _dbFromCtx(tr);

package/src/commands/wallet.js

@@ -4,6 +4,7 @@
  */
 
 import chalk from "chalk";
+import { numericOption } from "../lib/cli-numeric.js";
 import { logger } from "../lib/logger.js";
 import { bootstrap, shutdown } from "../runtime/bootstrap.js";
 import {
@@ -386,7 +387,7 @@ export function registerWalletCommand(program) {
         const db = ctx.db.getDatabase();
         const txns = getTransactions(db, {
           address: options.address,
-          limit: parseInt(options.limit),
+          limit: numericOption(options.limit, { name: "--limit", integer: true, min: 1, fallback: 20 }),
         });
 
         if (options.json) {

package/src/gateways/ws/personal-data-hub-protocol.js

@@ -30,9 +30,22 @@ import {
   writeFileSync,
 } from "node:fs";
 import { join } from "node:path";
-import pdhPkg from "@chainlesschain/personal-data-hub";
-
-const { ingestSystemDataAndroidSnapshot } = pdhPkg;
+// Lazily import the pdh package the first time the system-data-android
+// ingest topic is actually used. This module is pulled in by the
+// agent/chat/serve/ui runtime chain at startup (ws-server →
+// message-dispatcher → here), so a top-level static import would force the
+// whole pdh graph to load on every `cc` invocation — and a partial/corrupt
+// pdh install would brick unrelated commands. See the matching rationale in
+// personal-data-hub-wiring.js.
+let _ingestSnapshotFn = null;
+async function ingestSystemDataAndroidSnapshot(hub, snapshot) {
+  if (!_ingestSnapshotFn) {
+    const pdhMod = await import("@chainlesschain/personal-data-hub");
+    const pdhPkg = pdhMod.default || pdhMod;
+    _ingestSnapshotFn = pdhPkg.ingestSystemDataAndroidSnapshot;
+  }
+  return _ingestSnapshotFn(hub, snapshot);
+}
 
 /**
  * If the caller didn't pass `inputPath`, try to pull a snapshot for

package/src/lib/__tests__/agents.test.js

@@ -0,0 +1,225 @@
+"use strict";
+
+/**
+ * agents tests — user-defined subagent discovery (.claude/agents/*.md), the
+ * Claude-Code parity layer, previously untested. Covers normalizeTools,
+ * parseAgentFile (frontmatter + body=systemPrompt, defaults, bad YAML),
+ * discoverAgents (path-derived names with `:`, frontmatter name override,
+ * project-shadows-personal precedence, sorting) and getAgent (colon/slash/
+ * leading-slash lookup). In-memory fake fs over POSIX paths via the deps seam;
+ * no `.git` present so projectRootBase resolves to null (cwd+home dirs only).
+ */
+
+import { describe, it, expect } from "vitest";
+import pathDefault from "path";
+import {
+  normalizeTools,
+  parseAgentFile,
+  discoverAgents,
+  getAgent,
+} from "../agents.js";
+
+const P = pathDefault.posix;
+
+function makeFs(files) {
+  const contents = new Map(Object.entries(files));
+  const fileSet = new Set(contents.keys());
+  const dirSet = new Set(["/"]);
+  for (const f of fileSet) {
+    let d = P.dirname(f);
+    while (d && !dirSet.has(d)) {
+      dirSet.add(d);
+      d = P.dirname(d);
+    }
+  }
+  const childrenOf = (dir) => {
+    const out = new Map();
+    for (const f of fileSet)
+      if (P.dirname(f) === dir) out.set(P.basename(f), false);
+    for (const d of dirSet)
+      if (d !== "/" && P.dirname(d) === dir) out.set(P.basename(d), true);
+    return out;
+  };
+  return {
+    readFileSync(p) {
+      if (!fileSet.has(p)) {
+        const e = new Error("ENOENT");
+        e.code = "ENOENT";
+        throw e;
+      }
+      return contents.get(p);
+    },
+    existsSync(p) {
+      return fileSet.has(p) || dirSet.has(p);
+    },
+    statSync(p) {
+      if (!fileSet.has(p) && !dirSet.has(p)) {
+        const e = new Error("ENOENT");
+        e.code = "ENOENT";
+        throw e;
+      }
+      const isDir = dirSet.has(p);
+      return { isDirectory: () => isDir, isFile: () => !isDir };
+    },
+    readdirSync(p, opts) {
+      if (!dirSet.has(p)) {
+        const e = new Error("ENOENT");
+        e.code = "ENOENT";
+        throw e;
+      }
+      const kids = childrenOf(p);
+      if (opts && opts.withFileTypes) {
+        return [...kids].map(([name, isDir]) => ({
+          name,
+          isDirectory: () => isDir,
+          isFile: () => !isDir,
+        }));
+      }
+      return [...kids.keys()];
+    },
+  };
+}
+
+const discover = (files, home = "/home/u") =>
+  discoverAgents("/proj", { deps: { fs: makeFs(files), path: P }, home });
+
+// --------------------------------------------------------------------------- //
+// normalizeTools
+// --------------------------------------------------------------------------- //
+describe("normalizeTools", () => {
+  it("returns null for null/undefined", () => {
+    expect(normalizeTools(null)).toBe(null);
+    expect(normalizeTools(undefined)).toBe(null);
+  });
+
+  it("splits a comma/space string into a trimmed list", () => {
+    expect(normalizeTools("read, write,  run")).toEqual([
+      "read",
+      "write",
+      "run",
+    ]);
+    expect(normalizeTools("a b c")).toEqual(["a", "b", "c"]);
+  });
+
+  it("normalizes an array, dropping empties", () => {
+    expect(normalizeTools(["read", "", "  write "])).toEqual(["read", "write"]);
+  });
+
+  it("returns null when nothing remains", () => {
+    expect(normalizeTools("")).toBe(null);
+    expect(normalizeTools([" ", ""])).toBe(null);
+  });
+});
+
+// --------------------------------------------------------------------------- //
+// parseAgentFile
+// --------------------------------------------------------------------------- //
+describe("parseAgentFile", () => {
+  const parse = (content, opts) =>
+    parseAgentFile("/a.md", "project", {
+      deps: { fs: makeFs({ "/a.md": content }) },
+      ...opts,
+    });
+
+  it("returns null when the file cannot be read", () => {
+    expect(
+      parseAgentFile("/missing.md", "project", { deps: { fs: makeFs({}) } }),
+    ).toBe(null);
+  });
+
+  it("uses the whole body as systemPrompt when there is no frontmatter", () => {
+    const a = parse("You are a helpful agent.");
+    expect(a.systemPrompt).toBe("You are a helpful agent.");
+    expect(a.name).toBe(null);
+    expect(a.description).toBe("");
+    expect(a.tools).toBe(null);
+    expect(a.model).toBe(null);
+  });
+
+  it("parses frontmatter metadata and trims the body", () => {
+    const a = parse(
+      "---\nname: sec\ndescription: security review\ntools: read, grep\nmodel: opus\n---\n\nReview for vulns.\n",
+    );
+    expect(a.name).toBe("sec");
+    expect(a.description).toBe("security review");
+    expect(a.tools).toEqual(["read", "grep"]);
+    expect(a.model).toBe("opus");
+    expect(a.systemPrompt).toBe("Review for vulns.");
+  });
+
+  it("accepts a YAML array for tools", () => {
+    const a = parse("---\ntools:\n  - read\n  - write\n---\nbody");
+    expect(a.tools).toEqual(["read", "write"]);
+  });
+
+  it("falls back to defaults on invalid YAML frontmatter", () => {
+    const a = parse("---\n: : bad : yaml :\n---\nthe body");
+    expect(a.name).toBe(null);
+    expect(a.systemPrompt).toBe("the body");
+  });
+});
+
+// --------------------------------------------------------------------------- //
+// discoverAgents
+// --------------------------------------------------------------------------- //
+describe("discoverAgents", () => {
+  it("derives names from the path with ':' for nesting", () => {
+    const agents = discover({
+      "/proj/.claude/agents/reviewer.md": "Review.",
+      "/proj/.claude/agents/sec/audit.md": "Audit.",
+    });
+    const names = agents.map((a) => a.name);
+    expect(names).toEqual(["reviewer", "sec:audit"]); // sorted
+  });
+
+  it("lets frontmatter name override the path-derived name", () => {
+    const agents = discover({
+      "/proj/.claude/agents/x.md": "---\nname: custom\n---\nbody",
+    });
+    expect(agents[0].name).toBe("custom");
+  });
+
+  it("project scope shadows personal on a name clash", () => {
+    const agents = discover({
+      "/proj/.claude/agents/reviewer.md": "PROJECT version.",
+      "/home/u/.claude/agents/reviewer.md": "PERSONAL version.",
+      "/home/u/.claude/agents/helper.md": "Helper.",
+    });
+    const reviewer = agents.find((a) => a.name === "reviewer");
+    expect(reviewer.scope).toBe("project");
+    expect(reviewer.systemPrompt).toBe("PROJECT version.");
+    // personal-only agent still discovered
+    expect(agents.find((a) => a.name === "helper").scope).toBe("personal");
+  });
+
+  it("returns [] when no agent dirs exist", () => {
+    expect(discover({ "/proj/readme.md": "x" })).toEqual([]);
+  });
+});
+
+// --------------------------------------------------------------------------- //
+// getAgent
+// --------------------------------------------------------------------------- //
+describe("getAgent", () => {
+  const files = {
+    "/proj/.claude/agents/sec/audit.md": "---\ndescription: d\n---\nAudit.",
+  };
+  const get = (name) =>
+    getAgent(name, "/proj", {
+      deps: { fs: makeFs(files), path: P },
+      home: "/home/u",
+    });
+
+  it("looks up by colon name", () => {
+    expect(get("sec:audit")?.description).toBe("d");
+  });
+
+  it("accepts slash and leading-slash forms", () => {
+    expect(get("sec/audit")?.name).toBe("sec:audit");
+    expect(get("/sec/audit")?.name).toBe("sec:audit");
+  });
+
+  it("returns null for an unknown agent", () => {
+    expect(get("nope")).toBe(null);
+  });
+});

package/src/lib/__tests__/cowork-observe-html.test.js

@@ -0,0 +1,141 @@
+"use strict";
+
+/**
+ * cowork-observe-html buildHtml tests (previously untested).
+ *
+ * buildHtml renders a static dashboard from an aggregate snapshot and embeds
+ * user-controlled data (template names, failure summaries, schedule fields) into
+ * HTML and into an inline <script> JSON blob. The escaping is the security
+ * boundary — these tests pin XSS safety (HTML entity escaping + JSON
+ * script-breakout escaping) plus the structural rendering / empty states.
+ */
+
+import { describe, it, expect } from "vitest";
+import { buildHtml } from "../cowork-observe-html.js";
+
+describe("buildHtml — document shape", () => {
+  it("emits a full HTML document with UTF-8 charset", () => {
+    const html = buildHtml({});
+    expect(html.startsWith("<!DOCTYPE html>")).toBe(true);
+    expect(html).toContain('<meta charset="UTF-8">');
+    expect(html).toContain("Cowork Observe");
+  });
+
+  it("does not throw on null/undefined data", () => {
+    expect(() => buildHtml(null)).not.toThrow();
+    expect(() => buildHtml(undefined)).not.toThrow();
+  });
+
+  it("renders empty-state messages when there is no data", () => {
+    const html = buildHtml({});
+    expect(html).toContain("No template runs in window.");
+    expect(html).toContain("No failures in window");
+    expect(html).toContain("No upcoming triggers.");
+  });
+
+  it("renders summary stat cards", () => {
+    const html = buildHtml({
+      tasks: { total: 42, successRate: 0.876, failed: 5, avgTokens: 1200 },
+      schedules: { active: 3 },
+    });
+    expect(html).toContain(">42<"); // total
+    expect(html).toContain(">88%<"); // successRate rounded
+    expect(html).toContain(">3<"); // active schedules
+  });
+});
+
+describe("buildHtml — table rendering", () => {
+  it("renders template rows with success-rate percentage", () => {
+    const html = buildHtml({
+      templates: [
+        { templateName: "build", runs: 9, successRate: 0.5, avgTokens: 100 },
+      ],
+    });
+    expect(html).toContain("<td>build</td>");
+    expect(html).toContain("<td>50%</td>");
+  });
+
+  it("caps template rows at 10", () => {
+    const templates = Array.from({ length: 15 }, (_, i) => ({
+      templateName: `t${i}`,
+      runs: i,
+      successRate: 1,
+      avgTokens: 0,
+    }));
+    const html = buildHtml({ templates });
+    expect(html).toContain("<td>t9</td>");
+    expect(html).not.toContain("<td>t10</td>"); // 11th dropped
+  });
+
+  it("truncates failure summary to 80 chars", () => {
+    const long = "x".repeat(200);
+    const html = buildHtml({
+      failures: [
+        {
+          templateId: "f",
+          failureCount: 2,
+          commonSummaries: [{ summary: long }],
+        },
+      ],
+    });
+    // the visible table cell is truncated to 80 (the raw 200-char string still
+    // lives untruncated inside the embedded JSON blob, so scope to the <td>).
+    expect(html).toContain("<td>" + "x".repeat(80) + "</td>");
+    expect(html).not.toContain("<td>" + "x".repeat(81));
+  });
+});
+
+describe("buildHtml — XSS safety", () => {
+  it("HTML-escapes user-controlled template names", () => {
+    const html = buildHtml({
+      templates: [
+        {
+          templateName: "<script>alert(1)</script>",
+          runs: 1,
+          successRate: 1,
+          avgTokens: 0,
+        },
+      ],
+    });
+    expect(html).toContain("&lt;script&gt;alert(1)&lt;/script&gt;");
+    // the raw payload must not appear inside a table cell
+    expect(html).not.toContain("<td><script>alert(1)</script></td>");
+  });
+
+  it("HTML-escapes failure summaries and schedule fields", () => {
+    const html = buildHtml({
+      failures: [
+        {
+          templateName: "<b>x</b>",
+          failureCount: 1,
+          commonSummaries: [{ summary: "a&b\"c'" }],
+        },
+      ],
+      schedules: {
+        nextTriggers: [
+          { at: "<i>t</i>", cron: "* * * * *", scheduleId: "s<1>" },
+        ],
+      },
+    });
+    expect(html).toContain("&lt;b&gt;x&lt;/b&gt;");
+    expect(html).toContain("a&amp;b&quot;c&#39;");
+    expect(html).toContain("&lt;i&gt;t&lt;/i&gt;");
+    expect(html).toContain("s&lt;1&gt;");
+  });
+
+  it("escapes a </script> breakout in the embedded JSON blob", () => {
+    const html = buildHtml({
+      tasks: { note: "</script><img src=x onerror=alert(1)>" },
+    });
+    // the inline JSON must not contain a raw closing script tag
+    expect(html).toContain("\\u003c/script");
+    expect(html).not.toContain("</script><img");
+  });
+
+  it("escapes <, > and & in the embedded JSON blob", () => {
+    const html = buildHtml({ x: "<a> & <b>" });
+    expect(html).toContain("\\u003ca\\u003e \\u0026 \\u003cb\\u003e");
+    // the script assignment line itself carries the escaped form
+    expect(html).toContain("window.__COWORK_OBSERVE__ =");
+  });
+});