arisa 5.1.2 → 5.1.8

package/test/slave-cli.test.js

@@ -0,0 +1,282 @@
+import assert from "node:assert/strict";
+import { access, mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { createHeadlessApp } from "../src/runtime/create-headless-app.js";
+import { parseSlaveBootstrapUrl } from "../src/runtime/slave-bootstrap-url.js";
+import { withSecureRequestFile } from "../src/runtime/secure-request-file.js";
+import { ensureMasterSlaveTool, runSlaveBootstrap, runSlaveCli } from "../src/runtime/slave-cli.js";
+import {
+  buildSlaveSystemdUnit,
+  getSlavePaths,
+  installSlaveSystemdService,
+  registerSlaveServiceProcess,
+  selectSlaveServiceAccount
+} from "../src/runtime/slave-service.js";
+
+const secret = `arisa_secret_v1_${"a".repeat(43)}`;
+
+test("strictly parses IPv4 and bracketed IPv6 Slave bootstrap URLs", () => {
+  assert.deepEqual(parseSlaveBootstrapUrl(`tcp://198.51.100.12:4719/${secret}`), {
+    endpoint: "tcp://198.51.100.12:4719",
+    host: "198.51.100.12",
+    ipVersion: 4,
+    port: 4719,
+    secret,
+    url: `tcp://198.51.100.12:4719/${secret}`
+  });
+  assert.equal(parseSlaveBootstrapUrl(`tcp://[2001:db8::1]:4719/${secret}`).ipVersion, 6);
+});
+
+test("rejects non-literal hosts and every extra URL component", () => {
+  for (const invalid of [
+    `https://198.51.100.12:4719/${secret}`,
+    `tcp://master.example:4719/${secret}`,
+    `tcp://198.51.100.12/${secret}`,
+    `tcp://user@198.51.100.12:4719/${secret}`,
+    `tcp://198.51.100.12:4719/${secret}/extra`,
+    `tcp://198.51.100.12:4719/${secret}?`,
+    `tcp://198.51.100.12:4719/${secret}#fragment`,
+    "tcp://198.51.100.12:4719/short"
+  ]) {
+    assert.throws(() => parseSlaveBootstrapUrl(invalid));
+  }
+});
+
+test("hands one-shot requests through a 0600 file and removes it", async (t) => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "arisa-secure-request-"));
+  t.after(() => rm(root, { recursive: true, force: true }));
+  let handedFile;
+  const result = await withSecureRequestFile({ directory: root, value: { secret } }, async (file) => {
+    handedFile = file;
+    assert.equal((await stat(file)).mode & 0o777, 0o600);
+    assert.deepEqual(JSON.parse(await readFile(file, "utf8")), { secret });
+    return "consumed";
+  });
+  assert.equal(result, "consumed");
+  await assert.rejects(() => access(handedFile), { code: "ENOENT" });
+});
+
+test("never selects root without an explicit second confirmation", async () => {
+  await assert.rejects(() => selectSlaveServiceAccount({ euid: 0 }), /explicit account selection/);
+  const rejectedAnswers = ["3", "yes"];
+  await assert.rejects(
+    () => selectSlaveServiceAccount({ euid: 0, ask: async () => rejectedAnswers.shift() }),
+    /Root execution was not confirmed/
+  );
+  const acceptedAnswers = ["3", "RUN AS ROOT"];
+  assert.deepEqual(
+    await selectSlaveServiceAccount({ euid: 0, ask: async () => acceptedAnswers.shift() }),
+    { scope: "system", user: "root", root: true, dedicated: false }
+  );
+});
+
+test("builds a dedicated headless systemd service with isolated state", () => {
+  const unit = buildSlaveSystemdUnit({
+    account: { scope: "system", user: "arisa-slave" },
+    slaveHome: "/var/lib/arisa-slave",
+    entryFile: "/opt/arisa/src/index.js",
+    platform: "linux",
+    nodePath: "/usr/bin/node"
+  });
+  assert.match(unit, /User=arisa-slave/);
+  assert.match(unit, /Environment="ARISA_HOME=\/var\/lib\/arisa-slave"/);
+  assert.match(unit, /ExecStart="\/usr\/bin\/node" "\/opt\/arisa\/src\/index\.js" slave --service-runner/);
+  assert.match(unit, /StandardOutput=append:\/var\/lib\/arisa-slave\/state\/arisa-slave\.log/);
+  assert.doesNotMatch(unit, /Telegram|Pi Agent/);
+});
+
+test("refuses to replace the PID of an active Slave host", async (t) => {
+  const home = await mkdtemp(path.join(os.tmpdir(), "arisa-slave-pid-"));
+  t.after(() => rm(home, { recursive: true, force: true }));
+  const paths = getSlavePaths(home);
+  await registerSlaveServiceProcess(paths);
+  assert.equal(await readFile(paths.pidFile, "utf8"), `${process.pid}\n`);
+  await writeFile(paths.pidFile, `${process.ppid}\n`, { mode: 0o600 });
+  await assert.rejects(() => registerSlaveServiceProcess(paths), /already running/);
+});
+
+test("installs the dedicated Linux systemd target without silently selecting root", async (t) => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "arisa-slave-systemd-"));
+  t.after(() => rm(root, { recursive: true, force: true }));
+  const calls = [];
+  let accountExists = false;
+  const execute = async (command, args) => {
+    calls.push([command, args]);
+    if (command === "id" && args[0] === "-u" && !accountExists) throw new Error("missing user");
+    if (command === "useradd") accountExists = true;
+    if (command === "id" && args[0] === "-gn") return { stdout: "arisa-slave\n", stderr: "" };
+    return { stdout: "", stderr: "" };
+  };
+  const result = await installSlaveSystemdService({
+    account: { scope: "system", user: "arisa-slave", root: false, dedicated: true },
+    slaveHome: path.join(root, "home"),
+    entryFile: "/opt/arisa/src/index.js",
+    execute,
+    platform: "linux",
+    systemUnitDir: path.join(root, "units")
+  });
+  assert.equal(result.account.root, false);
+  assert.equal(await access(result.unitFile).then(() => true, () => false), true);
+  assert.ok(calls.some(([command]) => command === "useradd"));
+  assert.ok(calls.some(([command, args]) => command === "systemctl" && args.includes("enable") && args.includes("--now")));
+});
+
+test("validates before effects and keeps the bootstrap secret out of service metadata", async (t) => {
+  const home = await mkdtemp(path.join(os.tmpdir(), "arisa-slave-home-"));
+  t.after(() => rm(home, { recursive: true, force: true }));
+  const paths = getSlavePaths(home);
+  const calls = [];
+  const result = await runSlaveBootstrap(`tcp://198.51.100.12:4719/${secret}`, {
+    paths,
+    entryFile: "/opt/arisa/src/index.js",
+    platform: "linux",
+    selectAccount: async () => ({ scope: "user", user: "tester", root: false, dedicated: false }),
+    ensureTool: async () => { calls.push("tool"); },
+    installService: async () => { calls.push("service"); },
+    invokeTool: async (_paths, args) => {
+      calls.push("invoke");
+      assert.equal(args.action, "slave.bootstrap");
+      assert.equal((await stat(args.bootstrapFile)).mode & 0o777, 0o600);
+      assert.deepEqual(JSON.parse(await readFile(args.bootstrapFile, "utf8")), {
+        url: `tcp://198.51.100.12:4719/${secret}`
+      });
+      return { ok: true };
+    },
+    output: { log: () => {} }
+  });
+  assert.deepEqual(result, { ok: true });
+  assert.deepEqual(calls, ["tool", "invoke", "service"]);
+  const descriptor = await readFile(paths.descriptorFile, "utf8");
+  const config = await readFile(paths.configFile, "utf8");
+  assert.doesNotMatch(descriptor, /arisa_secret/);
+  assert.doesNotMatch(config, /arisa_secret/);
+
+  calls.length = 0;
+  await assert.rejects(
+    () => runSlaveBootstrap("tcp://hostname:4719/invalid", {
+      paths,
+      platform: "linux",
+      selectAccount: async () => { calls.push("account"); }
+    })
+  );
+  assert.deepEqual(calls, []);
+});
+
+test("ships an immutable verified master-slave bootstrap lock", async (t) => {
+  const home = await mkdtemp(path.join(os.tmpdir(), "arisa-slave-lock-"));
+  t.after(() => rm(home, { recursive: true, force: true }));
+  const calls = [];
+  const result = await ensureMasterSlaveTool(getSlavePaths(home), {
+    install: async (request) => {
+      calls.push(request);
+      return { commit: request.lock.commit };
+    }
+  });
+  assert.equal(result.installed, true);
+  assert.match(result.commit, /^[a-f0-9]{40}$/);
+  assert.equal(calls[0].toolName, "master-slave");
+  assert.ok(Object.keys(calls[0].lock.tools["master-slave"].files).length > 0);
+});
+
+test("starts the headless composition without Telegram or Pi components", async () => {
+  const calls = [];
+  const toolRegistry = {
+    load: async () => { calls.push("tools.load"); },
+    list: () => [],
+    run: async () => ({ ok: true })
+  };
+  const taskStore = {
+    recoverInterrupted: async () => { calls.push("tasks.recover"); },
+    addMany: async () => []
+  };
+  const supervisor = {
+    start: async () => { calls.push("supervisor.start"); },
+    stop: async () => { calls.push("supervisor.stop"); }
+  };
+  const ipcServer = {
+    socketPath: "/isolated/slave.sock",
+    start: async () => { calls.push("ipc.start"); },
+    stop: async () => { calls.push("ipc.stop"); }
+  };
+  const app = await createHeadlessApp({
+    configLoader: async () => ({ daemons: { supervisorIntervalMs: 1 } }),
+    artifactStoreFactory: () => ({ forChat: () => ({}) }),
+    taskStoreFactory: () => taskStore,
+    toolRegistryFactory: () => toolRegistry,
+    supervisorFactory: () => supervisor,
+    capabilitiesFactory: ({ agentManager }) => {
+      assert.equal(typeof agentManager.runTool, "function");
+      calls.push("capabilities.create");
+      return { dispatch: async () => ({}) };
+    },
+    ipcServerFactory: () => ipcServer
+  });
+  await app.start();
+  await app.stop();
+  assert.deepEqual(calls, [
+    "tools.load",
+    "capabilities.create",
+    "ipc.start",
+    "tasks.recover",
+    "supervisor.start",
+    "supervisor.stop",
+    "ipc.stop"
+  ]);
+});
+
+test("combines systemd and local tool diagnostics for Slave status", async (t) => {
+  const home = await mkdtemp(path.join(os.tmpdir(), "arisa-slave-status-"));
+  t.after(() => rm(home, { recursive: true, force: true }));
+  const output = [];
+  const result = await runSlaveCli({
+    positionals: ["status"],
+    paths: getSlavePaths(home),
+    controlService: async (_paths, operation) => {
+      assert.equal(operation, "status");
+      return { running: true, status: "active" };
+    },
+    toolInstalled: async () => true,
+    invokeTool: async (_paths, args) => {
+      assert.deepEqual(args, { action: "slave.status" });
+      return {
+        ok: true,
+        output: {
+          json: {
+            daemon: { state: "ready" },
+            role: "slave",
+            endpoint: "tcp://198.51.100.12:4719",
+            identityFingerprint: "abcd1234",
+            paired: true,
+            toolCount: 4,
+            jobs: { active: 1, queued: 2, failed: 0 },
+            pendingSecrets: 0
+          }
+        }
+      };
+    },
+    output: { log: (line) => output.push(line) }
+  });
+  assert.equal(result.systemd.running, true);
+  assert.match(output[0], /Systemd: active/);
+  assert.match(output[0], /Daemon: ready/);
+  assert.match(output[0], /Role: slave/);
+  assert.match(output[0], /Endpoint: tcp:\/\/198\.51\.100\.12:4719/);
+  assert.match(output[0], /Identity: abcd1234/);
+  assert.match(output[0], /Paired: yes/);
+  assert.match(output[0], /Tools: 4/);
+  assert.match(output[0], /Jobs: active=1, queued=2, failed=0/);
+  assert.match(output[0], /Pending secrets: 0/);
+});
+
+test("prints Slave help without touching service or Master bootstrap state", async () => {
+  const output = [];
+  const result = await runSlaveCli({
+    flags: { help: true },
+    output: { log: (line) => output.push(line) },
+    controlService: async () => assert.fail("service must not be inspected for help")
+  });
+  assert.deepEqual(result, { help: true });
+  assert.match(output[0], /^Usage: arisa slave/);
+});

package/test/telegram-text-artifact.test.js

@@ -1,8 +1,31 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import { buildPrompt, buildReactionPrompt, shouldIncludeArtifactReference } from "../src/transport/telegram/bot.js";
+import { buildPrompt, buildReactionPrompt, isScheduledTaskPrompt, shouldIncludeArtifactReference, withPromptSpeed } from "../src/transport/telegram/bot.js";
 import { captureIncomingArtifact } from "../src/transport/telegram/media.js";
 
+test("scheduled agent prompts use normal speed for one turn and restore chat speed", async () => {
+  let speed = 1.5;
+  const speedController = {
+    setSpeed(value) { speed = value; }
+  };
+  assert.equal(isScheduledTaskPrompt("Scheduled task fired.\ntaskId: one"), true);
+  assert.equal(isScheduledTaskPrompt("Incoming Telegram message."), false);
+
+  await withPromptSpeed({ speedController, speed: 1, restoreSpeed: () => 1.5 }, async () => {
+    assert.equal(speed, 1);
+  });
+  assert.equal(speed, 1.5);
+
+  await assert.rejects(
+    withPromptSpeed({ speedController, speed: 1, restoreSpeed: () => 1.5 }, async () => {
+      assert.equal(speed, 1);
+      throw new Error("failed turn");
+    }),
+    /failed turn/
+  );
+  assert.equal(speed, 1.5);
+});
+
 function createTextContext(text = "hello") {
   return {
     chat: { id: 123 },

package/test/tool-capability-search.test.js

@@ -0,0 +1,55 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { rankToolMatches } from "../src/core/tools/tool-registry.js";
+import { searchOfficialToolCatalog } from "../src/core/tools/official-tool-catalog.js";
+
+const tools = [
+  {
+    name: "x-reader",
+    description: "Read public X posts",
+    category: "social",
+    keywords: ["posts", "reader", "x"],
+    input: ["text/plain"],
+    output: ["application/json"]
+  },
+  {
+    name: "x-session-reader",
+    description: "Read posts and bookmarks from an X session",
+    category: "social",
+    keywords: ["bookmarks", "session", "x"],
+    input: ["application/json"],
+    output: ["application/json", "text/csv"]
+  }
+];
+
+test("capability search ranks exact keyword matches first", () => {
+  const matches = rankToolMatches(tools, "bookmarks");
+  assert.equal(matches.length, 1);
+  assert.equal(matches[0].tool.name, "x-session-reader");
+  assert.equal(matches[0].score, 12);
+});
+
+test("capability search covers descriptions, inputs, and outputs", () => {
+  assert.equal(rankToolMatches(tools, "public")[0].tool.name, "x-reader");
+  assert.equal(rankToolMatches(tools, "csv")[0].tool.name, "x-session-reader");
+});
+
+test("official catalog fallback ranks remote manifests", async () => {
+  const responses = new Map([
+    ["https://api.github.com/repos/clasen/Arisa/contents/tools", [
+      { name: "x-reader", type: "dir" },
+      { name: "x-session-reader", type: "dir" }
+    ]],
+    ["https://raw.githubusercontent.com/clasen/Arisa/main/tools/x-reader/tool.manifest.json", tools[0]],
+    ["https://raw.githubusercontent.com/clasen/Arisa/main/tools/x-session-reader/tool.manifest.json", tools[1]]
+  ]);
+  const fetchImpl = async (url) => ({
+    ok: responses.has(url),
+    status: responses.has(url) ? 200 : 404,
+    json: async () => responses.get(url)
+  });
+  const matches = await searchOfficialToolCatalog("bookmarks", { fetchImpl });
+  assert.equal(matches.length, 1);
+  assert.equal(matches[0].name, "x-session-reader");
+  assert.equal(matches[0].source, "official-catalog");
+});

package/test/tool-registry-run.test.js

@@ -8,7 +8,7 @@ const homeDir = await mkdtemp(path.join(os.tmpdir(), "arisa-tool-registry-home-"
 process.env.HOME = homeDir;
 process.env.USERPROFILE = homeDir;
 
-const { ToolRegistry } = await import("../src/core/tools/tool-registry.js");
+const { ToolRegistry, createToolOutputParser } = await import("../src/core/tools/tool-registry.js");
 const {
   arisaHomeDir,
   arisaPackageDir,
@@ -69,6 +69,26 @@ process.stdout.write(JSON.stringify({
   return dir;
 }
 
+async function createStreamingTool(name = "stream-tool") {
+  const dir = await createFakeTool(name, { version: "2.1.0", packageDigest: "sha256:test", requirements: { ffmpeg: {} } });
+  await writeFile(path.join(dir, "index.js"), `const frames = [
+  { version: 1, jobId: "stream-job", type: "accepted", sequence: 1, payload: {} },
+  { version: 1, jobId: "stream-job", type: "progress", sequence: 2, payload: { percent: 50 } },
+  { version: 1, jobId: "stream-job", type: "chunk", sequence: 3, payload: { text: "part" } },
+  { version: 1, jobId: "stream-job", type: "completed", sequence: 4, payload: { result: { ok: true, output: { text: "stream completed" } } } }
+];
+process.stderr.write("stream diagnostic\\n");
+for (const frame of frames) {
+  const line = JSON.stringify(frame) + "\\n";
+  const midpoint = Math.floor(line.length / 2);
+  process.stdout.write(line.slice(0, midpoint));
+  await new Promise((resolve) => setTimeout(resolve, 2));
+  process.stdout.write(line.slice(midpoint));
+}
+`, "utf8");
+  return dir;
+}
+
 test("loads and lists installed tools from the user tools directory", async () => {
   await resetHome();
   await createFakeTool("fake-tool", {
@@ -81,6 +101,9 @@ test("loads and lists installed tools from the user tools directory", async () =
 
   assert.deepEqual(registry.list(), [{
     name: "fake-tool",
+    version: null,
+    packageDigest: null,
+    requirements: [],
     description: "Fake test tool",
     input: ["text/plain"],
     output: ["text/plain"],
@@ -192,3 +215,49 @@ test("rejects unknown tools", async () => {
     /Tool not found: missing-tool/
   );
 });
+
+test("parses fragmented NDJSON incrementally and keeps stderr diagnostic-only", async () => {
+  await resetHome();
+  await createStreamingTool();
+  const logs = [];
+  const registry = new ToolRegistry({ logger: { log: (...args) => logs.push(args.join(" ")) } });
+  await registry.load();
+  const events = [];
+
+  const result = await registry.run({
+    name: "stream-tool",
+    chatId: "chat-1",
+    request: { text: "hello" },
+    onEvent: (event) => events.push(event)
+  });
+
+  assert.equal(result.ok, true);
+  assert.equal(result.output.text, "stream completed");
+  assert.deepEqual(events.map((event) => event.type), ["accepted", "progress", "chunk", "completed"]);
+  assert.match(logs.join("\n"), /stream diagnostic/);
+  assert.doesNotMatch(JSON.stringify(events), /stream diagnostic/);
+});
+
+test("rejects invalid NDJSON sequences and a second terminal event", async () => {
+  const invalidSequence = createToolOutputParser("sequence-tool");
+  await invalidSequence.push(`${JSON.stringify({ version: 1, jobId: "job", type: "accepted", sequence: 1, payload: {} })}\n`);
+  await assert.rejects(
+    () => invalidSequence.push(`${JSON.stringify({ version: 1, jobId: "job", type: "chunk", sequence: 3, payload: {} })}\n`),
+    /Invalid tool event sequence/
+  );
+
+  const duplicateTerminal = createToolOutputParser("terminal-tool");
+  await duplicateTerminal.push(`${JSON.stringify({ version: 1, jobId: "job", type: "completed", sequence: 1, payload: { result: { ok: true } } })}\n`);
+  await assert.rejects(
+    () => duplicateTerminal.push(`${JSON.stringify({ version: 1, jobId: "job", type: "failed", sequence: 2, payload: { error: "late" } })}\n`),
+    /more than one terminal event/
+  );
+});
+
+test("preserves pretty-printed single JSON tool responses", async () => {
+  const parser = createToolOutputParser("legacy-tool");
+  const output = JSON.stringify({ ok: true, output: { text: "legacy" } }, null, 2);
+  await parser.push(output.slice(0, 11));
+  await parser.push(output.slice(11));
+  assert.deepEqual(await parser.finish(), { mode: "legacy", output });
+});

package/test/tool-resource-note.test.js

@@ -0,0 +1,50 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { ToolResourceNoteStore } from "../src/core/tools/tool-resource-note-store.js";
+import { buildAsyncTaskPrompt } from "../src/transport/telegram/bot.js";
+
+const root = await mkdtemp(path.join(os.tmpdir(), "arisa-resource-notes-"));
+const resolveFile = (chatId) => path.join(root, String(chatId), "notes.json");
+
+test.after(async () => rm(root, { recursive: true, force: true }));
+
+test("stores short notes by chat, tool, and exact resource", async () => {
+  const store = new ToolResourceNoteStore({ resolveFile });
+  await store.set("chat-a", "whatsapp-web", "group@g.us", "They call me Peter.");
+  assert.equal(await store.get("chat-a", "whatsapp-web", "group@g.us"), "They call me Peter.");
+  assert.equal(await store.get("chat-b", "whatsapp-web", "group@g.us"), "");
+  assert.equal(await store.get("chat-a", "other-tool", "group@g.us"), "");
+  const persisted = JSON.parse(await readFile(resolveFile("chat-a"), "utf8"));
+  assert.equal(persisted.tools["whatsapp-web"]["group@g.us"].note, "They call me Peter.");
+});
+
+test("enforces the 200-character limit and clears empty notes", async () => {
+  const store = new ToolResourceNoteStore({ resolveFile });
+  await assert.rejects(
+    () => store.set("chat-a", "whatsapp-web", "other@g.us", "x".repeat(201)),
+    /at most 200 characters/
+  );
+  await store.set("chat-a", "whatsapp-web", "other@g.us", "temporary");
+  await store.set("chat-a", "whatsapp-web", "other@g.us", "");
+  assert.equal(await store.get("chat-a", "whatsapp-web", "other@g.us"), "");
+});
+
+test("injects a matching resource note before scheduled event text", async () => {
+  const store = new ToolResourceNoteStore({ resolveFile });
+  await store.set("chat-a", "whatsapp-web", "group@g.us", "They call me Peter.");
+  const prompt = await buildAsyncTaskPrompt({
+    task: {
+      id: "task-1",
+      payload: { chatId: "chat-a", prompt: "Incoming WhatsApp message." },
+      source: { toolName: "whatsapp-web", resourceId: "group@g.us" }
+    },
+    artifactStore: { forChat: () => ({ get: async () => null }) },
+    toolRegistry: {},
+    resourceNotes: store
+  });
+  assert.match(prompt, /resourceNote: They call me Peter\./);
+  assert.ok(prompt.indexOf("resourceNote:") < prompt.indexOf("text: Incoming"));
+});

package/test/tool-usage.test.js

@@ -26,12 +26,17 @@ test("counts concurrent tool uses per chat", async () => {
   }
 });
 
-test("formats narrow tool usage counts", () => {
+test("formats narrow tool usage counts with bullets and right-aligned numbers", () => {
   const report = formatToolUsageReport([
-    { name: "campaign-draft-runner", count: 12 },
-    { name: "gmail-workspace", count: 3 }
+    { name: "gmail-workspace", count: 3 },
+    { name: "campaign-draft-runner", count: 12 }
   ]);
-  assert.match(report, /campaign-draft-runner\s+12/);
-  assert.match(report, /gmail-workspace\s+3/);
+  assert.match(report, /- campaign-draft-runner  12/);
+  assert.match(report, /- gmail-workspace\s+3/);
+  const rows = report.split("\n").filter((line) => line.startsWith("- "));
+  assert.match(rows[0], /campaign-draft-runner/);
+  assert.match(rows[1], /gmail-workspace/);
+  assert.deepEqual(rows.map((line) => line.match(/\d+$/).index + line.match(/\d+$/)[0].length), [27, 27]);
+  assert.deepEqual(rows.map((line) => line.length), [27, 27]);
   assert.ok(report.split("\n").every((line) => [...line].length <= 35));
 });

package/test-fixtures/fake-daemon.js

@@ -1,6 +1,7 @@
 import { fileURLToPath } from "node:url";
 import {
   readDaemonLaunchContext,
+  readJson,
   writeJson
 } from "../src/core/tools/daemon-processes.js";
 import { createDaemonRuntime } from "../src/core/tools/daemon-runtime.js";
@@ -40,8 +41,18 @@ if (process.argv[2] !== "daemon") {
 await runtime.workLoop({
   healthCheck,
   recover,
-  processJob: async (payload) => {
+  processJob: async (payload, execution) => {
     if (payload.action === "fail") throw new Error("synthetic job failure");
+    if (payload.action === "stream") {
+      await execution.emit("progress", { percent: 50 });
+      await execution.emit("chunk", { text: "partial" });
+    }
+    if (payload.action === "count") {
+      const countFile = `${runtime.paths.root}/effects.json`;
+      const current = await readJson(countFile, { count: 0 });
+      await writeJson(countFile, { count: current.count + 1 });
+      return { count: current.count + 1 };
+    }
     return { echo: payload.value ?? null };
   }
 });