clawspec 1.0.0

package/test/keywords.test.ts

@@ -0,0 +1,80 @@
+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("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 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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,67 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import path from "node:path";
+import { ensureOpenSpecCli, OPENSPEC_PACKAGE_NAME } 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 a plugin-local openspec when none is available", async () => {
+  const calls: Array<{ command: string; args: string[] }> = [];
+  let localCheckCount = 0;
+
+  const result = await ensureOpenSpecCli({
+    pluginRoot: ROOT_PREFIX,
+    runner: async ({ command, args }) => {
+      calls.push({ command, args });
+      if (command === LOCAL_COMMAND) {
+        localCheckCount += 1;
+        if (localCheckCount === 1) {
+          return { code: 1, stdout: "", stderr: "not found" };
+        }
+        return { code: 0, stdout: "1.2.0\n", stderr: "" };
+      }
+      if (command === "openspec") {
+        return { code: 1, stdout: "", stderr: "not found" };
+      }
+      if (command === "npm") {
+        return { code: 0, stdout: "installed\n", stderr: "" };
+      }
+      return { code: 1, stdout: "", stderr: "unexpected command" };
+    },
+  });
+
+  assert.equal(result.source, "local");
+  assert.equal(result.version, "1.2.0");
+  assert.equal(
+    calls.some((call) => call.command === "npm" && call.args.includes(OPENSPEC_PACKAGE_NAME)),
+    true,
+  );
+});

package/test/pause-cancel.test.ts

@@ -0,0 +1,55 @@
+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]);
+});

package/test/planning-journal.test.ts

@@ -0,0 +1,69 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import os from "node:os";
+import path from "node:path";
+import { mkdtemp } from "node:fs/promises";
+import { PlanningJournalStore } from "../src/planning/journal.ts";
+
+test("planning journal reports clean when snapshot matches current content", async () => {
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), "clawspec-journal-clean-"));
+  const journalPath = path.join(tempRoot, "planning-journal.jsonl");
+  const snapshotPath = path.join(tempRoot, "planning-journal.snapshot.json");
+  const store = new PlanningJournalStore(journalPath);
+
+  await store.append({
+    timestamp: "2026-03-23T07:00:00.000Z",
+    changeName: "hello",
+    role: "user",
+    text: "keep the two existing endpoints",
+  });
+  await store.writeSnapshot(snapshotPath, "hello", "2026-03-23T07:05:00.000Z");
+
+  assert.equal(await store.hasUnsyncedChanges("hello", snapshotPath), false);
+});
+
+test("planning journal reports dirty when a new entry is appended after the snapshot", async () => {
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), "clawspec-journal-dirty-"));
+  const journalPath = path.join(tempRoot, "planning-journal.jsonl");
+  const snapshotPath = path.join(tempRoot, "planning-journal.snapshot.json");
+  const store = new PlanningJournalStore(journalPath);
+
+  await store.append({
+    timestamp: "2026-03-23T07:00:00.000Z",
+    changeName: "hello",
+    role: "user",
+    text: "keep the two existing endpoints",
+  });
+  await store.writeSnapshot(snapshotPath, "hello", "2026-03-23T07:05:00.000Z");
+  await store.append({
+    timestamp: "2026-03-23T07:10:00.000Z",
+    changeName: "hello",
+    role: "user",
+    text: "add two new interfaces to the same change",
+  });
+
+  assert.equal(await store.hasUnsyncedChanges("hello", snapshotPath), true);
+});
+
+test("planning journal falls back to lastSyncedAt when no snapshot exists yet", async () => {
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), "clawspec-journal-fallback-"));
+  const journalPath = path.join(tempRoot, "planning-journal.jsonl");
+  const snapshotPath = path.join(tempRoot, "planning-journal.snapshot.json");
+  const store = new PlanningJournalStore(journalPath);
+
+  await store.append({
+    timestamp: "2026-03-23T07:00:00.000Z",
+    changeName: "hello",
+    role: "user",
+    text: "keep the two existing endpoints",
+  });
+
+  assert.equal(
+    await store.hasUnsyncedChanges("hello", snapshotPath, "2026-03-23T07:05:00.000Z"),
+    false,
+  );
+  assert.equal(
+    await store.hasUnsyncedChanges("hello", snapshotPath, "2026-03-23T06:55:00.000Z"),
+    true,
+  );
+});

package/test/plugin-registration.test.ts

@@ -0,0 +1,35 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import os from "node:os";
+import path from "node:path";
+import { mkdtemp } from "node:fs/promises";
+import plugin from "../src/index.ts";
+
+test("plugin registers the clawspec command", async () => {
+  const stateDir = await mkdtemp(path.join(os.tmpdir(), "clawspec-plugin-register-"));
+  const commandNames: string[] = [];
+
+  plugin.register({
+    pluginConfig: {},
+    config: {},
+    logger: {
+      info() {},
+      warn() {},
+      error() {},
+      debug() {},
+    },
+    runtime: {
+      state: {
+        resolveStateDir: () => stateDir,
+      },
+    },
+    registerService() {},
+    registerCli() {},
+    registerCommand(command: { name: string }) {
+      commandNames.push(command.name);
+    },
+    on() {},
+  } as any);
+
+  assert.deepEqual(commandNames, ["clawspec"]);
+});

package/test/project-memory.test.ts

@@ -0,0 +1,42 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import os from "node:os";
+import path from "node:path";
+import { mkdtemp, mkdir } from "node:fs/promises";
+import {
+  DuplicateRememberedProjectError,
+  ProjectMemoryStore,
+  RememberedProjectPathInvalidError,
+} from "../src/memory/store.ts";
+
+test("project memory store remembers, lists, overwrites, and validates paths", async () => {
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), "clawspec-memory-"));
+  const memoryFile = path.join(tempRoot, "project-memory.json");
+  const repoA = path.join(tempRoot, "repo-a");
+  const repoB = path.join(tempRoot, "repo-b");
+  await mkdir(repoA, { recursive: true });
+  await mkdir(repoB, { recursive: true });
+
+  const store = new ProjectMemoryStore(memoryFile);
+  await store.initialize();
+
+  const created = await store.remember("demo", repoA);
+  assert.equal(created.created, true);
+  assert.equal(created.overwritten, false);
+
+  const entries = await store.list();
+  assert.equal(entries.length, 1);
+  assert.equal(entries[0].repoPath, repoA);
+
+  await assert.rejects(() => store.remember("demo", repoB), DuplicateRememberedProjectError);
+
+  const overwritten = await store.remember("demo", repoB, { overwrite: true });
+  assert.equal(overwritten.overwritten, true);
+  assert.equal((await store.resolveForUse("demo")).repoPath, repoB);
+
+  const staleFile = path.join(tempRoot, "stale-memory.json");
+  const staleStore = new ProjectMemoryStore(staleFile);
+  await staleStore.initialize();
+  await staleStore.remember("stale", path.join(tempRoot, "missing"));
+  await assert.rejects(() => staleStore.resolveForUse("stale"), RememberedProjectPathInvalidError);
+});

package/test/proposal.test.ts

@@ -0,0 +1,24 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import path from "node:path";
+import { pathExists } from "../src/utils/fs.ts";
+import { createServiceHarness } from "./helpers/harness.ts";
+
+test("proposal creates scaffold and rollback baseline", async () => {
+  const harness = await createServiceHarness("clawspec-proposal-");
+  const { service, stateStore, workspacePath } = harness;
+  const channelKey = "discord:proposal:default:main";
+
+  await service.startProject(channelKey);
+  await service.useProject(channelKey, "demo-app");
+  const result = await service.proposalProject(channelKey, "support-weather Add weather endpoints");
+  const project = await stateStore.getActiveProject(channelKey);
+  const changeDir = path.join(workspacePath, "demo-app", "openspec", "changes", "support-weather");
+
+  assert.match(result.text ?? "", /Proposal Ready/);
+  assert.equal(project?.changeName, "support-weather");
+  assert.equal(project?.status, "ready");
+  assert.equal(project?.phase, "proposal");
+  assert.equal(await pathExists(path.join(changeDir, ".openspec.yaml")), true);
+  assert.equal(await pathExists(project?.rollback?.manifestPath ?? ""), true);
+});

package/test/queue-planning.test.ts

@@ -0,0 +1,247 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { pathExists, readJsonFile, writeUtf8 } from "../src/utils/fs.ts";
+import { PlanningJournalStore } from "../src/planning/journal.ts";
+import { getRepoStatePaths } from "../src/utils/paths.ts";
+import { createServiceHarness, seedPlanningProject } from "./helpers/harness.ts";
+
+test("apply prepares visible planning", async () => {
+  const harness = await createServiceHarness("clawspec-apply-queue-");
+  const { service, stateStore, watcherManager, repoPath, workspacePath, changeDir } = harness;
+  const channelKey = "discord:apply-queue:default:main";
+
+  await seedPlanningProject(stateStore, channelKey, {
+    workspacePath,
+    repoPath,
+    projectName: "demo-app",
+    changeName: "weather-plan",
+    changeDir,
+    phase: "proposal",
+    status: "ready",
+    planningDirty: true,
+  });
+
+  const repoStatePaths = getRepoStatePaths(repoPath, "archives");
+  await writeUtf8(repoStatePaths.executionControlFile, "{\"state\":\"running\"}\n");
+  await writeUtf8(repoStatePaths.executionResultFile, "{\"status\":\"running\"}\n");
+  await writeUtf8(repoStatePaths.workerProgressFile, "{\"kind\":\"task_start\"}\n");
+
+  const result = await service.queuePlanningProject(channelKey, "apply");
+  const project = await stateStore.getActiveProject(channelKey);
+
+  assert.match(result.text ?? "", /Planning Ready/);
+  assert.equal(project?.status, "ready");
+  assert.equal(project?.execution, undefined);
+  assert.deepEqual(watcherManager.wakeCalls, []);
+  assert.equal(await pathExists(repoStatePaths.executionControlFile), false);
+  assert.equal(await pathExists(repoStatePaths.executionResultFile), false);
+  assert.equal(await pathExists(repoStatePaths.workerProgressFile), false);
+});
+
+test("continue routes back to planning when dirty", async () => {
+  const harness = await createServiceHarness("clawspec-continue-planning-");
+  const { service, stateStore, watcherManager, repoPath, workspacePath, changeDir } = harness;
+  const channelKey = "discord:continue-planning:default:main";
+
+  await seedPlanningProject(stateStore, channelKey, {
+    workspacePath,
+    repoPath,
+    projectName: "demo-app",
+    changeName: "dirty-plan",
+    changeDir,
+    phase: "tasks",
+    status: "paused",
+    planningDirty: true,
+  });
+
+  const result = await service.continueProject(channelKey);
+  const project = await stateStore.getActiveProject(channelKey);
+
+  assert.match(result.text ?? "", /Planning Ready/);
+  assert.equal(project?.status, "ready");
+  assert.equal(project?.execution, undefined);
+  assert.deepEqual(watcherManager.wakeCalls, []);
+});
+
+test("apply still prepares visible planning review when attached and journal matches the last snapshot", async () => {
+  const harness = await createServiceHarness("clawspec-apply-no-new-plan-");
+  const { service, stateStore, watcherManager, repoPath, workspacePath, changeDir } = harness;
+  const channelKey = "discord:apply-no-new-plan:default:main";
+
+  await seedPlanningProject(stateStore, channelKey, {
+    workspacePath,
+    repoPath,
+    projectName: "demo-app",
+    changeName: "weather-plan",
+    changeDir,
+    phase: "tasks",
+    status: "ready",
+    planningDirty: true,
+  });
+
+  const repoStatePaths = getRepoStatePaths(repoPath, "archives");
+  const journalStore = new PlanningJournalStore(repoStatePaths.planningJournalFile);
+  await journalStore.append({
+    timestamp: new Date(Date.now() - 60_000).toISOString(),
+    changeName: "weather-plan",
+    role: "user",
+    text: "keep the same two API endpoints",
+  });
+  await journalStore.writeSnapshot(repoStatePaths.planningJournalSnapshotFile, "weather-plan");
+
+  const result = await service.queuePlanningProject(channelKey, "apply");
+  const project = await stateStore.getActiveProject(channelKey);
+
+  assert.match(result.text ?? "", /Planning Ready/);
+  assert.equal(project?.status, "ready");
+  assert.match(project?.latestSummary ?? "", /Waiting for cs-plan in chat/);
+  assert.deepEqual(watcherManager.wakeCalls, []);
+});
+
+test("apply reports no new planning notes when the chat context is detached", async () => {
+  const harness = await createServiceHarness("clawspec-apply-detached-no-new-plan-");
+  const { service, stateStore, watcherManager, repoPath, workspacePath, changeDir } = harness;
+  const channelKey = "discord:apply-detached-no-new-plan:default:main";
+
+  await seedPlanningProject(stateStore, channelKey, {
+    workspacePath,
+    repoPath,
+    projectName: "demo-app",
+    changeName: "weather-plan",
+    changeDir,
+    phase: "tasks",
+    status: "ready",
+    planningDirty: true,
+  });
+
+  await stateStore.updateProject(channelKey, (current) => ({
+    ...current,
+    contextMode: "detached",
+  }));
+
+  const repoStatePaths = getRepoStatePaths(repoPath, "archives");
+  const journalStore = new PlanningJournalStore(repoStatePaths.planningJournalFile);
+  await journalStore.writeSnapshot(repoStatePaths.planningJournalSnapshotFile, "weather-plan");
+
+  const result = await service.queuePlanningProject(channelKey, "apply");
+  const project = await stateStore.getActiveProject(channelKey);
+
+  assert.match(result.text ?? "", /No New Planning Notes/);
+  assert.equal(project?.planningJournal?.dirty, false);
+  assert.deepEqual(watcherManager.wakeCalls, []);
+});
+
+test("cs-plan runs visible planning sync and writes a fresh snapshot", async () => {
+  const harness = await createServiceHarness("clawspec-visible-plan-");
+  const { service, stateStore, repoPath } = harness;
+  const channelKey = "discord:visible-plan:default:main";
+  const promptContext = {
+    trigger: "user",
+    channel: "discord",
+    channelId: "visible-plan",
+    accountId: "default",
+    conversationId: "main",
+    sessionKey: "agent:main:discord:channel:visible-plan",
+  };
+
+  await service.startProject(channelKey);
+  await service.useProject(channelKey, "demo-app");
+  await service.proposalProject(channelKey, "demo-change Demo change");
+  await service.recordPlanningMessageFromContext(promptContext, "add another API endpoint");
+
+  const injected = await service.handleBeforePromptBuild(
+    { prompt: "cs-plan", messages: [] },
+    promptContext,
+  );
+  const runningProject = await stateStore.getActiveProject(channelKey);
+
+  assert.match(injected?.prependContext ?? "", /ClawSpec planning sync is active for this turn/);
+  assert.equal(runningProject?.status, "planning");
+  assert.equal(runningProject?.phase, "planning_sync");
+
+  await service.handleAgentEnd(
+    { messages: [], success: true, durationMs: 10 },
+    promptContext,
+  );
+
+  const finalized = await stateStore.getActiveProject(channelKey);
+  const repoStatePaths = getRepoStatePaths(repoPath, "archives");
+  const snapshotExists = await pathExists(repoStatePaths.planningJournalSnapshotFile);
+  const snapshot = await readJsonFile<any>(repoStatePaths.planningJournalSnapshotFile, null);
+
+  assert.equal(finalized?.status, "ready");
+  assert.equal(finalized?.phase, "tasks");
+  assert.equal(finalized?.planningJournal?.dirty, false);
+  assert.equal(snapshotExists, true);
+  assert.equal(snapshot?.changeName, "demo-change");
+});
+
+test("cs-plan clears stale execution control artifacts from earlier worker runs", async () => {
+  const harness = await createServiceHarness("clawspec-visible-plan-cleanup-");
+  const { service, stateStore, repoPath } = harness;
+  const channelKey = "discord:visible-plan-cleanup:default:main";
+  const promptContext = {
+    trigger: "user",
+    channel: "discord",
+    channelId: "visible-plan-cleanup",
+    accountId: "default",
+    conversationId: "main",
+    sessionKey: "agent:main:discord:channel:visible-plan-cleanup",
+  };
+
+  await service.startProject(channelKey);
+  await service.useProject(channelKey, "demo-app");
+  await service.proposalProject(channelKey, "demo-change Demo change");
+  await service.recordPlanningMessageFromContext(promptContext, "add another API endpoint");
+
+  const repoStatePaths = getRepoStatePaths(repoPath, "archives");
+  await writeUtf8(repoStatePaths.executionControlFile, "{\"state\":\"running\"}\n");
+  await writeUtf8(repoStatePaths.executionResultFile, "{\"status\":\"running\"}\n");
+  await writeUtf8(repoStatePaths.workerProgressFile, "{\"kind\":\"task_start\"}\n");
+
+  await service.handleBeforePromptBuild(
+    { prompt: "cs-plan", messages: [] },
+    promptContext,
+  );
+
+  await service.handleAgentEnd(
+    { messages: [], success: true, durationMs: 10 },
+    promptContext,
+  );
+
+  assert.equal(await pathExists(repoStatePaths.executionControlFile), false);
+  assert.equal(await pathExists(repoStatePaths.executionResultFile), false);
+  assert.equal(await pathExists(repoStatePaths.workerProgressFile), false);
+});
+
+test("ordinary planning discussion does not preload planning artifacts or propose skill", async () => {
+  const harness = await createServiceHarness("clawspec-discussion-guard-");
+  const { service } = harness;
+  const channelKey = "discord:discussion-guard:default:main";
+  const promptContext = {
+    trigger: "user",
+    channel: "discord",
+    channelId: "discussion-guard",
+    accountId: "default",
+    conversationId: "main",
+    sessionKey: "agent:main:discord:channel:discussion-guard",
+  };
+
+  await service.startProject(channelKey);
+  await service.useProject(channelKey, "demo-app");
+  await service.proposalProject(channelKey, "demo-change Demo change");
+
+  const injected = await service.handleBeforePromptBuild(
+    { prompt: "再增加一个接口", messages: [] },
+    promptContext,
+  );
+
+  assert.match(injected?.prependContext ?? "", /ClawSpec planning discussion mode is active/);
+  assert.doesNotMatch(injected?.prependContext ?? "", /openspec[\\/].*proposal\.md/);
+  assert.doesNotMatch(injected?.prependContext ?? "", /openspec[\\/].*design\.md/);
+  assert.doesNotMatch(injected?.prependContext ?? "", /openspec[\\/].*tasks\.md/);
+  assert.match(injected?.prependContext ?? "", /Do not say planning has started, queued, refreshed, synced, or completed/);
+  assert.match(injected?.prependContext ?? "", /explicitly tell the user that `cs-plan` is the next step before any further implementation/);
+  assert.match(injected?.prependContext ?? "", /do not say the next step is `cs-work`/);
+  assert.doesNotMatch(injected?.prependSystemContext ?? "", /openspec-propose/i);
+});