@assistkick/create 1.10.0 → 1.12.0

package/templates/assistkick-product-system/packages/shared/lib/workflow_engine.test.ts

@@ -1,7 +1,24 @@
-import { describe, it, mock, beforeEach } from 'node:test';
+import { describe, it, mock, beforeEach, after } from 'node:test';
 import assert from 'node:assert/strict';
+import { mkdtempSync, writeFileSync, mkdirSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
 import {WorkflowEngine} from "./workflow_engine.js";
 
+// ── Test Skills Directory ────────────────────────────────────────────
+const TEST_SKILLS_DIR = mkdtempSync(join(tmpdir(), 'wf-engine-test-skills-'));
+
+// Create test skill files
+for (const skillId of ['assistkick-developer', 'assistkick-code-reviewer', 'assistkick-debugger']) {
+  const dir = join(TEST_SKILLS_DIR, skillId);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, 'SKILL.md'), `# ${skillId} skill instructions`);
+}
+
+after(() => {
+  rmSync(TEST_SKILLS_DIR, { recursive: true, force: true });
+});
+
 // ── Default workflow graph (matches seeded data) ──────────────────────
 
 const DEFAULT_GRAPH = {
@@ -103,14 +120,20 @@ const createMockDb = (graphData = DEFAULT_GRAPH) => {
     'dev-agent-id': {
       id: 'dev-agent-id',
       name: 'Developer',
-      promptTemplate: 'Implement feature {{featureId}} in {{worktreePath}}',
+      model: 'claude-opus-4-6',
+      skills: '["assistkick-developer"]',
+      grounding: 'Implement feature {{featureId}} in {{worktreePath}}',
+      defaultGrounding: 'Implement feature {{featureId}} in {{worktreePath}}',
       projectId: null,
       isDefault: 1,
     },
     'rev-agent-id': {
       id: 'rev-agent-id',
       name: 'Reviewer',
-      promptTemplate: 'Review feature {{featureId}}',
+      model: 'claude-opus-4-6',
+      skills: '["assistkick-code-reviewer"]',
+      grounding: 'Review feature {{featureId}}',
+      defaultGrounding: 'Review feature {{featureId}}',
       projectId: null,
       isDefault: 1,
     },
@@ -243,7 +266,7 @@ const createMockClaudeService = () => ({
 });
 
 const createMockGitWorkflow = () => ({
-  createWorktree: mock.fn(async (featureId: string) => `/tmp/worktrees/${featureId}`),
+  createWorktree: mock.fn(async (featureId: string, _projectId: string) => `/tmp/worktrees/${featureId}`),
   removeWorktree: mock.fn(async () => {}),
   deleteBranch: mock.fn(async () => {}),
   commitChanges: mock.fn(async () => {}),
@@ -253,6 +276,8 @@ const createMockGitWorkflow = () => ({
   stash: mock.fn(async () => false),
   unstash: mock.fn(async () => {}),
   getDirtyFiles: mock.fn(async () => []),
+  pullDefaultBranch: mock.fn(async () => {}),
+  pushToRemote: mock.fn(async () => {}),
 });
 
 const createMockLog = () => mock.fn((_tag: string, _msg: string) => {});
@@ -277,6 +302,7 @@ describe('WorkflowEngine', () => {
         kanban: createMockKanban(),
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -294,6 +320,7 @@ describe('WorkflowEngine', () => {
         kanban: createMockKanban(),
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -311,6 +338,7 @@ describe('WorkflowEngine', () => {
         kanban: createMockKanban(),
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -344,6 +372,7 @@ describe('WorkflowEngine', () => {
         kanban: createMockKanban(),
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -357,6 +386,7 @@ describe('WorkflowEngine', () => {
         kanban: createMockKanban(),
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -370,6 +400,7 @@ describe('WorkflowEngine', () => {
         kanban: createMockKanban(),
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -383,6 +414,7 @@ describe('WorkflowEngine', () => {
         kanban: createMockKanban(),
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -396,6 +428,7 @@ describe('WorkflowEngine', () => {
         kanban: createMockKanban(),
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -409,6 +442,7 @@ describe('WorkflowEngine', () => {
         kanban: createMockKanban(),
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -422,6 +456,7 @@ describe('WorkflowEngine', () => {
         kanban: createMockKanban(),
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -439,6 +474,7 @@ describe('WorkflowEngine', () => {
         kanban,
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -458,6 +494,7 @@ describe('WorkflowEngine', () => {
         kanban,
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -476,6 +513,7 @@ describe('WorkflowEngine', () => {
         kanban,
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -496,6 +534,7 @@ describe('WorkflowEngine', () => {
         kanban,
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -512,6 +551,7 @@ describe('WorkflowEngine', () => {
         kanban,
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -529,6 +569,7 @@ describe('WorkflowEngine', () => {
         kanban,
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -546,6 +587,7 @@ describe('WorkflowEngine', () => {
         kanban: createMockKanban(),
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -563,6 +605,7 @@ describe('WorkflowEngine', () => {
         kanban: createMockKanban(),
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -580,6 +623,7 @@ describe('WorkflowEngine', () => {
         kanban: createMockKanban(),
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -601,6 +645,7 @@ describe('WorkflowEngine', () => {
         kanban,
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -618,6 +663,7 @@ describe('WorkflowEngine', () => {
         kanban,
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -635,6 +681,7 @@ describe('WorkflowEngine', () => {
         kanban: createMockKanban(),
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -659,7 +706,60 @@ describe('WorkflowEngine', () => {
 
       const engine = new WorkflowEngine({
         db: db as any, kanban: createMockKanban(), claudeService: createMockClaudeService(),
-        gitWorkflow, log: createMockLog(),
+        gitWorkflow, skillsDir: TEST_SKILLS_DIR, log: createMockLog(),
+      });
+
+      const node = { id: 'end_success', type: 'end', data: { outcome: 'success' } };
+      const context = defaultContext({ cycle: 1 });
+
+      await (engine as any).handleEnd(node, context, execId);
+
+      assert.equal(gitWorkflow.mergeBranch.mock.calls.length, 1);
+      assert.equal(gitWorkflow.removeWorktree.mock.calls.length, 1);
+      assert.equal(gitWorkflow.deleteBranch.mock.calls.length, 1);
+      assert.equal(db._stores.executionsStore[execId].status, 'completed');
+    });
+
+    it('pushes to remote after successful merge', async () => {
+      const db = createMockDb();
+      const gitWorkflow = createMockGitWorkflow();
+      const execId = 'test-exec-push';
+
+      db._stores.executionsStore[execId] = {
+        id: execId, workflowId: WORKFLOW_ID, featureId: 'feat_test',
+        status: 'running', currentNodeId: 'end_success',
+        context: '{}', startedAt: '2026-01-01', updatedAt: '2026-01-01',
+      };
+
+      const engine = new WorkflowEngine({
+        db: db as any, kanban: createMockKanban(), claudeService: createMockClaudeService(),
+        gitWorkflow, skillsDir: TEST_SKILLS_DIR, log: createMockLog(),
+      });
+
+      const node = { id: 'end_success', type: 'end', data: { outcome: 'success' } };
+      const context = defaultContext({ cycle: 1, projectId: 'proj_test' });
+
+      await (engine as any).handleEnd(node, context, execId);
+
+      assert.equal(gitWorkflow.pushToRemote.mock.calls.length, 1);
+      assert.equal(gitWorkflow.pushToRemote.mock.calls[0].arguments[0], 'proj_test');
+    });
+
+    it('does not fail workflow when push to remote fails', async () => {
+      const db = createMockDb();
+      const gitWorkflow = createMockGitWorkflow();
+      gitWorkflow.pushToRemote = mock.fn(async () => { throw new Error('remote unreachable'); });
+      const execId = 'test-exec-push-fail';
+
+      db._stores.executionsStore[execId] = {
+        id: execId, workflowId: WORKFLOW_ID, featureId: 'feat_test',
+        status: 'running', currentNodeId: 'end_success',
+        context: '{}', startedAt: '2026-01-01', updatedAt: '2026-01-01',
+      };
+
+      const engine = new WorkflowEngine({
+        db: db as any, kanban: createMockKanban(), claudeService: createMockClaudeService(),
+        gitWorkflow, skillsDir: TEST_SKILLS_DIR, log: createMockLog(),
       });
 
       const node = { id: 'end_success', type: 'end', data: { outcome: 'success' } };
@@ -667,12 +767,37 @@ describe('WorkflowEngine', () => {
 
       await (engine as any).handleEnd(node, context, execId);
 
+      // Merge still succeeded and cleanup happened
       assert.equal(gitWorkflow.mergeBranch.mock.calls.length, 1);
       assert.equal(gitWorkflow.removeWorktree.mock.calls.length, 1);
       assert.equal(gitWorkflow.deleteBranch.mock.calls.length, 1);
       assert.equal(db._stores.executionsStore[execId].status, 'completed');
     });
 
+    it('does not push to remote on blocked outcome', async () => {
+      const db = createMockDb();
+      const gitWorkflow = createMockGitWorkflow();
+      const execId = 'test-exec-no-push';
+
+      db._stores.executionsStore[execId] = {
+        id: execId, workflowId: WORKFLOW_ID, featureId: 'feat_test',
+        status: 'running', currentNodeId: 'end_blocked',
+        context: '{}', startedAt: '2026-01-01', updatedAt: '2026-01-01',
+      };
+
+      const engine = new WorkflowEngine({
+        db: db as any, kanban: createMockKanban(), claudeService: createMockClaudeService(),
+        gitWorkflow, skillsDir: TEST_SKILLS_DIR, log: createMockLog(),
+      });
+
+      const node = { id: 'end_blocked', type: 'end', data: { outcome: 'blocked' } };
+      const context = defaultContext({ cycle: 3 });
+
+      await (engine as any).handleEnd(node, context, execId);
+
+      assert.equal(gitWorkflow.pushToRemote.mock.calls.length, 0);
+    });
+
     it('cleans up worktree without merge and sets completed on blocked outcome', async () => {
       const db = createMockDb();
       const gitWorkflow = createMockGitWorkflow();
@@ -686,7 +811,7 @@ describe('WorkflowEngine', () => {
 
       const engine = new WorkflowEngine({
         db: db as any, kanban: createMockKanban(), claudeService: createMockClaudeService(),
-        gitWorkflow, log: createMockLog(),
+        gitWorkflow, skillsDir: TEST_SKILLS_DIR, log: createMockLog(),
       });
 
       const node = { id: 'end_blocked', type: 'end', data: { outcome: 'blocked' } };
@@ -713,7 +838,7 @@ describe('WorkflowEngine', () => {
 
       const engine = new WorkflowEngine({
         db: db as any, kanban: createMockKanban(), claudeService: createMockClaudeService(),
-        gitWorkflow, log: createMockLog(),
+        gitWorkflow, skillsDir: TEST_SKILLS_DIR, log: createMockLog(),
       });
 
       const node = { id: 'end_fail', type: 'end', data: { outcome: 'failed' } };
@@ -735,7 +860,7 @@ describe('WorkflowEngine', () => {
 
       const engine = new WorkflowEngine({
         db: db as any, kanban: createMockKanban(), claudeService,
-        gitWorkflow: createMockGitWorkflow(), log: createMockLog(),
+        gitWorkflow: createMockGitWorkflow(), skillsDir: TEST_SKILLS_DIR, log: createMockLog(),
       });
 
       const node = { id: 'run1', type: 'runAgent', data: { agentId: 'dev-agent-id' } };
@@ -749,10 +874,14 @@ describe('WorkflowEngine', () => {
       assert.equal(result.outputData.agentId, 'dev-agent-id');
       assert.equal(result.outputData.agentName, 'Developer');
 
-      // Verify spawnClaude called with resolved prompt and worktree path
+      // Verify spawnClaude called with composed prompt (skill content + resolved grounding) and worktree path
       const call = claudeService.spawnClaude.mock.calls[0];
-      assert.equal(call.arguments[0], 'Implement feature feat_test in /tmp/wt');
+      const prompt = call.arguments[0] as string;
+      assert.ok(prompt.includes('# assistkick-developer skill instructions'), 'prompt should include skill file content');
+      assert.ok(prompt.includes('Implement feature feat_test in /tmp/wt'), 'prompt should include resolved grounding');
       assert.equal(call.arguments[1], '/tmp/wt');
+      // Verify model is passed through
+      assert.equal(call.arguments[3].model, 'claude-opus-4-6');
     });
 
     it('passes onToolUse and onResult callbacks to spawnClaude', async () => {
@@ -781,7 +910,7 @@ describe('WorkflowEngine', () => {
 
       const engine = new WorkflowEngine({
         db: db as any, kanban: createMockKanban(), claudeService,
-        gitWorkflow: createMockGitWorkflow(), log: createMockLog(),
+        gitWorkflow: createMockGitWorkflow(), skillsDir: TEST_SKILLS_DIR, log: createMockLog(),
       });
 
       const node = { id: 'run1', type: 'runAgent', data: { agentId: 'dev-agent-id' } };
@@ -806,7 +935,7 @@ describe('WorkflowEngine', () => {
 
       const engine = new WorkflowEngine({
         db: db as any, kanban: createMockKanban(), claudeService,
-        gitWorkflow: createMockGitWorkflow(), log: createMockLog(),
+        gitWorkflow: createMockGitWorkflow(), skillsDir: TEST_SKILLS_DIR, log: createMockLog(),
       });
 
       const node = { id: 'run1', type: 'runAgent', data: { agentId: 'dev-agent-id' } };
@@ -831,7 +960,7 @@ describe('WorkflowEngine', () => {
 
       const engine = new WorkflowEngine({
         db: db as any, kanban: createMockKanban(), claudeService: createMockClaudeService(),
-        gitWorkflow: createMockGitWorkflow(), log: createMockLog(),
+        gitWorkflow: createMockGitWorkflow(), skillsDir: TEST_SKILLS_DIR, log: createMockLog(),
       });
 
       const node = { id: 'run1', type: 'runAgent', data: { agentId: 'nonexistent-id' } };
@@ -848,7 +977,10 @@ describe('WorkflowEngine', () => {
       db._stores.agentsStore['custom-agent'] = {
         id: 'custom-agent',
         name: 'Custom',
-        promptTemplate: 'Feature: {{featureId}}, Branch: {{branchName}}, Cycle: {{cycle}}',
+        model: 'claude-opus-4-6',
+        skills: '[]',
+        grounding: 'Feature: {{featureId}}, Branch: {{branchName}}, Cycle: {{cycle}}',
+        defaultGrounding: null,
         projectId: null,
         isDefault: 0,
       };
@@ -856,7 +988,7 @@ describe('WorkflowEngine', () => {
 
       const engine = new WorkflowEngine({
         db: db as any, kanban: createMockKanban(), claudeService,
-        gitWorkflow: createMockGitWorkflow(), log: createMockLog(),
+        gitWorkflow: createMockGitWorkflow(), skillsDir: TEST_SKILLS_DIR, log: createMockLog(),
       });
 
       const node = { id: 'run1', type: 'runAgent', data: { agentId: 'custom-agent' } };
@@ -867,6 +999,123 @@ describe('WorkflowEngine', () => {
       const call = claudeService.spawnClaude.mock.calls[0];
       assert.equal(call.arguments[0], 'Feature: feat_test, Branch: feature/feat_test, Cycle: 2');
     });
+
+    it('composes prompt from skill files and resolved grounding', async () => {
+      const db = createMockDb();
+      const claudeService = createMockClaudeService();
+      claudeService.spawnClaude = mock.fn(async () => 'output');
+
+      const engine = new WorkflowEngine({
+        db: db as any, kanban: createMockKanban(), claudeService,
+        gitWorkflow: createMockGitWorkflow(), skillsDir: TEST_SKILLS_DIR, log: createMockLog(),
+      });
+
+      const node = { id: 'run1', type: 'runAgent', data: { agentId: 'dev-agent-id' } };
+      const context = defaultContext({ cycle: 1 });
+
+      await (engine as any).handleRunAgent(node, context, 'exec-id');
+
+      const call = claudeService.spawnClaude.mock.calls[0];
+      const prompt = call.arguments[0] as string;
+      // Skill content comes first, grounding comes after
+      const skillIdx = prompt.indexOf('# assistkick-developer skill instructions');
+      const groundingIdx = prompt.indexOf('Implement feature feat_test');
+      assert.ok(skillIdx >= 0, 'prompt should contain skill content');
+      assert.ok(groundingIdx > skillIdx, 'grounding should come after skill content');
+    });
+
+    it('does not resolve placeholders in skill content', async () => {
+      const db = createMockDb();
+      // Create a skill file with a placeholder-like pattern
+      const skillDir = join(TEST_SKILLS_DIR, 'test-no-resolve');
+      mkdirSync(skillDir, { recursive: true });
+      writeFileSync(join(skillDir, 'SKILL.md'), 'Skill with {{featureId}} in it');
+
+      db._stores.agentsStore['skill-no-resolve'] = {
+        id: 'skill-no-resolve',
+        name: 'TestNoResolve',
+        model: 'claude-opus-4-6',
+        skills: '["test-no-resolve"]',
+        grounding: 'Grounding for {{featureId}}',
+        defaultGrounding: null,
+        projectId: null,
+        isDefault: 0,
+      };
+      const claudeService = createMockClaudeService();
+      claudeService.spawnClaude = mock.fn(async () => 'output');
+
+      const engine = new WorkflowEngine({
+        db: db as any, kanban: createMockKanban(), claudeService,
+        gitWorkflow: createMockGitWorkflow(), skillsDir: TEST_SKILLS_DIR, log: createMockLog(),
+      });
+
+      const node = { id: 'run1', type: 'runAgent', data: { agentId: 'skill-no-resolve' } };
+      const context = defaultContext({ cycle: 1 });
+
+      await (engine as any).handleRunAgent(node, context, 'exec-id');
+
+      const prompt = claudeService.spawnClaude.mock.calls[0].arguments[0] as string;
+      // Skill content should NOT have {{featureId}} resolved
+      assert.ok(prompt.includes('Skill with {{featureId}} in it'), 'skill content should not be interpolated');
+      // Grounding should have {{featureId}} resolved
+      assert.ok(prompt.includes('Grounding for feat_test'), 'grounding should be interpolated');
+    });
+
+    it('passes agent model to spawnClaude', async () => {
+      const db = createMockDb();
+      db._stores.agentsStore['custom-model'] = {
+        id: 'custom-model',
+        name: 'CustomModel',
+        model: 'claude-sonnet-4-6',
+        skills: '[]',
+        grounding: 'test grounding',
+        defaultGrounding: null,
+        projectId: null,
+        isDefault: 0,
+      };
+      const claudeService = createMockClaudeService();
+      claudeService.spawnClaude = mock.fn(async () => 'output');
+
+      const engine = new WorkflowEngine({
+        db: db as any, kanban: createMockKanban(), claudeService,
+        gitWorkflow: createMockGitWorkflow(), skillsDir: TEST_SKILLS_DIR, log: createMockLog(),
+      });
+
+      const node = { id: 'run1', type: 'runAgent', data: { agentId: 'custom-model' } };
+      const context = defaultContext({ cycle: 1 });
+
+      await (engine as any).handleRunAgent(node, context, 'exec-id');
+
+      const opts = claudeService.spawnClaude.mock.calls[0].arguments[3];
+      assert.equal(opts.model, 'claude-sonnet-4-6');
+    });
+
+    it('throws error when skill file is not found', async () => {
+      const db = createMockDb();
+      db._stores.agentsStore['missing-skill'] = {
+        id: 'missing-skill',
+        name: 'MissingSkill',
+        model: 'claude-opus-4-6',
+        skills: '["nonexistent-skill"]',
+        grounding: 'test',
+        defaultGrounding: null,
+        projectId: null,
+        isDefault: 0,
+      };
+
+      const engine = new WorkflowEngine({
+        db: db as any, kanban: createMockKanban(), claudeService: createMockClaudeService(),
+        gitWorkflow: createMockGitWorkflow(), skillsDir: TEST_SKILLS_DIR, log: createMockLog(),
+      });
+
+      const node = { id: 'run1', type: 'runAgent', data: { agentId: 'missing-skill' } };
+      const context = defaultContext({ cycle: 1 });
+
+      await assert.rejects(
+        () => (engine as any).handleRunAgent(node, context, 'exec-id'),
+        /Failed to read skill file for "nonexistent-skill"/,
+      );
+    });
   });
 
   describe('getExecutionMetrics', () => {
@@ -913,7 +1162,7 @@ describe('WorkflowEngine', () => {
 
       const engine = new WorkflowEngine({
         db: db as any, kanban: createMockKanban(), claudeService: createMockClaudeService(),
-        gitWorkflow: createMockGitWorkflow(), log: createMockLog(),
+        gitWorkflow: createMockGitWorkflow(), skillsDir: TEST_SKILLS_DIR, log: createMockLog(),
       });
 
       const metrics = await engine.getExecutionMetrics(execId);
@@ -931,7 +1180,7 @@ describe('WorkflowEngine', () => {
       const db = createMockDb();
       const engine = new WorkflowEngine({
         db: db as any, kanban: createMockKanban(), claudeService: createMockClaudeService(),
-        gitWorkflow: createMockGitWorkflow(), log: createMockLog(),
+        gitWorkflow: createMockGitWorkflow(), skillsDir: TEST_SKILLS_DIR, log: createMockLog(),
       });
 
       const metrics = await engine.getExecutionMetrics('nonexistent');
@@ -972,7 +1221,7 @@ describe('WorkflowEngine', () => {
 
       const engine = new WorkflowEngine({
         db: db as any, kanban, claudeService: createMockClaudeService(),
-        gitWorkflow, log: createMockLog(),
+        gitWorkflow, skillsDir: TEST_SKILLS_DIR, log: createMockLog(),
       });
 
       const { executionId } = await engine.start('feat_test', WORKFLOW_ID, 'proj_test');
@@ -992,6 +1241,7 @@ describe('WorkflowEngine', () => {
         kanban: createMockKanban(),
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -1018,6 +1268,7 @@ describe('WorkflowEngine', () => {
         kanban: createMockKanban(),
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -1040,6 +1291,7 @@ describe('WorkflowEngine', () => {
         kanban: createMockKanban(),
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -1070,6 +1322,7 @@ describe('WorkflowEngine', () => {
         db: db as any, kanban: createMockKanban(),
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -1105,6 +1358,7 @@ describe('WorkflowEngine', () => {
         db: db as any, kanban: createMockKanban(),
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -1137,7 +1391,7 @@ describe('WorkflowEngine', () => {
       const engine = new WorkflowEngine({
         db: db as any, kanban: createMockKanban(),
         claudeService: createMockClaudeService(), gitWorkflow,
-        log: createMockLog(),
+        skillsDir: TEST_SKILLS_DIR, log: createMockLog(),
       });
 
       const { executionId } = await engine.start('feat_test', WORKFLOW_ID, 'proj_test');
@@ -1147,11 +1401,16 @@ describe('WorkflowEngine', () => {
 
       // Execution row was created
       assert.ok(db._stores.executionsStore[executionId]);
+      // Pull was called before worktree creation
+      assert.equal(gitWorkflow.pullDefaultBranch.mock.calls.length, 1);
+      assert.equal(gitWorkflow.pullDefaultBranch.mock.calls[0].arguments[0], 'proj_test');
       // Worktree was created
       assert.equal(gitWorkflow.createWorktree.mock.calls.length, 1);
       assert.equal(gitWorkflow.createWorktree.mock.calls[0].arguments[0], 'feat_test');
       // Merge was called (success outcome)
       assert.equal(gitWorkflow.mergeBranch.mock.calls.length, 1);
+      // Push was called after merge
+      assert.equal(gitWorkflow.pushToRemote.mock.calls.length, 1);
       // Execution completed
       assert.equal(db._stores.executionsStore[executionId].status, 'completed');
       // Node executions were created for both nodes
@@ -1177,6 +1436,7 @@ describe('WorkflowEngine', () => {
         db: db as any, kanban,
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -1210,6 +1470,7 @@ describe('WorkflowEngine', () => {
         db: db as any, kanban: createMockKanban(),
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -1239,6 +1500,7 @@ describe('WorkflowEngine', () => {
         db: db as any, kanban: createMockKanban(),
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -1270,6 +1532,7 @@ describe('WorkflowEngine', () => {
         db: db as any, kanban,
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -1301,6 +1564,7 @@ describe('WorkflowEngine', () => {
         db: db as any, kanban: createMockKanban(),
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -1351,7 +1615,7 @@ describe('WorkflowEngine', () => {
       const engine = new WorkflowEngine({
         db: db as any, kanban: createMockKanban(),
         claudeService: createMockClaudeService(), gitWorkflow,
-        log: createMockLog(),
+        skillsDir: TEST_SKILLS_DIR, log: createMockLog(),
       });
 
       await engine.resume(execId);
@@ -1381,6 +1645,7 @@ describe('WorkflowEngine', () => {
         db: db as any, kanban: createMockKanban(),
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -1406,6 +1671,7 @@ describe('WorkflowEngine', () => {
         db: db as any, kanban: createMockKanban(),
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -1423,6 +1689,7 @@ describe('WorkflowEngine', () => {
         kanban: createMockKanban(),
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -1442,6 +1709,7 @@ describe('WorkflowEngine', () => {
         kanban: createMockKanban(),
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
     });
@@ -1506,6 +1774,7 @@ describe('WorkflowEngine', () => {
         kanban: createMockKanban(),
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
     });
@@ -1549,6 +1818,7 @@ describe('WorkflowEngine', () => {
         kanban: createMockKanban(),
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
     });
@@ -1577,6 +1847,7 @@ describe('WorkflowEngine', () => {
         kanban: createMockKanban(),
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -1612,6 +1883,7 @@ describe('WorkflowEngine', () => {
         outputData: JSON.stringify({ result: 'ok' }),
         error: null,
         attempt: 1,
+        cycle: 1,
       };
 
       // Seed tool calls
@@ -1635,6 +1907,7 @@ describe('WorkflowEngine', () => {
         kanban: createMockKanban(),
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -1653,14 +1926,16 @@ describe('WorkflowEngine', () => {
       assert.ok(graphData.nodes.length > 0);
       assert.ok(graphData.edges.length > 0);
 
-      // Check node executions
-      const nodeExecs = result.nodeExecutions as Record<string, any>;
+      // Check node executions — now an array per node
+      const nodeExecs = result.nodeExecutions as Record<string, any[]>;
       assert.ok(nodeExecs['agent_dev']);
-      assert.equal(nodeExecs['agent_dev'].status, 'completed');
-      assert.deepEqual(nodeExecs['agent_dev'].outputData, { result: 'ok' });
+      assert.equal(nodeExecs['agent_dev'].length, 1);
+      assert.equal(nodeExecs['agent_dev'][0].status, 'completed');
+      assert.equal(nodeExecs['agent_dev'][0].cycle, 1);
+      assert.deepEqual(nodeExecs['agent_dev'][0].outputData, { result: 'ok' });
 
       // Check tool calls grouped under node execution
-      const toolCalls = nodeExecs['agent_dev'].toolCalls as any[];
+      const toolCalls = nodeExecs['agent_dev'][0].toolCalls as any[];
       assert.equal(toolCalls.length, 2);
       assert.equal(toolCalls[0].toolName, 'Read');
       assert.equal(toolCalls[0].target, '/src/index.ts');
@@ -1700,6 +1975,7 @@ describe('WorkflowEngine', () => {
         kanban: createMockKanban(),
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -1734,6 +2010,147 @@ describe('WorkflowEngine', () => {
         outputData: null,
         error: null,
         attempt: 1,
+        cycle: 1,
+      };
+
+      const engine = new WorkflowEngine({
+        db: db as any,
+        kanban: createMockKanban(),
+        claudeService: createMockClaudeService(),
+        gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
+        log: createMockLog(),
+      });
+
+      const result = await engine.getMonitorData('feat_test');
+      assert.ok(result);
+      const nodeExecs = result.nodeExecutions as Record<string, any[]>;
+      assert.deepEqual(nodeExecs['transition_1'][0].toolCalls, []);
+    });
+
+    it('returns multiple cycle executions per node sorted by cycle', async () => {
+      const db = createMockDb();
+      const execId = 'exec-cycles';
+
+      db._stores.executionsStore[execId] = {
+        id: execId,
+        workflowId: WORKFLOW_ID,
+        featureId: 'feat_test',
+        status: 'completed',
+        currentNodeId: 'end_success',
+        startedAt: '2026-01-01T00:00:00.000Z',
+        updatedAt: '2026-01-01T00:10:00.000Z',
+        contextData: null,
+      };
+
+      // Cycle 1 execution of agent_dev
+      db._stores.nodeExecutionsStore['ne-c1'] = {
+        id: 'ne-c1',
+        executionId: execId,
+        nodeId: 'agent_dev',
+        status: 'completed',
+        startedAt: '2026-01-01T00:01:00.000Z',
+        completedAt: '2026-01-01T00:03:00.000Z',
+        outputData: JSON.stringify({ costUsd: 0.05 }),
+        error: null,
+        attempt: 1,
+        cycle: 1,
+      };
+
+      // Cycle 2 execution of agent_dev
+      db._stores.nodeExecutionsStore['ne-c2'] = {
+        id: 'ne-c2',
+        executionId: execId,
+        nodeId: 'agent_dev',
+        status: 'completed',
+        startedAt: '2026-01-01T00:05:00.000Z',
+        completedAt: '2026-01-01T00:08:00.000Z',
+        outputData: JSON.stringify({ costUsd: 0.08 }),
+        error: null,
+        attempt: 1,
+        cycle: 2,
+      };
+
+      const engine = new WorkflowEngine({
+        db: db as any,
+        kanban: createMockKanban(),
+        claudeService: createMockClaudeService(),
+        gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
+        log: createMockLog(),
+      });
+
+      const result = await engine.getMonitorData('feat_test');
+      assert.ok(result);
+
+      const nodeExecs = result.nodeExecutions as Record<string, any[]>;
+      const devExecs = nodeExecs['agent_dev'];
+      assert.equal(devExecs.length, 2);
+
+      // Sorted by cycle ascending
+      assert.equal(devExecs[0].cycle, 1);
+      assert.equal(devExecs[1].cycle, 2);
+
+      // Each has its own data
+      assert.deepEqual(devExecs[0].outputData, { costUsd: 0.05 });
+      assert.deepEqual(devExecs[1].outputData, { costUsd: 0.08 });
+    });
+
+    it('preserves tool calls per cycle execution', async () => {
+      const db = createMockDb();
+      const execId = 'exec-tc-cycles';
+
+      db._stores.executionsStore[execId] = {
+        id: execId,
+        workflowId: WORKFLOW_ID,
+        featureId: 'feat_test',
+        status: 'completed',
+        currentNodeId: 'end_success',
+        startedAt: '2026-01-01T00:00:00.000Z',
+        updatedAt: '2026-01-01T00:10:00.000Z',
+        contextData: null,
+      };
+
+      db._stores.nodeExecutionsStore['ne-tc1'] = {
+        id: 'ne-tc1',
+        executionId: execId,
+        nodeId: 'agent_dev',
+        status: 'completed',
+        startedAt: '2026-01-01T00:01:00.000Z',
+        completedAt: '2026-01-01T00:03:00.000Z',
+        outputData: null,
+        error: null,
+        attempt: 1,
+        cycle: 1,
+      };
+
+      db._stores.nodeExecutionsStore['ne-tc2'] = {
+        id: 'ne-tc2',
+        executionId: execId,
+        nodeId: 'agent_dev',
+        status: 'completed',
+        startedAt: '2026-01-01T00:05:00.000Z',
+        completedAt: '2026-01-01T00:08:00.000Z',
+        outputData: null,
+        error: null,
+        attempt: 1,
+        cycle: 2,
+      };
+
+      // Tool calls for cycle 1
+      db._stores.toolCallsStore['tc-c1-1'] = {
+        id: 'tc-c1-1', nodeExecutionId: 'ne-tc1',
+        timestamp: '2026-01-01T00:01:30.000Z', toolName: 'Read', target: '/src/a.ts',
+      };
+
+      // Tool calls for cycle 2
+      db._stores.toolCallsStore['tc-c2-1'] = {
+        id: 'tc-c2-1', nodeExecutionId: 'ne-tc2',
+        timestamp: '2026-01-01T00:06:00.000Z', toolName: 'Write', target: '/src/b.ts',
+      };
+      db._stores.toolCallsStore['tc-c2-2'] = {
+        id: 'tc-c2-2', nodeExecutionId: 'ne-tc2',
+        timestamp: '2026-01-01T00:07:00.000Z', toolName: 'Bash', target: 'npm test',
       };
 
       const engine = new WorkflowEngine({
@@ -1741,13 +2158,20 @@ describe('WorkflowEngine', () => {
         kanban: createMockKanban(),
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
       const result = await engine.getMonitorData('feat_test');
       assert.ok(result);
-      const nodeExecs = result.nodeExecutions as Record<string, any>;
-      assert.deepEqual(nodeExecs['transition_1'].toolCalls, []);
+
+      const devExecs = (result.nodeExecutions as Record<string, any[]>)['agent_dev'];
+      assert.equal(devExecs[0].toolCalls.length, 1);
+      assert.equal(devExecs[0].toolCalls[0].toolName, 'Read');
+
+      assert.equal(devExecs[1].toolCalls.length, 2);
+      assert.equal(devExecs[1].toolCalls[0].toolName, 'Write');
+      assert.equal(devExecs[1].toolCalls[1].toolName, 'Bash');
     });
   });
 
@@ -1771,6 +2195,7 @@ describe('WorkflowEngine', () => {
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
         bundleService: mockBundleService,
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -1799,6 +2224,7 @@ describe('WorkflowEngine', () => {
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
         bundleService: mockBundleService,
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -1815,6 +2241,7 @@ describe('WorkflowEngine', () => {
         kanban: createMockKanban(),
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -1845,6 +2272,7 @@ describe('WorkflowEngine', () => {
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
         ttsService: mockTtsService,
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -1875,6 +2303,7 @@ describe('WorkflowEngine', () => {
         kanban: createMockKanban(),
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -1905,6 +2334,7 @@ describe('WorkflowEngine', () => {
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
         videoRenderService: mockVideoRenderService,
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -1946,6 +2376,7 @@ describe('WorkflowEngine', () => {
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
         videoRenderService: mockVideoRenderService,
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -1964,6 +2395,7 @@ describe('WorkflowEngine', () => {
         kanban: createMockKanban(),
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -1985,6 +2417,7 @@ describe('WorkflowEngine', () => {
         claudeService: createMockClaudeService(),
         gitWorkflow: createMockGitWorkflow(),
         videoRenderService: mockVideoRenderService,
+        skillsDir: TEST_SKILLS_DIR,
         log: createMockLog(),
       });
 
@@ -1996,4 +2429,347 @@ describe('WorkflowEngine', () => {
       );
     });
   });
+
+  describe('stopNode', () => {
+    it('marks node execution as stopped and workflow execution as failed', async () => {
+      const db = createMockDb();
+      const execId = 'exec-stop-1';
+      const nodeExecId = 'ne-stop-1';
+
+      db._stores.executionsStore[execId] = {
+        id: execId, workflowId: WORKFLOW_ID, featureId: 'feat_test',
+        status: 'running', currentNodeId: 'agent_dev',
+        context: JSON.stringify(defaultContext()), startedAt: '2026-01-01', updatedAt: '2026-01-01',
+      };
+      db._stores.nodeExecutionsStore[nodeExecId] = {
+        id: nodeExecId, executionId: execId, nodeId: 'agent_dev',
+        status: 'running', startedAt: '2026-01-01', completedAt: null,
+        outputData: null, error: null, attempt: 1,
+      };
+
+      const engine = new WorkflowEngine({
+        db: db as any, kanban: createMockKanban(), claudeService: createMockClaudeService(),
+        gitWorkflow: createMockGitWorkflow(), skillsDir: TEST_SKILLS_DIR, log: createMockLog(),
+      });
+
+      await engine.stopNode('feat_test', 'agent_dev');
+
+      assert.equal(db._stores.nodeExecutionsStore[nodeExecId].status, 'stopped');
+      assert.equal(db._stores.nodeExecutionsStore[nodeExecId].error, 'Stopped by user');
+      assert.ok(db._stores.nodeExecutionsStore[nodeExecId].completedAt);
+      assert.equal(db._stores.executionsStore[execId].status, 'failed');
+    });
+
+    it('throws when no running execution exists', async () => {
+      const db = createMockDb();
+      const execId = 'exec-stop-2';
+
+      db._stores.executionsStore[execId] = {
+        id: execId, workflowId: WORKFLOW_ID, featureId: 'feat_test',
+        status: 'completed', currentNodeId: null,
+        context: JSON.stringify(defaultContext()), startedAt: '2026-01-01', updatedAt: '2026-01-01',
+      };
+
+      const engine = new WorkflowEngine({
+        db: db as any, kanban: createMockKanban(), claudeService: createMockClaudeService(),
+        gitWorkflow: createMockGitWorkflow(), skillsDir: TEST_SKILLS_DIR, log: createMockLog(),
+      });
+
+      await assert.rejects(
+        () => engine.stopNode('feat_test', 'agent_dev'),
+        /No running execution found/,
+      );
+    });
+
+    it('throws when nodeId is not the current node', async () => {
+      const db = createMockDb();
+      const execId = 'exec-stop-3';
+
+      db._stores.executionsStore[execId] = {
+        id: execId, workflowId: WORKFLOW_ID, featureId: 'feat_test',
+        status: 'running', currentNodeId: 'agent_rev',
+        context: JSON.stringify(defaultContext()), startedAt: '2026-01-01', updatedAt: '2026-01-01',
+      };
+
+      const engine = new WorkflowEngine({
+        db: db as any, kanban: createMockKanban(), claudeService: createMockClaudeService(),
+        gitWorkflow: createMockGitWorkflow(), skillsDir: TEST_SKILLS_DIR, log: createMockLog(),
+      });
+
+      await assert.rejects(
+        () => engine.stopNode('feat_test', 'agent_dev'),
+        /not the current execution node/,
+      );
+    });
+
+    it('kills active child process with SIGTERM', async () => {
+      const db = createMockDb();
+      const execId = 'exec-stop-4';
+      const nodeExecId = 'ne-stop-4';
+
+      db._stores.executionsStore[execId] = {
+        id: execId, workflowId: WORKFLOW_ID, featureId: 'feat_test',
+        status: 'running', currentNodeId: 'agent_dev',
+        context: JSON.stringify(defaultContext()), startedAt: '2026-01-01', updatedAt: '2026-01-01',
+      };
+      db._stores.nodeExecutionsStore[nodeExecId] = {
+        id: nodeExecId, executionId: execId, nodeId: 'agent_dev',
+        status: 'running', startedAt: '2026-01-01', completedAt: null,
+        outputData: null, error: null, attempt: 1,
+      };
+
+      const engine = new WorkflowEngine({
+        db: db as any, kanban: createMockKanban(), claudeService: createMockClaudeService(),
+        gitWorkflow: createMockGitWorkflow(), skillsDir: TEST_SKILLS_DIR, log: createMockLog(),
+      });
+
+      // Simulate an active child process in the map
+      const mockChild = { kill: mock.fn(() => true) };
+      (engine as any).activeProcesses.set(execId, mockChild);
+
+      await engine.stopNode('feat_test', 'agent_dev');
+
+      assert.equal(mockChild.kill.mock.calls.length, 1);
+      assert.equal(mockChild.kill.mock.calls[0].arguments[0], 'SIGTERM');
+    });
+
+    it('adds execution to stoppedExecutions set to prevent status overwrite', async () => {
+      const db = createMockDb();
+      const execId = 'exec-stop-5';
+      const nodeExecId = 'ne-stop-5';
+
+      db._stores.executionsStore[execId] = {
+        id: execId, workflowId: WORKFLOW_ID, featureId: 'feat_test',
+        status: 'running', currentNodeId: 'agent_dev',
+        context: JSON.stringify(defaultContext()), startedAt: '2026-01-01', updatedAt: '2026-01-01',
+      };
+      db._stores.nodeExecutionsStore[nodeExecId] = {
+        id: nodeExecId, executionId: execId, nodeId: 'agent_dev',
+        status: 'running', startedAt: '2026-01-01', completedAt: null,
+        outputData: null, error: null, attempt: 1,
+      };
+
+      const engine = new WorkflowEngine({
+        db: db as any, kanban: createMockKanban(), claudeService: createMockClaudeService(),
+        gitWorkflow: createMockGitWorkflow(), skillsDir: TEST_SKILLS_DIR, log: createMockLog(),
+      });
+
+      await engine.stopNode('feat_test', 'agent_dev');
+
+      assert.ok((engine as any).stoppedExecutions.has(execId));
+    });
+  });
+
+  describe('continueNode', () => {
+    it('resets node execution to running and workflow execution to running', async () => {
+      const db = createMockDb();
+      const execId = 'exec-cont-1';
+      const nodeExecId = 'ne-cont-1';
+      const sessionId = 'session-abc-123';
+
+      db._stores.executionsStore[execId] = {
+        id: execId, workflowId: WORKFLOW_ID, featureId: 'feat_test',
+        status: 'failed', currentNodeId: 'agent_dev',
+        context: JSON.stringify(defaultContext()), startedAt: '2026-01-01', updatedAt: '2026-01-01',
+      };
+      db._stores.nodeExecutionsStore[nodeExecId] = {
+        id: nodeExecId, executionId: execId, nodeId: 'agent_dev',
+        status: 'failed', startedAt: '2026-01-01', completedAt: '2026-01-01T00:05:00Z',
+        outputData: null, error: 'Process died', attempt: 1, claudeSessionId: sessionId,
+      };
+
+      const engine = new WorkflowEngine({
+        db: db as any, kanban: createMockKanban(), claudeService: createMockClaudeService(),
+        gitWorkflow: createMockGitWorkflow(), skillsDir: TEST_SKILLS_DIR, log: createMockLog(),
+      });
+
+      await engine.continueNode('feat_test', 'agent_dev');
+
+      // Node execution should be reset to running
+      assert.equal(db._stores.nodeExecutionsStore[nodeExecId].status, 'running');
+      assert.equal(db._stores.nodeExecutionsStore[nodeExecId].error, null);
+      assert.equal(db._stores.nodeExecutionsStore[nodeExecId].completedAt, null);
+      // Attempt should NOT be incremented (continuation, not retry)
+      assert.equal(db._stores.nodeExecutionsStore[nodeExecId].attempt, 1);
+      // Workflow execution should be set back to running
+      assert.equal(db._stores.executionsStore[execId].status, 'running');
+    });
+
+    it('throws when no execution exists for the feature', async () => {
+      const db = createMockDb();
+
+      const engine = new WorkflowEngine({
+        db: db as any, kanban: createMockKanban(), claudeService: createMockClaudeService(),
+        gitWorkflow: createMockGitWorkflow(), skillsDir: TEST_SKILLS_DIR, log: createMockLog(),
+      });
+
+      await assert.rejects(
+        () => engine.continueNode('feat_nonexistent', 'agent_dev'),
+        /No execution found/,
+      );
+    });
+
+    it('throws when nodeId is not the current node', async () => {
+      const db = createMockDb();
+      const execId = 'exec-cont-3';
+
+      db._stores.executionsStore[execId] = {
+        id: execId, workflowId: WORKFLOW_ID, featureId: 'feat_test',
+        status: 'failed', currentNodeId: 'agent_rev',
+        context: JSON.stringify(defaultContext()), startedAt: '2026-01-01', updatedAt: '2026-01-01',
+      };
+
+      const engine = new WorkflowEngine({
+        db: db as any, kanban: createMockKanban(), claudeService: createMockClaudeService(),
+        gitWorkflow: createMockGitWorkflow(), skillsDir: TEST_SKILLS_DIR, log: createMockLog(),
+      });
+
+      await assert.rejects(
+        () => engine.continueNode('feat_test', 'agent_dev'),
+        /not the current execution node/,
+      );
+    });
+
+    it('throws when node has no claudeSessionId', async () => {
+      const db = createMockDb();
+      const execId = 'exec-cont-4';
+      const nodeExecId = 'ne-cont-4';
+
+      db._stores.executionsStore[execId] = {
+        id: execId, workflowId: WORKFLOW_ID, featureId: 'feat_test',
+        status: 'failed', currentNodeId: 'agent_dev',
+        context: JSON.stringify(defaultContext()), startedAt: '2026-01-01', updatedAt: '2026-01-01',
+      };
+      db._stores.nodeExecutionsStore[nodeExecId] = {
+        id: nodeExecId, executionId: execId, nodeId: 'agent_dev',
+        status: 'failed', startedAt: '2026-01-01', completedAt: null,
+        outputData: null, error: 'Process died', attempt: 1, claudeSessionId: null,
+      };
+
+      const engine = new WorkflowEngine({
+        db: db as any, kanban: createMockKanban(), claudeService: createMockClaudeService(),
+        gitWorkflow: createMockGitWorkflow(), skillsDir: TEST_SKILLS_DIR, log: createMockLog(),
+      });
+
+      await assert.rejects(
+        () => engine.continueNode('feat_test', 'agent_dev'),
+        /no Claude session ID/,
+      );
+    });
+
+    it('calls spawnClaude with resume sessionId and "Continue" prompt', async () => {
+      const db = createMockDb();
+      const execId = 'exec-cont-5';
+      const nodeExecId = 'ne-cont-5';
+      const sessionId = 'session-resume-456';
+
+      db._stores.executionsStore[execId] = {
+        id: execId, workflowId: WORKFLOW_ID, featureId: 'feat_test',
+        status: 'failed', currentNodeId: 'agent_dev',
+        context: JSON.stringify(defaultContext()), startedAt: '2026-01-01', updatedAt: '2026-01-01',
+      };
+      db._stores.nodeExecutionsStore[nodeExecId] = {
+        id: nodeExecId, executionId: execId, nodeId: 'agent_dev',
+        status: 'failed', startedAt: '2026-01-01', completedAt: null,
+        outputData: null, error: 'Process died', attempt: 1, claudeSessionId: sessionId,
+      };
+
+      const claudeService = createMockClaudeService();
+      const engine = new WorkflowEngine({
+        db: db as any, kanban: createMockKanban(), claudeService,
+        gitWorkflow: createMockGitWorkflow(), skillsDir: TEST_SKILLS_DIR, log: createMockLog(),
+      });
+
+      await engine.continueNode('feat_test', 'agent_dev');
+      // Allow the fire-and-forget async to run
+      await new Promise(r => setTimeout(r, 50));
+
+      assert.equal(claudeService.spawnClaude.mock.calls.length, 1);
+      const call = claudeService.spawnClaude.mock.calls[0];
+      // First arg is the prompt "Continue"
+      assert.equal(call.arguments[0], 'Continue');
+      // Fourth arg is the options object with resume
+      assert.equal(call.arguments[3].resume, sessionId);
+    });
+
+    it('kills existing alive process before resuming', async () => {
+      const db = createMockDb();
+      const execId = 'exec-cont-6';
+      const nodeExecId = 'ne-cont-6';
+      const sessionId = 'session-kill-789';
+
+      db._stores.executionsStore[execId] = {
+        id: execId, workflowId: WORKFLOW_ID, featureId: 'feat_test',
+        status: 'running', currentNodeId: 'agent_dev',
+        context: JSON.stringify(defaultContext()), startedAt: '2026-01-01', updatedAt: '2026-01-01',
+      };
+      db._stores.nodeExecutionsStore[nodeExecId] = {
+        id: nodeExecId, executionId: execId, nodeId: 'agent_dev',
+        status: 'running', startedAt: '2026-01-01', completedAt: null,
+        outputData: null, error: null, attempt: 1, claudeSessionId: sessionId,
+      };
+
+      const engine = new WorkflowEngine({
+        db: db as any, kanban: createMockKanban(), claudeService: createMockClaudeService(),
+        gitWorkflow: createMockGitWorkflow(), skillsDir: TEST_SKILLS_DIR, log: createMockLog(),
+      });
+
+      // Simulate an active child process with an EventEmitter-like on()
+      const mockChild = {
+        kill: mock.fn(() => true),
+        on: mock.fn((_event: string, cb: () => void) => { cb(); }), // immediately emit 'close'
+      };
+      (engine as any).activeProcesses.set(execId, mockChild);
+
+      await engine.continueNode('feat_test', 'agent_dev');
+
+      // The existing process should have been killed with SIGTERM
+      assert.equal(mockChild.kill.mock.calls.length, 1);
+      assert.equal(mockChild.kill.mock.calls[0].arguments[0], 'SIGTERM');
+      // The process should be removed from activeProcesses (before the resumed one is added)
+      // stoppedExecutions should be cleaned up (no lingering entries)
+      assert.ok(!(engine as any).stoppedExecutions.has(execId));
+    });
+
+    it('picks the highest-attempt node execution record', async () => {
+      const db = createMockDb();
+      const execId = 'exec-cont-7';
+      const nodeExecId1 = 'ne-cont-7a';
+      const nodeExecId2 = 'ne-cont-7b';
+      const sessionId = 'session-latest';
+
+      db._stores.executionsStore[execId] = {
+        id: execId, workflowId: WORKFLOW_ID, featureId: 'feat_test',
+        status: 'failed', currentNodeId: 'agent_dev',
+        context: JSON.stringify(defaultContext()), startedAt: '2026-01-01', updatedAt: '2026-01-01',
+      };
+      // Attempt 1 — completed previously
+      db._stores.nodeExecutionsStore[nodeExecId1] = {
+        id: nodeExecId1, executionId: execId, nodeId: 'agent_dev',
+        status: 'completed', startedAt: '2026-01-01', completedAt: '2026-01-01',
+        outputData: null, error: null, attempt: 1, claudeSessionId: 'session-old',
+      };
+      // Attempt 2 — the one that failed and should be continued
+      db._stores.nodeExecutionsStore[nodeExecId2] = {
+        id: nodeExecId2, executionId: execId, nodeId: 'agent_dev',
+        status: 'failed', startedAt: '2026-01-01', completedAt: null,
+        outputData: null, error: 'OOM', attempt: 2, claudeSessionId: sessionId,
+      };
+
+      const claudeService = createMockClaudeService();
+      const engine = new WorkflowEngine({
+        db: db as any, kanban: createMockKanban(), claudeService,
+        gitWorkflow: createMockGitWorkflow(), skillsDir: TEST_SKILLS_DIR, log: createMockLog(),
+      });
+
+      await engine.continueNode('feat_test', 'agent_dev');
+      await new Promise(r => setTimeout(r, 50));
+
+      // Should resume the latest session (attempt 2), not attempt 1
+      const call = claudeService.spawnClaude.mock.calls[0];
+      assert.equal(call.arguments[3].resume, sessionId);
+      // Attempt should still be 2 — not incremented (continuation, not retry)
+      assert.equal(db._stores.nodeExecutionsStore[nodeExecId2].attempt, 2);
+    });
+  });
 });