palmier 0.9.6 → 0.9.8

package/test/agent-instructions.test.ts

@@ -1,209 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import * as fs from "fs";
-import * as path from "path";
-import { fileURLToPath } from "url";
-import { generateEndpointDocs, type ToolDefinition, type ResourceDefinition } from "../src/mcp-tools.js";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const templatePath = path.join(__dirname, "..", "src", "agents", "agent-instructions.md");
-const template = fs.readFileSync(templatePath, "utf-8");
-
-/** Mock tools with a known, stable shape for testing */
-const mockTools: ToolDefinition[] = [
-  {
-    name: "mock-action",
-    description: [
-      "Perform a mock action.",
-      'Response: `{"ok": true}` on success.',
-    ],
-    inputSchema: {
-      type: "object",
-      properties: {
-        title: { type: "string", description: "Action title" },
-        detail: { type: "string", description: "Optional detail" },
-      },
-      required: ["title"],
-    },
-    handler: async () => ({ ok: true }),
-  },
-  {
-    name: "mock-query",
-    description: [
-      "Query mock data from the device.",
-      "Blocks until the device responds.",
-      'Response: `{"data": ...}` on success.',
-    ],
-    inputSchema: {
-      type: "object",
-      properties: {
-        tags: {
-          type: "array",
-          items: { type: "string" },
-          description: "Filter tags",
-        },
-      },
-    },
-    handler: async () => ({ data: [] }),
-  },
-];
-
-/** Mock resources with a known, stable shape for testing */
-const mockResources: ResourceDefinition[] = [
-  {
-    uri: "mock://data",
-    name: "Mock Data",
-    description: [
-      "Get mock data from the device.",
-      "Response: JSON array of data objects.",
-    ],
-    mimeType: "application/json",
-    restPath: "/mock-data",
-    read: () => [],
-  },
-];
-
-/** Minimal replica of getAgentInstructions that doesn't need host.json */
-function buildInstructions(taskId: string, opts?: { skipPermissions?: boolean }): string {
-  let instructions = template
-    .replace(/\{\{ENDPOINT_DOCS\}\}/g, generateEndpointDocs(7256, taskId, mockTools, mockResources))
-    .replace(/\{\{TASK_DESCRIPTION\}\}/g, "Test task prompt");
-  if (opts?.skipPermissions) {
-    instructions = instructions.replace(/## Permissions\r?\n[\s\S]*?(?=## |\r?\n---)/m, "");
-  }
-  return instructions;
-}
-
-describe("getAgentInstructions", () => {
-  it("includes Permissions section by default", () => {
-    const result = buildInstructions("test-task-id");
-    assert.match(result, /## Permissions/);
-    assert.match(result, /PALMIER_PERMISSION/);
-  });
-
-  it("strips Permissions section when skipPermissions is true", () => {
-    const result = buildInstructions("test-task-id", { skipPermissions: true });
-    assert.doesNotMatch(result, /## Permissions/);
-    assert.doesNotMatch(result, /PALMIER_PERMISSION/);
-  });
-
-  it("preserves other sections when Permissions is stripped", () => {
-    const result = buildInstructions("test-task-id", { skipPermissions: true });
-    assert.match(result, /## Reporting Output/);
-    assert.match(result, /## Completion/);
-    assert.match(result, /## HTTP Endpoints/);
-  });
-
-  it("replaces all template variables", () => {
-    const result = buildInstructions("my-task-123");
-    assert.doesNotMatch(result, /\{\{ENDPOINT_DOCS\}\}/);
-    assert.doesNotMatch(result, /\{\{TASK_DESCRIPTION\}\}/);
-  });
-
-  it("includes task ID in endpoint examples", () => {
-    const result = buildInstructions("my-task-123");
-    assert.match(result, /my-task-123/);
-  });
-
-  it("includes port in endpoint URL", () => {
-    const result = buildInstructions("test");
-    assert.match(result, /localhost:7256/);
-  });
-
-  it("includes task description", () => {
-    const result = buildInstructions("test");
-    assert.match(result, /Test task prompt/);
-  });
-
-});
-
-
-describe("generateEndpointDocs", () => {
-  const docs = generateEndpointDocs(7256, "test-id", mockTools, mockResources);
-
-  it("matches expected full output", () => {
-    const expected = [
-      "The following HTTP endpoints are available during task execution. Use curl to call them.",
-      "",
-      "**`POST http://localhost:7256/mock-action?taskId=test-id`** — Perform a mock action.",
-      "```json",
-      '{"title":"...","detail":"..."}',
-      "```",
-      "- `title` (required, string): Action title",
-      "- `detail` (optional, string): Optional detail",
-      '- Response: `{"ok": true}` on success.',
-      "",
-      "**`POST http://localhost:7256/mock-query?taskId=test-id`** — Query mock data from the device.",
-      "```json",
-      '{"tags":["..."]}',
-      "```",
-      "- `tags` (optional, string array): Filter tags",
-      "- Blocks until the device responds.",
-      '- Response: `{"data": ...}` on success.',
-      "",
-      "**`GET http://localhost:7256/mock-data?taskId=test-id`** — Get mock data from the device.",
-      "- Response: JSON array of data objects.",
-    ].join("\n");
-    assert.equal(docs, expected);
-  });
-
-  it("generates docs for all provided tools", () => {
-    for (const tool of mockTools) {
-      assert.match(docs, new RegExp(`POST http://localhost:7256/${tool.name}\\?taskId=`), `Missing endpoint for ${tool.name}`);
-    }
-  });
-
-  it("includes taskId parameter for every endpoint", () => {
-    const endpointBlocks = docs.split("**`POST");
-    // First element is the header, skip it
-    for (let i = 1; i < endpointBlocks.length; i++) {
-      assert.match(endpointBlocks[i], /taskId/, `Missing taskId in endpoint block ${i}`);
-    }
-  });
-
-  it("includes port in the header", () => {
-    assert.match(docs, /localhost:7256/);
-  });
-
-  it("includes task ID in query parameters", () => {
-    assert.match(docs, /taskId=test-id/);
-  });
-
-  it("includes response descriptions", () => {
-    for (const tool of mockTools) {
-      if (tool.description.length > 1) {
-        assert.match(docs, /Response:/, `Missing response description for ${tool.name}`);
-      }
-    }
-  });
-
-  it("marks required and optional parameters correctly", () => {
-    assert.match(docs, /\(required, string\)/);
-    // "detail" has no required entry, so it should be optional
-    assert.match(docs, /\(optional, string\)/);
-  });
-
-  it("handles array-type parameters", () => {
-    assert.match(docs, /\(optional, string array\)/);
-    assert.match(docs, /Filter tags/);
-  });
-
-  it("renders multi-line descriptions as bullet points", () => {
-    assert.match(docs, /- Blocks until the device responds\./);
-  });
-
-  it("generates GET endpoints for all provided resources", () => {
-    for (const resource of mockResources) {
-      assert.match(docs, new RegExp(`GET http://localhost:7256${resource.restPath}`), `Missing endpoint for ${resource.uri}`);
-    }
-  });
-
-  it("includes resource description as bullet points", () => {
-    assert.match(docs, /- Response: JSON array of data objects\./);
-  });
-
-  it("generates no resource endpoints when resources array is empty", () => {
-    const docsNoResources = generateEndpointDocs(7256, "test-id", mockTools, []);
-    assert.doesNotMatch(docsNoResources, /GET http/);
-  });
-});

package/test/agent-output-parsing.test.ts

@@ -1,74 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { parseTaskOutcome, parseReportFiles, parsePermissions } from "../src/commands/run.js";
-
-describe("parseTaskOutcome", () => {
-  it("returns 'finished' for success marker", () => {
-    assert.equal(parseTaskOutcome("some output\n[PALMIER_TASK_SUCCESS]"), "finished");
-  });
-
-  it("returns 'failed' for failure marker", () => {
-    assert.equal(parseTaskOutcome("some output\n[PALMIER_TASK_FAILURE]"), "failed");
-  });
-
-  it("returns 'finished' when no marker is present", () => {
-    assert.equal(parseTaskOutcome("just some regular output"), "finished");
-  });
-
-  it("returns 'failed' when both markers present (failure takes priority)", () => {
-    assert.equal(parseTaskOutcome("[PALMIER_TASK_SUCCESS]\n[PALMIER_TASK_FAILURE]"), "failed");
-  });
-
-  it("only looks at last 500 chars", () => {
-    const padding = "x".repeat(600);
-    assert.equal(parseTaskOutcome("[PALMIER_TASK_FAILURE]" + padding), "finished");
-  });
-});
-
-describe("parseReportFiles", () => {
-  it("extracts report file names", () => {
-    const output = "doing work\n[PALMIER_REPORT] report.md\nmore work\n[PALMIER_REPORT] summary.md";
-    assert.deepEqual(parseReportFiles(output), ["report.md", "summary.md"]);
-  });
-
-  it("returns empty array when no reports", () => {
-    assert.deepEqual(parseReportFiles("no reports here"), []);
-  });
-
-  it("trims whitespace from file names", () => {
-    assert.deepEqual(parseReportFiles("[PALMIER_REPORT]   report.md  "), ["report.md"]);
-  });
-
-  it("ignores placeholder examples from echoed prompt", () => {
-    const output = "[PALMIER_REPORT] <filename>\n[PALMIER_REPORT] actual-report.md";
-    assert.deepEqual(parseReportFiles(output), ["actual-report.md"]);
-  });
-});
-
-describe("parsePermissions", () => {
-  it("extracts permissions with name and description", () => {
-    const output = "[PALMIER_PERMISSION] Read | Read file contents\n[PALMIER_PERMISSION] Bash(npm test) | Run tests";
-    const perms = parsePermissions(output);
-    assert.equal(perms.length, 2);
-    assert.deepEqual(perms[0], { name: "Read", description: "Read file contents" });
-    assert.deepEqual(perms[1], { name: "Bash(npm test)", description: "Run tests" });
-  });
-
-  it("handles permission without description", () => {
-    const perms = parsePermissions("[PALMIER_PERMISSION] Write");
-    assert.deepEqual(perms, [{ name: "Write", description: "" }]);
-  });
-
-  it("returns empty array when no permissions", () => {
-    assert.deepEqual(parsePermissions("no permissions"), []);
-  });
-
-  it("ignores placeholder examples from echoed prompt", () => {
-    const output = "[PALMIER_PERMISSION] <tool_name> | <description>\n[PALMIER_PERMISSION] Read | Read files";
-    const perms = parsePermissions(output);
-    assert.equal(perms.length, 1);
-    assert.deepEqual(perms[0], { name: "Read", description: "Read files" });
-  });
-});
-
-

package/test/linux-cron.test.ts

@@ -1,41 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { cronToOnCalendar } from "../src/platform/linux.js";
-
-describe("cronToOnCalendar", () => {
-  it("converts hourly cron", () => {
-    assert.equal(cronToOnCalendar("0 * * * *"), "*-*-* *:00:00");
-  });
-
-  it("converts daily cron", () => {
-    assert.equal(cronToOnCalendar("30 9 * * *"), "*-*-* 09:30:00");
-  });
-
-  it("converts weekly Monday cron", () => {
-    assert.equal(cronToOnCalendar("0 10 * * 1"), "Mon *-*-* 10:00:00");
-  });
-
-  it("converts weekly Sunday (day 0)", () => {
-    assert.equal(cronToOnCalendar("0 8 * * 0"), "Sun *-*-* 08:00:00");
-  });
-
-  it("converts weekly Sunday (day 7)", () => {
-    assert.equal(cronToOnCalendar("0 8 * * 7"), "Sun *-*-* 08:00:00");
-  });
-
-  it("converts monthly cron", () => {
-    assert.equal(cronToOnCalendar("0 14 15 * *"), "*-*-15 14:00:00");
-  });
-
-  it("pads single-digit hours and minutes", () => {
-    assert.equal(cronToOnCalendar("5 3 * * *"), "*-*-* 03:05:00");
-  });
-
-  it("throws on invalid cron expression", () => {
-    assert.throws(() => cronToOnCalendar("bad"), /Invalid cron/);
-  });
-
-  it("throws on too few fields", () => {
-    assert.throws(() => cronToOnCalendar("0 * *"), /Invalid cron/);
-  });
-});

package/test/macos-plist.test.ts

@@ -1,112 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import {
-  cronToCalendarInterval,
-  specificTimeToCalendarInterval,
-  buildPlist,
-} from "../src/platform/macos.js";
-
-describe("cronToCalendarInterval", () => {
-  it("converts hourly cron", () => {
-    assert.deepEqual(cronToCalendarInterval("0 * * * *"), { Minute: 0 });
-  });
-
-  it("converts daily cron", () => {
-    assert.deepEqual(cronToCalendarInterval("30 9 * * *"), { Minute: 30, Hour: 9 });
-  });
-
-  it("converts weekly Monday cron", () => {
-    assert.deepEqual(cronToCalendarInterval("0 10 * * 1"), { Minute: 0, Hour: 10, Weekday: 1 });
-  });
-
-  it("converts weekly Sunday (day 0)", () => {
-    assert.deepEqual(cronToCalendarInterval("0 8 * * 0"), { Minute: 0, Hour: 8, Weekday: 0 });
-  });
-
-  it("converts weekly Sunday (day 7 -> 0)", () => {
-    assert.deepEqual(cronToCalendarInterval("0 8 * * 7"), { Minute: 0, Hour: 8, Weekday: 0 });
-  });
-
-  it("converts monthly cron", () => {
-    assert.deepEqual(cronToCalendarInterval("0 14 15 * *"), { Minute: 0, Hour: 14, Day: 15 });
-  });
-
-  it("throws on invalid cron expression", () => {
-    assert.throws(() => cronToCalendarInterval("bad"), /Invalid cron/);
-  });
-
-  it("throws on too few fields", () => {
-    assert.throws(() => cronToCalendarInterval("0 * *"), /Invalid cron/);
-  });
-});
-
-describe("specificTimeToCalendarInterval", () => {
-  it("parses an ISO local datetime", () => {
-    assert.deepEqual(
-      specificTimeToCalendarInterval("2026-04-20T09:00"),
-      { Month: 4, Day: 20, Hour: 9, Minute: 0 },
-    );
-  });
-
-  it("parses an ISO datetime with seconds", () => {
-    assert.deepEqual(
-      specificTimeToCalendarInterval("2026-12-31T23:59:30"),
-      { Month: 12, Day: 31, Hour: 23, Minute: 59 },
-    );
-  });
-
-  it("throws on malformed input", () => {
-    assert.throws(() => specificTimeToCalendarInterval("not-a-date"), /Invalid specific_times/);
-  });
-});
-
-describe("buildPlist", () => {
-  it("emits a valid plist envelope with ProgramArguments", () => {
-    const xml = buildPlist({
-      Label: "me.palmier.host",
-      ProgramArguments: ["/usr/local/bin/node", "/opt/palmier/dist/index.js", "serve"],
-      RunAtLoad: true,
-    });
-
-    assert.ok(xml.startsWith(`<?xml version="1.0" encoding="UTF-8"?>`), "xml header");
-    assert.ok(xml.includes(`<!DOCTYPE plist PUBLIC`), "doctype");
-    assert.ok(xml.includes(`<plist version="1.0">`), "plist tag");
-    assert.ok(xml.includes(`<key>Label</key>`), "label key");
-    assert.ok(xml.includes(`<string>me.palmier.host</string>`), "label value");
-    assert.ok(xml.includes(`<key>ProgramArguments</key>`), "program args key");
-    assert.ok(xml.includes(`<string>/usr/local/bin/node</string>`), "program args first");
-    assert.ok(xml.includes(`<true/>`), "boolean");
-  });
-
-  it("serializes StartCalendarInterval as an array of dicts", () => {
-    const xml = buildPlist({
-      Label: "me.palmier.task.abc",
-      StartCalendarInterval: [
-        { Minute: 0, Hour: 9 },
-        { Minute: 30, Hour: 14, Weekday: 1 },
-      ],
-    });
-
-    assert.ok(xml.includes(`<key>StartCalendarInterval</key>`));
-    assert.ok(xml.includes(`<array>`));
-    assert.ok(xml.includes(`<key>Minute</key>`));
-    assert.ok(xml.includes(`<integer>0</integer>`));
-    assert.ok(xml.includes(`<integer>9</integer>`));
-    assert.ok(xml.includes(`<key>Weekday</key>`));
-    assert.ok(xml.includes(`<integer>1</integer>`));
-  });
-
-  it("nests dicts (EnvironmentVariables.PATH)", () => {
-    const xml = buildPlist({
-      EnvironmentVariables: { PATH: "/usr/local/bin:/usr/bin:/bin" },
-    });
-    assert.ok(xml.includes(`<key>EnvironmentVariables</key>`));
-    assert.ok(xml.includes(`<key>PATH</key>`));
-    assert.ok(xml.includes(`<string>/usr/local/bin:/usr/bin:/bin</string>`));
-  });
-
-  it("escapes XML special characters in strings", () => {
-    const xml = buildPlist({ Label: "a & b <c>" });
-    assert.ok(xml.includes(`<string>a &amp; b &lt;c&gt;</string>`));
-  });
-});

package/test/notification-store.test.ts

@@ -1,57 +0,0 @@
-import { describe, it, beforeEach } from "node:test";
-import assert from "node:assert/strict";
-
-// Re-import fresh module state for each test file run
-// Since the store is module-level state, we test the exported functions directly
-import { addNotification, getNotifications, onNotificationsChanged, type DeviceNotification } from "../src/notification-store.js";
-
-function makeNotification(id: string, overrides?: Partial<DeviceNotification>): DeviceNotification {
-  return {
-    id,
-    packageName: "com.example.app",
-    appName: "Example",
-    title: `Title ${id}`,
-    text: `Text ${id}`,
-    timestamp: Date.now(),
-    receivedAt: Date.now(),
-    ...overrides,
-  };
-}
-
-describe("notification-store", () => {
-  it("stores and retrieves notifications", () => {
-    const before = getNotifications().length;
-    addNotification(makeNotification("test-1"));
-    const after = getNotifications();
-    assert.equal(after.length, before + 1);
-    assert.equal(after[after.length - 1].id, "test-1");
-  });
-
-  it("returns a defensive copy", () => {
-    const a = getNotifications();
-    const b = getNotifications();
-    assert.notStrictEqual(a, b);
-  });
-
-  it("evicts oldest when exceeding max", () => {
-    const before = getNotifications().length;
-    // Add enough to exceed 50
-    for (let i = 0; i < 60; i++) {
-      addNotification(makeNotification(`evict-${i}`));
-    }
-    const result = getNotifications();
-    assert.ok(result.length <= 50, `Expected <= 50, got ${result.length}`);
-  });
-
-  it("notifies listeners on add", () => {
-    let called = 0;
-    const unsub = onNotificationsChanged(() => { called++; });
-    addNotification(makeNotification("listener-1"));
-    assert.equal(called, 1);
-    addNotification(makeNotification("listener-2"));
-    assert.equal(called, 2);
-    unsub();
-    addNotification(makeNotification("listener-3"));
-    assert.equal(called, 2); // no longer called after unsubscribe
-  });
-});

package/test/pairing.test.ts

@@ -1,35 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { generatePairingCode, PAIRING_EXPIRY_MS } from "../src/commands/pair.js";
-
-describe("generatePairingCode", () => {
-  it("generates a 6-character code", () => {
-    const code = generatePairingCode();
-    assert.equal(code.length, 6);
-  });
-
-  it("only contains allowed characters (no O/0/I/1/L)", () => {
-    const allowed = "ABCDEFGHJKMNPQRSTUVWXYZ23456789";
-    for (let i = 0; i < 50; i++) {
-      const code = generatePairingCode();
-      for (const ch of code) {
-        assert.ok(allowed.includes(ch), `Character '${ch}' is not in allowed set`);
-      }
-    }
-  });
-
-  it("generates unique codes", () => {
-    const codes = new Set<string>();
-    for (let i = 0; i < 100; i++) {
-      codes.add(generatePairingCode());
-    }
-    // With 30^6 ≈ 729M possibilities, 100 codes should all be unique
-    assert.equal(codes.size, 100);
-  });
-});
-
-describe("PAIRING_EXPIRY_MS", () => {
-  it("is 1 minute", () => {
-    assert.equal(PAIRING_EXPIRY_MS, 60 * 1000);
-  });
-});

package/test/result-state.test.ts

@@ -1,110 +0,0 @@
-import { describe, it, beforeEach } from "node:test";
-import assert from "node:assert/strict";
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-import {
-  createRunDir,
-  appendRunMessage,
-  beginStreamingMessage,
-} from "../src/task.js";
-import { parseResultFrontmatter } from "../src/rpc-handler.js";
-
-let taskDir: string;
-let runId: string;
-
-function setup() {
-  taskDir = fs.mkdtempSync(path.join(os.tmpdir(), "palmier-test-"));
-  runId = createRunDir(taskDir, "Test Task", 1000, "claude");
-}
-
-function readRaw(): string {
-  return fs.readFileSync(path.join(taskDir, runId, "TASKRUN.md"), "utf-8");
-}
-
-describe("parseResultFrontmatter — monitoring state", () => {
-  beforeEach(setup);
-
-  it("returns 'monitoring' when monitoring is the last message", () => {
-    appendRunMessage(taskDir, runId, { role: "status", time: 1000, content: "", type: "started" });
-    appendRunMessage(taskDir, runId, { role: "status", time: 1001, content: "", type: "monitoring" });
-
-    const result = parseResultFrontmatter(readRaw());
-    assert.equal(result.running_state, "monitoring");
-  });
-
-  it("returns 'started' when an assistant message follows monitoring", () => {
-    appendRunMessage(taskDir, runId, { role: "status", time: 1000, content: "", type: "started" });
-    appendRunMessage(taskDir, runId, { role: "status", time: 1001, content: "", type: "monitoring" });
-    const writer = beginStreamingMessage(taskDir, runId, 1002);
-    writer.write("Working on it...");
-    writer.end();
-
-    const result = parseResultFrontmatter(readRaw());
-    assert.equal(result.running_state, "started");
-  });
-
-  it("returns 'monitoring' after agent finishes and monitoring resumes", () => {
-    appendRunMessage(taskDir, runId, { role: "status", time: 1000, content: "", type: "started" });
-    appendRunMessage(taskDir, runId, { role: "status", time: 1001, content: "", type: "monitoring" });
-    // Agent processes a line
-    const writer = beginStreamingMessage(taskDir, runId, 1002);
-    writer.write("Done processing line.");
-    writer.end();
-    // Back to monitoring
-    appendRunMessage(taskDir, runId, { role: "status", time: 1003, content: "", type: "monitoring" });
-
-    const result = parseResultFrontmatter(readRaw());
-    assert.equal(result.running_state, "monitoring");
-  });
-
-  it("returns 'started' when a user message follows monitoring", () => {
-    appendRunMessage(taskDir, runId, { role: "status", time: 1000, content: "", type: "started" });
-    appendRunMessage(taskDir, runId, { role: "status", time: 1001, content: "", type: "monitoring" });
-    appendRunMessage(taskDir, runId, { role: "user", time: 1002, content: "some input" });
-
-    const result = parseResultFrontmatter(readRaw());
-    assert.equal(result.running_state, "started");
-  });
-});
-
-describe("parseResultFrontmatter — standard states", () => {
-  beforeEach(setup);
-
-  it("returns 'started' for a running task", () => {
-    appendRunMessage(taskDir, runId, { role: "status", time: 1000, content: "", type: "started" });
-    appendRunMessage(taskDir, runId, { role: "user", time: 1001, content: "Do something" });
-
-    const result = parseResultFrontmatter(readRaw());
-    assert.equal(result.running_state, "started");
-  });
-
-  it("returns 'finished' for a completed task", () => {
-    appendRunMessage(taskDir, runId, { role: "status", time: 1000, content: "", type: "started" });
-    appendRunMessage(taskDir, runId, { role: "user", time: 1001, content: "Do something" });
-    const writer = beginStreamingMessage(taskDir, runId, 1002);
-    writer.write("Done.");
-    writer.end();
-    appendRunMessage(taskDir, runId, { role: "status", time: 1003, content: "", type: "finished" });
-
-    const result = parseResultFrontmatter(readRaw());
-    assert.equal(result.running_state, "finished");
-  });
-
-  it("returns 'failed' for a failed task", () => {
-    appendRunMessage(taskDir, runId, { role: "status", time: 1000, content: "", type: "started" });
-    appendRunMessage(taskDir, runId, { role: "status", time: 1001, content: "", type: "failed" });
-
-    const result = parseResultFrontmatter(readRaw());
-    assert.equal(result.running_state, "failed");
-  });
-
-  it("returns 'followup' when started again after terminal state", () => {
-    appendRunMessage(taskDir, runId, { role: "status", time: 1000, content: "", type: "started" });
-    appendRunMessage(taskDir, runId, { role: "status", time: 1001, content: "", type: "finished" });
-    appendRunMessage(taskDir, runId, { role: "status", time: 1002, content: "", type: "started" });
-
-    const result = parseResultFrontmatter(readRaw());
-    assert.equal(result.running_state, "followup");
-  });
-});