Merge pull request #175 from kaanozhan/fix/spec-sync-initial-status

fix(specs): don't walk merged specs back from done when importing their tasks

Author: kaanozhan

src/main/specManager.js

@@ -904,6 +904,30 @@ function getSpecFootprint(projectPath, slug) {
   return parseFootprintMarkdown(plan);
 }
 
+// A task imported for the first time starts from what the spec itself
+// records, not from 'pending'. Specs are implemented in worktrees whose task
+// state lives in a tasks.json nobody commits, so a finished spec can arrive
+// by merge with its tasks.md but none of its tasks — and importing those as
+// pending walked it from `done` back to `tasks_generated`. The spec's own
+// files travel with it: a `done` phase means every task finished, and the
+// implement loop writes one `## T<n> — …` outcome entry per finished task.
+const OUTCOME_TASK_RE = /^##\s+(T\d{1,3})\b/gm;
+
+function completedTaskIdsFromOutcome(content) {
+  const ids = new Set();
+  if (!content) return ids;
+  for (const m of content.matchAll(OUTCOME_TASK_RE)) ids.add(m[1]);
+  return ids;
+}
+
+function initialTaskState(status, outcomeIds, taskId, now) {
+  if (status && status.phase === 'done') {
+    return { status: 'completed', completedAt: status.last_phase_at || status.updated_at || now };
+  }
+  if (outcomeIds.has(taskId)) return { status: 'completed', completedAt: now };
+  return { status: 'pending', completedAt: null };
+}
+
 function syncTasksFromMarkdown(projectPath, slug) {
   const tasksMdPath = path.join(getSpecDir(projectPath, slug), TASKS_FILE);
   const md = readFileSafe(tasksMdPath);
@@ -923,6 +947,10 @@ function syncTasksFromMarkdown(projectPath, slug) {
   const now = new Date().toISOString();
   const generatedIds = [];
   let added = 0, updated = 0, unchanged = 0;
+  const specStatus = readStatus(projectPath, slug);
+  const outcomeIds = completedTaskIdsFromOutcome(
+    readFileSafe(path.join(getSpecDir(projectPath, slug), OUTCOME_FILE))
+  );
 
   for (const item of parsed) {
     const sourceMarker = `spec:${slug}:${item.taskId}`;
@@ -938,18 +966,19 @@ function syncTasksFromMarkdown(projectPath, slug) {
         unchanged++;
       }
     } else {
+      const initial = initialTaskState(specStatus, outcomeIds, item.taskId, now);
       tasksData.tasks.push({
         id,
         title: item.description,
         description: '',
         source: sourceMarker,
-        status: 'pending',
+        status: initial.status,
         priority: 'medium',
         category: 'feature',
         context: `From spec: ${slug}`,
         createdAt: now,
         updatedAt: now,
-        completedAt: null
+        completedAt: initial.completedAt
       });
       tasksData.metadata = tasksData.metadata || {};
       tasksData.metadata.totalCreated = (tasksData.metadata.totalCreated || 0) + 1;

test/specTasksSync.test.js

@@ -278,3 +278,67 @@ test('two Frames arguing over one spec stop being answered', () => {
   assert.ok(corrected <= 3, `and then stops answering (corrected ${corrected} times)`);
   assert.equal(phaseNow(), 'done', 'the last write is the other Frame\'s, not ours');
 });
+
+// ─── first import starts from what the spec records ─────────
+
+function setStatus(fields) {
+  const statusPath = path.join(specDir(), 'status.json');
+  const s = JSON.parse(fs.readFileSync(statusPath, 'utf8'));
+  fs.writeFileSync(statusPath, JSON.stringify({ ...s, ...fields }, null, 2), 'utf8');
+}
+
+test('a finished spec arriving by merge is imported completed, not walked back', () => {
+  // Implemented in a worktree: its tasks were completed in a tasks.json nobody
+  // commits, so main gets tasks.md and a `done` status.json but no tasks.
+  // Importing them as pending used to rewind the spec to tasks_generated.
+  writeStatus();
+  writeTasksMd(NON_ASCENDING);
+  setStatus({ phase: 'done', last_phase_at: '2026-10-08T13:29:41.859Z' });
+
+  specManager.syncTasksFromMarkdown(projectDir, SLUG);
+
+  const tasks = readSpecTasks();
+  assert.equal(tasks.length, 6);
+  assert.ok(tasks.every(t => t.status === 'completed'), 'every task imported completed');
+  assert.ok(tasks.every(t => t.completedAt === '2026-10-08T13:29:41.859Z'), 'completedAt is when the spec finished');
+
+  specManager.reconcilePhase(projectDir, SLUG, tasksManager.loadTasks(projectDir));
+  assert.equal(JSON.parse(fs.readFileSync(path.join(specDir(), 'status.json'), 'utf8')).phase, 'done');
+});
+
+test('an unfinished spec imports the tasks its outcome.md records as completed', () => {
+  writeStatus();
+  writeTasksMd(NON_ASCENDING);
+  setStatus({ phase: 'implementing' });
+  fs.writeFileSync(path.join(specDir(), 'outcome.md'), [
+    '## T01 — Expose the report path', '', 'Did it.', '', '---', '',
+    '## T05 — Handle a missing report', '', 'Did it. Mentions T03 in passing.', '', '---', ''
+  ].join('\n'), 'utf8');
+
+  specManager.syncTasksFromMarkdown(projectDir, SLUG);
+
+  const status = (id) => readSpecTasks().find(t => t.source === `spec:${SLUG}:${id}`).status;
+  assert.equal(status('T01'), 'completed');
+  assert.equal(status('T05'), 'completed');
+  assert.equal(status('T03'), 'pending', 'a task only mentioned in prose is not completed');
+  assert.equal(status('T02'), 'pending');
+  assert.equal(
+    specManager.derivePhase(projectDir, SLUG, 'implementing', tasksManager.loadTasks(projectDir)),
+    'implementing'
+  );
+});
+
+test('the initial state applies to first import only — user-set status still wins', () => {
+  writeStatus();
+  writeTasksMd(NON_ASCENDING);
+  setStatus({ phase: 'done' });
+  specManager.syncTasksFromMarkdown(projectDir, SLUG);
+
+  // The user reopens a task.
+  const data = tasksManager.loadTasks(projectDir);
+  data.tasks.find(t => t.source === `spec:${SLUG}:T03`).status = 'pending';
+  tasksManager.saveTasks(projectDir, data);
+
+  specManager.syncTasksFromMarkdown(projectDir, SLUG);
+  assert.equal(readSpecTasks().find(t => t.source === `spec:${SLUG}:T03`).status, 'pending');
+});