clawspec 1.0.9 → 1.0.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawspec",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "type": "module",
   "description": "OpenClaw plugin that orchestrates OpenSpec project workflows with visible main-agent execution.",
   "keywords": [

package/src/orchestrator/service.ts

@@ -675,6 +675,13 @@ export class ClawSpecService {
         repoStatePaths.planningJournalSnapshotFile,
         project.planningJournal?.lastSyncedAt,
       );
+      const snapshot = await journalStore.readSnapshot(repoStatePaths.planningJournalSnapshotFile);
+      const digest = await journalStore.digest(project.changeName);
+      this.logger.info(`[clawspec] cs-work check for ${project.changeName}:`);
+      this.logger.info(`  - hasUnsyncedChanges: ${hasUnsyncedChanges}`);
+      this.logger.info(`  - Snapshot: entryCount=${snapshot?.entryCount}, lastEntryAt=${snapshot?.lastEntryAt}, hash=${snapshot?.contentHash?.slice(0, 8)}`);
+      this.logger.info(`  - Current digest: entryCount=${digest.entryCount}, lastEntryAt=${digest.lastEntryAt}, hash=${digest.contentHash.slice(0, 8)}`);
+      this.logger.info(`  - fallbackLastSyncedAt: ${project.planningJournal?.lastSyncedAt}`);
       if (!hasUnsyncedChanges) {
         const isDetached = !isProjectContextAttached(project);
         if (isDetached) {
@@ -2460,9 +2467,12 @@ export class ClawSpecService {
       }
     }
 
-    if (!journalDirty) {
-      await journalStore.writeSnapshot(repoStatePaths.planningJournalSnapshotFile, project.changeName, timestamp);
-    }
+    await journalStore.writeSnapshot(repoStatePaths.planningJournalSnapshotFile, project.changeName, timestamp);
+    const writtenSnapshot = await journalStore.readSnapshot(repoStatePaths.planningJournalSnapshotFile);
+    const currentDigest = await journalStore.digest(project.changeName);
+    this.logger.info(`[clawspec] Planning snapshot written for ${project.changeName}:`);
+    this.logger.info(`  - Snapshot: entryCount=${writtenSnapshot?.entryCount}, lastEntryAt=${writtenSnapshot?.lastEntryAt}, hash=${writtenSnapshot?.contentHash?.slice(0, 8)}`);
+    this.logger.info(`  - Current digest: entryCount=${currentDigest.entryCount}, lastEntryAt=${currentDigest.lastEntryAt}, hash=${currentDigest.contentHash.slice(0, 8)}`);
     await this.writeLatestSummary(repoStatePaths, latestSummary);
 
     const finalized = await this.stateStore.updateProject(project.channelKey, (current) => ({

package/src/worker/prompts.ts

@@ -188,13 +188,19 @@ export function buildPlanningPrependContext(params: {
         "Required workflow for this turn:",
         "0. The active change directory shown above is the only OpenSpec change directory you may inspect or modify in this turn.",
         "1. Read planning-journal.jsonl, .openspec.yaml, and any planning artifacts that already exist.",
-        "2. Treat the prefetched OpenSpec instruction files in this context as the authoritative source for artifact structure, output paths, and writing guidance.",
-        "3. Use the current visible chat context plus the planning journal to decide whether there are substantive new requirements, constraints, or design changes since the last planning sync.",
-        "4. The allowed planning scope is limited to what is explicitly supported by the current user message, the planning journal, existing dependency artifacts, and the prefetched OpenSpec instructions.",
-        "5. Do not invent endpoints, features, constraints, files, acceptance criteria, test scenarios, or architecture details that are not grounded in those sources.",
-        "6. If there is no substantive planning change, say so clearly in chat and do not rewrite artifacts unnecessarily.",
-        "7. If artifacts are missing or stale, update `proposal`, `specs`, `design`, and `tasks` in dependency order using those prefetched OpenSpec instruction files.",
-        "8. Do not generate or rewrite planning artifacts from ad-hoc structure guesses; follow OpenSpec instruction/template constraints only.",
+        "2. **CRITICAL**: The prefetched OpenSpec instruction blocks below contain the EXACT prompts you must follow to generate each artifact.",
+        "3. Each instruction block shows:",
+        "   - Instruction: The EXACT prompt/guidance for generating that artifact",
+        "   - Template: The structure/format to follow",
+        "4. **YOU MUST**:",
+        "   - Treat each instruction block's 'Instruction' section as if it were given to you directly by the user",
+        "   - Follow the instruction's requirements, structure, and sections EXACTLY as specified",
+        "   - Use the planning journal and user requirements to fill in the CONTENT, but follow the instruction for STRUCTURE",
+        "   - Do NOT create your own format - the instruction tells you exactly what to write and how",
+        "5. The allowed planning scope is limited to what is explicitly supported by the current user message, the planning journal, existing dependency artifacts, and the prefetched OpenSpec instructions.",
+        "6. Do not invent endpoints, features, constraints, files, acceptance criteria, test scenarios, or architecture details that are not grounded in those sources.",
+        "7. If there is no substantive planning change, say so clearly in chat and do not rewrite artifacts unnecessarily.",
+        "8. Update artifacts in dependency order: proposal → specs → design → tasks, using the prefetched instruction prompts for each.",
         "9. Before updating each artifact, post a short chat update naming the artifact you are about to refresh.",
         "10. After updating each artifact, post a short chat update describing what changed and what artifact comes next.",
         "11. For any implementation-oriented task item, ensure tasks.md contains an explicit testing task (new tests or updated tests) and a validation command.",

package/test/planning-journal.test.ts

@@ -67,3 +67,58 @@ test("planning journal falls back to lastSyncedAt when no snapshot exists yet",
     true,
   );
 });
+
+test("snapshot is always written after planning sync regardless of journal dirty state", async () => {
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), "clawspec-snapshot-always-"));
+  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-27T03:00:00.000Z",
+    changeName: "test",
+    role: "user",
+    text: "initial requirement",
+  });
+
+  const snapshot1 = await store.writeSnapshot(snapshotPath, "test", "2026-03-27T03:05:00.000Z");
+  assert.equal(snapshot1.entryCount, 1);
+
+  await store.append({
+    timestamp: "2026-03-27T03:10:00.000Z",
+    changeName: "test",
+    role: "assistant",
+    text: "planning sync response",
+  });
+
+  const snapshot2 = await store.writeSnapshot(snapshotPath, "test", "2026-03-27T03:15:00.000Z");
+  assert.equal(snapshot2.entryCount, 2);
+  assert.equal(await store.hasUnsyncedChanges("test", snapshotPath), false);
+});
+
+test("snapshot correctly captures all journal entries including assistant messages", async () => {
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), "clawspec-snapshot-complete-"));
+  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-27T03:00:00.000Z",
+    changeName: "test",
+    role: "user",
+    text: "user requirement",
+  });
+  await store.append({
+    timestamp: "2026-03-27T03:05:00.000Z",
+    changeName: "test",
+    role: "assistant",
+    text: "assistant response",
+  });
+
+  const snapshot = await store.writeSnapshot(snapshotPath, "test");
+  const digest = await store.digest("test");
+
+  assert.equal(snapshot.entryCount, digest.entryCount);
+  assert.equal(snapshot.lastEntryAt, digest.lastEntryAt);
+  assert.equal(snapshot.contentHash, digest.contentHash);
+});