clawspec 1.0.19 → 1.0.21

package/test/helpers/harness.ts

@@ -1,305 +0,0 @@
-import os from "node:os";
-import path from "node:path";
-import { mkdtemp, mkdir } from "node:fs/promises";
-import { PlanningJournalStore } from "../../src/planning/journal.ts";
-import { parsePluginConfig } from "../../src/config.ts";
-import { ProjectMemoryStore } from "../../src/memory/store.ts";
-import { ClawSpecService } from "../../src/orchestrator/service.ts";
-import { ProjectStateStore } from "../../src/state/store.ts";
-import { writeUtf8 } from "../../src/utils/fs.ts";
-import { getRepoStatePaths } from "../../src/utils/paths.ts";
-import { WorkspaceStore } from "../../src/workspace/store.ts";
-
-export type FakeWatcherManager = {
-  wakeCalls: string[];
-  interruptCalls: Array<{ channelKey: string; reason: string }>;
-  runtimeStatusCalls: string[];
-  runtimeStatus?: unknown;
-  wake: (channelKey: string) => Promise<void>;
-  interrupt: (channelKey: string, reason: string) => Promise<void>;
-  getWorkerRuntimeStatus: (channelKeyOrProject: string | { channelKey: string }) => Promise<unknown>;
-};
-
-export function createFakeWatcherManager(): FakeWatcherManager {
-  const wakeCalls: string[] = [];
-  const interruptCalls: Array<{ channelKey: string; reason: string }> = [];
-  const runtimeStatusCalls: string[] = [];
-  const manager: FakeWatcherManager = {
-    wakeCalls,
-    interruptCalls,
-    runtimeStatusCalls,
-    runtimeStatus: undefined,
-    wake: async (channelKey: string) => {
-      wakeCalls.push(channelKey);
-    },
-    interrupt: async (channelKey: string, reason: string) => {
-      interruptCalls.push({ channelKey, reason });
-    },
-    getWorkerRuntimeStatus: async (channelKeyOrProject: string | { channelKey: string }) => {
-      const channelKey = typeof channelKeyOrProject === "string"
-        ? channelKeyOrProject
-        : channelKeyOrProject.channelKey;
-      runtimeStatusCalls.push(channelKey);
-      return manager.runtimeStatus;
-    },
-  };
-  return manager;
-}
-
-export function createLogger() {
-  return {
-    info: () => undefined,
-    warn: () => undefined,
-    error: () => undefined,
-    debug: () => undefined,
-  };
-}
-
-export async function waitFor(
-  check: () => Promise<boolean>,
-  timeoutMs = 4_000,
-  pollIntervalMs = 250,
-): Promise<void> {
-  const startedAt = Date.now();
-  while (Date.now() - startedAt < timeoutMs) {
-    if (await check()) {
-      return;
-    }
-    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
-  }
-  throw new Error("Timed out waiting for test condition.");
-}
-
-export async function createServiceHarness(prefix: string): Promise<{
-  service: ClawSpecService;
-  stateStore: ProjectStateStore;
-  memoryStore: ProjectMemoryStore;
-  workspaceStore: WorkspaceStore;
-  watcherManager: FakeWatcherManager;
-  sentMessages: Array<{ to: string; text: string }>;
-  workspacePath: string;
-  repoPath: string;
-  changeDir: string;
-  openSpec: Record<string, any>;
-}> {
-  const tempRoot = await mkdtemp(path.join(os.tmpdir(), prefix));
-  const workspacePath = path.join(tempRoot, "workspace");
-  const repoPath = path.join(workspacePath, "demo-app");
-  const changeDir = path.join(repoPath, "openspec", "changes", "demo-change");
-  await mkdir(workspacePath, { recursive: true });
-
-  const stateStore = new ProjectStateStore(tempRoot, "archives");
-  const memoryStore = new ProjectMemoryStore(path.join(tempRoot, "memory.json"));
-  const workspaceStore = new WorkspaceStore(path.join(tempRoot, "workspace-state.json"), workspacePath);
-  await stateStore.initialize();
-  await memoryStore.initialize();
-  await workspaceStore.initialize();
-
-  const openSpec = {
-    init: async (cwd: string) => {
-      await writeUtf8(path.join(cwd, "openspec", "config.yaml"), "schema: spec-driven\n");
-      return {
-        command: "openspec init --tools none .",
-        cwd,
-        stdout: "initialized",
-        stderr: "",
-        durationMs: 1,
-      };
-    },
-    newChange: async (cwd: string, changeName: string, description?: string) => {
-      const nextChangeDir = path.join(cwd, "openspec", "changes", changeName);
-      await mkdir(nextChangeDir, { recursive: true });
-      await writeUtf8(path.join(nextChangeDir, ".openspec.yaml"), "schema: spec-driven\n");
-      await writeUtf8(path.join(nextChangeDir, "proposal.md"), `# ${changeName}\n${description ?? ""}\n`);
-      return {
-        command: description
-          ? `openspec new change ${changeName} --description "${description}"`
-          : `openspec new change ${changeName}`,
-        cwd,
-        stdout: "change created",
-        stderr: "",
-        durationMs: 1,
-      };
-    },
-    status: async (cwd: string, changeName: string) => ({
-      command: `openspec status --change ${changeName} --json`,
-      cwd,
-      stdout: "{}",
-      stderr: "",
-      durationMs: 1,
-      parsed: {
-        changeName,
-        schemaName: "spec-driven",
-        isComplete: false,
-        applyRequires: ["tasks"],
-        artifacts: [
-          { id: "proposal", outputPath: path.join(changeDir, "proposal.md"), status: "done" },
-          { id: "tasks", outputPath: path.join(changeDir, "tasks.md"), status: "ready" },
-        ],
-      },
-    }),
-    instructionsArtifact: async (cwd: string, artifactId: string, changeName: string) => ({
-      command: `openspec instructions ${artifactId} --change ${changeName} --json`,
-      cwd,
-      stdout: "{}",
-      stderr: "",
-      durationMs: 1,
-      parsed: {
-        changeName,
-        artifactId,
-        schemaName: "spec-driven",
-        changeDir,
-        outputPath: artifactId === "specs"
-          ? path.join(changeDir, "specs", "demo-spec", "spec.md")
-          : path.join(changeDir, `${artifactId}.md`),
-        description: `Refresh ${artifactId}`,
-        instruction: `Use ${artifactId} template`,
-        template: `# ${artifactId}`,
-        dependencies: [],
-        unlocks: [],
-      },
-    }),
-    instructionsApply: async (cwd: string, changeName: string) => ({
-      command: `openspec instructions apply --change ${changeName} --json`,
-      cwd,
-      stdout: "{}",
-      stderr: "",
-      durationMs: 1,
-      parsed: {
-        changeName,
-        changeDir,
-        schemaName: "spec-driven",
-        contextFiles: {},
-        progress: { total: 0, complete: 0, remaining: 0 },
-        tasks: [],
-        state: "ready",
-        instruction: "Implement the remaining tasks.",
-      },
-    }),
-  } as Record<string, any>;
-
-  const watcherManager = createFakeWatcherManager();
-  const sentMessages: Array<{ to: string; text: string }> = [];
-  const service = new ClawSpecService({
-    api: {
-      config: {
-        acp: {
-          backend: "acpx",
-          defaultAgent: "codex",
-          allowedAgents: ["codex", "piper"],
-        },
-        agents: {
-          list: [
-            { id: "codex" },
-            { id: "piper" },
-          ],
-        },
-      },
-      runtime: {
-        channel: {
-          discord: {
-            sendMessageDiscord: async (to: string, text: string) => {
-              sentMessages.push({ to, text });
-            },
-          },
-          telegram: {},
-          slack: {},
-          signal: {},
-        },
-      },
-      logger: createLogger(),
-    } as any,
-    config: {
-      acp: {
-        backend: "acpx",
-        defaultAgent: "codex",
-        allowedAgents: ["codex", "piper"],
-      },
-      agents: {
-        list: [
-          { id: "codex" },
-          { id: "piper" },
-        ],
-      },
-    } as any,
-    logger: createLogger(),
-    stateStore,
-    memoryStore,
-    openSpec: openSpec as any,
-    archiveDirName: "archives",
-    defaultWorkspace: workspacePath,
-    defaultWorkerAgentId: undefined,
-    workspaceStore,
-    watcherManager: watcherManager as any,
-  });
-
-  return {
-    service,
-    stateStore,
-    memoryStore,
-    workspaceStore,
-    watcherManager,
-    sentMessages,
-    workspacePath,
-    repoPath,
-    changeDir,
-    openSpec,
-  };
-}
-
-export async function seedPlanningProject(
-  stateStore: ProjectStateStore,
-  channelKey: string,
-  params: {
-    workspacePath: string;
-    repoPath: string;
-    projectName: string;
-    changeName: string;
-    changeDir: string;
-    phase: "proposal" | "planning_sync" | "tasks" | "implementing";
-    status: "ready" | "paused" | "planning" | "running";
-    planningDirty: boolean;
-    execution?: {
-      action: "plan" | "work";
-      state: "armed" | "running";
-      mode: "apply" | "continue";
-    };
-  },
-): Promise<void> {
-  await mkdir(params.changeDir, { recursive: true });
-  const repoStatePaths = getRepoStatePaths(params.repoPath, "archives");
-  const journalStore = new PlanningJournalStore(repoStatePaths.planningJournalFile);
-  await stateStore.createProject(channelKey);
-  await stateStore.updateProject(channelKey, (current) => ({
-    ...current,
-    workspacePath: params.workspacePath,
-    repoPath: params.repoPath,
-    projectName: params.projectName,
-    projectTitle: params.projectName,
-    changeName: params.changeName,
-    changeDir: params.changeDir,
-    status: params.status,
-    phase: params.phase,
-    planningJournal: {
-      dirty: params.planningDirty,
-      entryCount: params.planningDirty ? 1 : 0,
-      lastEntryAt: params.planningDirty ? new Date(Date.now() - 60_000).toISOString() : undefined,
-    },
-    execution: params.execution
-      ? {
-          ...params.execution,
-          workerSlot: "primary",
-          armedAt: new Date().toISOString(),
-        }
-      : current.execution,
-  }));
-
-  if (params.planningDirty) {
-    await journalStore.append({
-      timestamp: new Date(Date.now() - 60_000).toISOString(),
-      changeName: params.changeName,
-      role: "user",
-      text: "refresh planning for the active change",
-    });
-  }
-}

package/test/helpers.test.ts

@@ -1,108 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import type { ProjectState } from "../src/types.ts";
-import {
-  hasBlockingExecution,
-  isFinishedStatus,
-  isProjectContextAttached,
-  requiresPlanningSync,
-  sanitizePlanningMessageText,
-  shouldCapturePlanningMessage,
-  isMeaningfulExecutionSummary,
-  okReply,
-  errorReply,
-  samePath,
-} from "../src/orchestrator/helpers.ts";
-
-function makeProject(overrides: Partial<ProjectState> = {}): ProjectState {
-  return {
-    projectId: "test-id",
-    channelKey: "discord:test:default:main",
-    projectName: "test",
-    status: "ready",
-    phase: "tasks",
-    createdAt: new Date().toISOString(),
-    updatedAt: new Date().toISOString(),
-    ...overrides,
-  } as ProjectState;
-}
-
-test("hasBlockingExecution detects armed/running states", () => {
-  assert.equal(hasBlockingExecution(makeProject({ execution: { state: "armed" } as any })), true);
-  assert.equal(hasBlockingExecution(makeProject({ execution: { state: "running" } as any })), true);
-  assert.equal(hasBlockingExecution(makeProject({ status: "running" })), true);
-  assert.equal(hasBlockingExecution(makeProject({ status: "ready" })), false);
-  assert.equal(hasBlockingExecution(makeProject()), false);
-});
-
-test("isFinishedStatus identifies terminal statuses", () => {
-  assert.equal(isFinishedStatus("done"), true);
-  assert.equal(isFinishedStatus("archived"), true);
-  assert.equal(isFinishedStatus("cancelled"), true);
-  assert.equal(isFinishedStatus("ready"), false);
-  assert.equal(isFinishedStatus("running"), false);
-  assert.equal(isFinishedStatus("armed"), false);
-});
-
-test("isProjectContextAttached returns false when detached", () => {
-  assert.equal(isProjectContextAttached(makeProject({ contextMode: "detached" })), false);
-  assert.equal(isProjectContextAttached(makeProject({ contextMode: undefined })), true);
-  assert.equal(isProjectContextAttached(makeProject()), true);
-});
-
-test("requiresPlanningSync detects dirty journal", () => {
-  assert.equal(requiresPlanningSync(makeProject({ changeName: "x", planningJournal: { dirty: true, entryCount: 1 } })), true);
-  assert.equal(requiresPlanningSync(makeProject({ changeName: "x", phase: "proposal" })), true);
-  assert.equal(requiresPlanningSync(makeProject({ changeName: "x", planningJournal: { dirty: false, entryCount: 0 } })), false);
-  assert.equal(requiresPlanningSync(makeProject({ changeName: undefined as any })), false);
-  assert.equal(requiresPlanningSync(makeProject({ changeName: "x", status: "done" })), false);
-});
-
-test("shouldCapturePlanningMessage excludes running/archived/cancelled", () => {
-  assert.equal(shouldCapturePlanningMessage(makeProject({ changeName: "x", status: "ready" })), true);
-  assert.equal(shouldCapturePlanningMessage(makeProject({ changeName: "x", status: "running" })), false);
-  assert.equal(shouldCapturePlanningMessage(makeProject({ changeName: "x", status: "archived" })), false);
-  assert.equal(shouldCapturePlanningMessage(makeProject({ changeName: "x", status: "cancelled" })), false);
-  assert.equal(shouldCapturePlanningMessage(makeProject({ contextMode: "detached", changeName: "x" })), false);
-  assert.equal(shouldCapturePlanningMessage(makeProject({ changeName: undefined as any })), false);
-});
-
-test("sanitizePlanningMessageText strips metadata blocks", () => {
-  const input = `Hello\nConversation info (untrusted metadata):\n\`\`\`json\n{"key":"value"}\n\`\`\`\nWorld`;
-  const result = sanitizePlanningMessageText(input);
-  assert.equal(result, "Hello\nWorld");
-});
-
-test("sanitizePlanningMessageText preserves clean text", () => {
-  assert.equal(sanitizePlanningMessageText("  clean text  "), "clean text");
-});
-
-test("isMeaningfulExecutionSummary filters boilerplate", () => {
-  assert.equal(isMeaningfulExecutionSummary(undefined), false);
-  assert.equal(isMeaningfulExecutionSummary(""), false);
-  assert.equal(isMeaningfulExecutionSummary("No summary yet."), false);
-  assert.equal(isMeaningfulExecutionSummary("Visible execution ended without a structured result."), false);
-  assert.equal(isMeaningfulExecutionSummary("Visible execution started for something"), false);
-  assert.equal(isMeaningfulExecutionSummary("Completed task 1.1"), true);
-  assert.equal(isMeaningfulExecutionSummary("All tasks done."), true);
-});
-
-test("okReply and errorReply produce correct shapes", () => {
-  const ok = okReply("success");
-  assert.equal(ok.text, "success");
-  assert.equal(ok.isError, undefined);
-
-  const err = errorReply("failure");
-  assert.equal(err.text, "failure");
-  assert.equal(err.isError, true);
-});
-
-test("samePath respects platform case sensitivity rules", () => {
-  if (process.platform === "win32") {
-    assert.equal(samePath("C:\\Repo\\Demo", "c:\\repo\\demo"), true);
-    return;
-  }
-
-  assert.equal(samePath("/Repo/Demo", "/repo/demo"), false);
-  assert.equal(samePath("/repo/demo", "/repo/demo"), true);
-});

package/test/keywords.test.ts

@@ -1,92 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import {
-  parseClawSpecKeyword,
-  extractEmbeddedClawSpecKeyword,
-  isClawSpecKeywordText,
-} from "../src/control/keywords.ts";
-
-test("parseClawSpecKeyword recognizes all primary commands", () => {
-  const commands = [
-    ["cs-plan", "plan"],
-    ["cs-work", "work"],
-    ["cs-attach", "attach"],
-    ["cs-detach", "detach"],
-    ["cs-deattach", "detach"],
-    ["cs-pause", "pause"],
-    ["cs-continue", "continue"],
-    ["cs-status", "status"],
-    ["cs-cancel", "cancel"],
-  ] as const;
-
-  for (const [input, expectedKind] of commands) {
-    const result = parseClawSpecKeyword(input);
-    assert.equal(result?.kind, expectedKind, `${input} should be kind "${expectedKind}"`);
-    assert.equal(result?.command, input.toLowerCase());
-  }
-});
-
-test("parseClawSpecKeyword handles args", () => {
-  const result = parseClawSpecKeyword("cs-continue now please");
-  assert.equal(result?.kind, "continue");
-  assert.equal(result?.args, "now please");
-  assert.equal(result?.raw, "cs-continue now please");
-});
-
-test("parseClawSpecKeyword returns null for non-cs- prefixed text", () => {
-  assert.equal(parseClawSpecKeyword("hello world"), null);
-  assert.equal(parseClawSpecKeyword("/clawspec proposal"), null);
-  assert.equal(parseClawSpecKeyword(""), null);
-  assert.equal(parseClawSpecKeyword("cs-nonexistent"), null);
-});
-
-test("parseClawSpecKeyword is case-insensitive for command", () => {
-  const result = parseClawSpecKeyword("CS-PLAN");
-  assert.equal(result?.kind, "plan");
-  assert.equal(result?.command, "cs-plan");
-});
-
-test("parseClawSpecKeyword trims input", () => {
-  const result = parseClawSpecKeyword("  cs-work  ");
-  assert.equal(result?.kind, "work");
-});
-
-test("parseClawSpecKeyword accepts slash-prefixed and punctuated control words", () => {
-  assert.equal(parseClawSpecKeyword("/cs-work")?.kind, "work");
-  assert.equal(parseClawSpecKeyword("`cs-plan`")?.kind, "plan");
-  assert.equal(parseClawSpecKeyword("cs-work。")?.kind, "work");
-});
-
-test("isClawSpecKeywordText returns boolean correctly", () => {
-  assert.equal(isClawSpecKeywordText("cs-plan"), true);
-  assert.equal(isClawSpecKeywordText("hello"), false);
-});
-
-test("extractEmbeddedClawSpecKeyword finds keyword in multiline text", () => {
-  const text = "Here is some context\n\ncs-work\n\nMore text after";
-  const result = extractEmbeddedClawSpecKeyword(text);
-  assert.equal(result?.kind, "work");
-});
-
-test("extractEmbeddedClawSpecKeyword finds keyword with args in multiline text", () => {
-  const text = "Please do this:\ncs-continue hello world\nThanks!";
-  const result = extractEmbeddedClawSpecKeyword(text);
-  assert.equal(result?.kind, "continue");
-  assert.equal(result?.args, "hello world");
-});
-
-test("extractEmbeddedClawSpecKeyword finds slash-prefixed keyword in multiline text", () => {
-  const text = "Summary:\n/cs-work\nProceed please.";
-  const result = extractEmbeddedClawSpecKeyword(text);
-  assert.equal(result?.kind, "work");
-});
-
-test("extractEmbeddedClawSpecKeyword returns direct match for single-line input", () => {
-  const result = extractEmbeddedClawSpecKeyword("cs-status");
-  assert.equal(result?.kind, "status");
-});
-
-test("extractEmbeddedClawSpecKeyword returns null when no keyword present", () => {
-  assert.equal(extractEmbeddedClawSpecKeyword("no keywords here"), null);
-  assert.equal(extractEmbeddedClawSpecKeyword("just a normal message\nwith multiple lines"), null);
-});

package/test/notifier.test.ts

@@ -1,29 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { ClawSpecNotifier } from "../src/watchers/notifier.ts";
-import { createLogger } from "./helpers/harness.ts";
-
-test("notifier formats Discord channel target correctly", async () => {
-  const sent: Array<{ to: string; text: string }> = [];
-  const notifier = new ClawSpecNotifier({
-    api: {
-      config: {},
-      runtime: {
-        channel: {
-          discord: {
-            sendMessageDiscord: async (to: string, text: string) => {
-              sent.push({ to, text });
-            },
-          },
-          telegram: {},
-          slack: {},
-          signal: {},
-        },
-      },
-    } as any,
-    logger: createLogger() as any,
-  });
-
-  await notifier.send("discord:1474686041939251210:default:main", "hello");
-  assert.deepEqual(sent, [{ to: "channel:1474686041939251210", text: "hello" }]);
-});

package/test/openspec-dependency.test.ts

@@ -1,68 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import path from "node:path";
-import { buildOpenSpecInstallMessage, ensureOpenSpecCli } from "../src/dependencies/openspec.ts";
-
-const ROOT_PREFIX = process.platform === "win32" ? "C:\\clawspec-test" : "/tmp/clawspec-test";
-
-const LOCAL_COMMAND = path.join(
-  ROOT_PREFIX,
-  "node_modules",
-  ".bin",
-  process.platform === "win32" ? "openspec.cmd" : "openspec",
-);
-
-test("ensureOpenSpecCli uses the global openspec command when available", async () => {
-  const calls: Array<{ command: string; args: string[] }> = [];
-  const result = await ensureOpenSpecCli({
-    pluginRoot: ROOT_PREFIX,
-    runner: async ({ command, args }) => {
-      calls.push({ command, args });
-      if (command === LOCAL_COMMAND) {
-        return { code: 1, stdout: "", stderr: "not found" };
-      }
-      if (command === "openspec") {
-        return { code: 0, stdout: "1.2.0\n", stderr: "" };
-      }
-      return { code: 1, stdout: "", stderr: "unexpected command" };
-    },
-  });
-
-  assert.equal(result.source, "global");
-  assert.equal(result.version, "1.2.0");
-  assert.equal(calls.some((call) => call.command === "npm"), false);
-});
-
-test("ensureOpenSpecCli installs plugin-local openspec when local and global are unavailable", async () => {
-  const calls: Array<{ command: string; args: string[] }> = [];
-  const result = await ensureOpenSpecCli({
-    pluginRoot: ROOT_PREFIX,
-    runner: async ({ command, args }) => {
-      calls.push({ command, args });
-      if (command === LOCAL_COMMAND) {
-        const versionChecks = calls.filter((call) => call.command === LOCAL_COMMAND && call.args[0] === "--version").length;
-        if (versionChecks >= 2) {
-          return { code: 0, stdout: "1.2.3\n", stderr: "" };
-        }
-        return { code: 1, stdout: "", stderr: "not found" };
-      }
-      if (command === "openspec") {
-        return { code: 1, stdout: "", stderr: "not found" };
-      }
-      if (command === "npm") {
-        return { code: 0, stdout: "installed", stderr: "" };
-      }
-      return { code: 1, stdout: "", stderr: "unexpected command" };
-    },
-  });
-
-  assert.equal(result.source, "local");
-  assert.equal(result.version, "1.2.3");
-  assert.equal(calls.some((call) => call.command === "npm"), true);
-});
-
-test("buildOpenSpecInstallMessage includes install command", () => {
-  const message = buildOpenSpecInstallMessage("not found");
-  assert.match(message, /npm install -g @fission-ai\/openspec/);
-  assert.match(message, /not found/);
-});

package/test/paths-utils.test.ts

@@ -1,30 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import os from "node:os";
-import path from "node:path";
-import { resolveUserPath } from "../src/utils/paths.ts";
-
-test("resolveUserPath expands home directory shorthand", () => {
-  const actual = resolveUserPath("~/Desktop/workspace/ai_workspace", "/tmp/base");
-  const expected = path.join(os.homedir(), "Desktop", "workspace", "ai_workspace");
-  assert.equal(actual, expected);
-});
-
-test("resolveUserPath resolves relative path against base directory", () => {
-  const base = path.join(os.homedir(), "clawspec", "workspace");
-  const actual = resolveUserPath("demo-app", base);
-  assert.equal(actual, path.resolve(base, "demo-app"));
-});
-
-test("resolveUserPath keeps POSIX absolute path absolute", () => {
-  const absolute = "/tmp/clawspec-posix-absolute";
-  const actual = resolveUserPath(absolute, "/tmp/base");
-  assert.equal(actual, path.normalize(absolute));
-});
-
-test("resolveUserPath keeps Windows drive absolute path absolute on all platforms", () => {
-  const absolute = "C:\\Users\\dev\\workspace\\demo";
-  const actual = resolveUserPath(absolute, "/tmp/base");
-  assert.equal(actual, path.normalize(absolute));
-});
-

package/test/pause-cancel.test.ts

@@ -1,55 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { createServiceHarness, seedPlanningProject } from "./helpers/harness.ts";
-
-test("pause requests watcher interrupt", async () => {
-  const harness = await createServiceHarness("clawspec-pause-");
-  const { service, stateStore, watcherManager, repoPath, workspacePath, changeDir } = harness;
-  const channelKey = "discord:pause:default:main";
-
-  await seedPlanningProject(stateStore, channelKey, {
-    workspacePath,
-    repoPath,
-    projectName: "demo-app",
-    changeName: "pause-change",
-    changeDir,
-    phase: "implementing",
-    status: "running",
-    planningDirty: false,
-    execution: { action: "work", state: "running", mode: "apply" },
-  });
-
-  const result = await service.pauseProject(channelKey);
-  const project = await stateStore.getActiveProject(channelKey);
-
-  assert.match(result.text ?? "", /Pause Requested/);
-  assert.equal(project?.pauseRequested, true);
-  assert.deepEqual(watcherManager.interruptCalls, [{ channelKey, reason: "paused by user" }]);
-  assert.deepEqual(watcherManager.wakeCalls, [channelKey]);
-});
-
-test("cancel requests watcher interrupt", async () => {
-  const harness = await createServiceHarness("clawspec-cancel-");
-  const { service, stateStore, watcherManager, repoPath, workspacePath, changeDir } = harness;
-  const channelKey = "discord:cancel:default:main";
-
-  await seedPlanningProject(stateStore, channelKey, {
-    workspacePath,
-    repoPath,
-    projectName: "demo-app",
-    changeName: "cancel-change",
-    changeDir,
-    phase: "implementing",
-    status: "running",
-    planningDirty: false,
-    execution: { action: "work", state: "running", mode: "apply" },
-  });
-
-  const result = await service.cancelProject(channelKey);
-  const project = await stateStore.getActiveProject(channelKey);
-
-  assert.match(result.text ?? "", /Cancellation Requested/);
-  assert.equal(project?.cancelRequested, true);
-  assert.deepEqual(watcherManager.interruptCalls, [{ channelKey, reason: "cancelled by user" }]);
-  assert.deepEqual(watcherManager.wakeCalls, [channelKey]);
-});