create-harness-vibe-coding 0.8.19 → 0.9.3

package/src/wf-ui-server/__tests__/workflow-goal-task-autoclose.test.mjs

@@ -0,0 +1,256 @@
+import { describe, it, before } from 'node:test';
+import assert from 'node:assert';
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+
+// ── Helpers ──
+function tempProjectRoot() {
+  const id = crypto.randomBytes(4).toString('hex');
+  const dir = path.join(process.cwd(), '.tmp-goal-autoclose-test-' + id);
+  fs.mkdirSync(path.join(dir, 'Harness', 'a2a', 'component-nodes'), { recursive: true });
+  fs.writeFileSync(path.join(dir, 'Harness', 'a2a', 'component-nodes', 'index.json'), JSON.stringify({ schemaVersion: 1, nodes: [] }));
+  fs.mkdirSync(path.join(dir, 'Harness', 'a2a'), { recursive: true });
+  fs.writeFileSync(path.join(dir, 'Harness', 'a2a', 'workflow-map.json'), JSON.stringify({ schemaVersion: 1, version: 1, nodes: [], edges: [], positions: {}, undoStack: [], redoStack: [], deletedNodes: [] }));
+  return dir;
+}
+
+function cleanup(dir) {
+  try { fs.rmSync(dir, { recursive: true, force: true }); } catch {}
+}
+
+function seedAgentGraphNode(root, nodeId = 'goal-autoclose-agent-01') {
+  const graph = runtime.loadWorkflowGraphMap(root);
+  runtime.writeWorkflowGraphMap(root, {
+    ...graph,
+    version: graph.version + 1,
+    nodes: [
+      ...(graph.nodes || []),
+      {
+        nodeId,
+        sessionId: `${nodeId}-pty`,
+        agentKind: 'main',
+        runtime: 'codex',
+        status: 'stopped',
+        label: 'Goal Autoclose Agent',
+        cwd: root,
+        taskId: null,
+        role: 'main',
+      },
+    ],
+    positions: {
+      ...(graph.positions || {}),
+      [nodeId]: { x: 100, y: 120 },
+    },
+  });
+  return nodeId;
+}
+
+function seedActiveTask(root, taskId = 'task-goal-autoclose') {
+  fs.mkdirSync(path.join(root, 'Harness', 'tasks', taskId), { recursive: true });
+  fs.writeFileSync(path.join(root, 'Harness', 'PROGRESS.md'), `# PROGRESS.md\n\n## Active Task\n\n- ${taskId}\n`, 'utf8');
+  fs.writeFileSync(path.join(root, 'Harness', 'tasks', taskId, 'STATE.json'), JSON.stringify({
+    schemaVersion: 1,
+    taskId,
+    status: 'active',
+    mode: 'direct',
+    tier: 'WF-Standard',
+    phase: 'implement',
+    gate: 'TEST-GATE',
+    updatedAt: '2026-08-12T00:00:00.000Z',
+    activeQuestion: null,
+    nextAction: 'Implement the autoclose path.',
+    acceptance: [
+      { id: 'AC-AUTOCLOSE', status: 'tracked', text: 'Capsule closes when the Goal completes.' },
+    ],
+    links: { dependsOn: [], blocks: [], related: [] },
+  }, null, 2), 'utf8');
+  fs.writeFileSync(path.join(root, 'Harness', 'tasks', taskId, 'PLAN.md'), '# Autoclose plan\n', 'utf8');
+  fs.writeFileSync(path.join(root, 'Harness', 'tasks', taskId, 'PROGRESS.md'), '# Autoclose progress\n', 'utf8');
+  return `goal-${taskId}`;
+}
+
+function connectGoal(localRoot, goalNodeId, agentNodeId) {
+  graphStore.connectNodes(localRoot, {
+    from: goalNodeId,
+    to: agentNodeId,
+    relation: 'goal',
+    direction: 'bidirectional',
+    sourceHandle: 'goal:right',
+    targetHandle: 'context',
+  });
+}
+
+function capsuleState(root, taskId) {
+  return JSON.parse(fs.readFileSync(path.join(root, 'Harness', 'tasks', taskId, 'STATE.json'), 'utf8'));
+}
+
+let runtime;
+let graphStore;
+let goalNodeModule;
+
+before(async () => {
+  runtime = await import('../workflow-node-runtime.mjs');
+  graphStore = await import('../workflow-graph-store.mjs');
+  goalNodeModule = await import('../workflow-node-types/goal-node.mjs');
+});
+
+describe('Workflow Goal Task Autoclose', () => {
+  it('C1: goal.complete with all items checked closes the bound capsule (phase completed + closedBy + PROGRESS note)', async () => {
+    const localRoot = tempProjectRoot();
+    try {
+      const goalNodeId = seedActiveTask(localRoot);
+      const agentNodeId = seedAgentGraphNode(localRoot, 'goal-autoclose-agent-01');
+      connectGoal(localRoot, goalNodeId, agentNodeId);
+
+      await runtime.executeNodeAction(localRoot, goalNodeId, 'goal.add', {
+        actorNodeId: agentNodeId,
+        planItems: [{ text: 'Close capsule A' }, { text: 'Close capsule B' }],
+      });
+      await runtime.executeNodeAction(localRoot, goalNodeId, 'goal.check', {
+        actorNodeId: agentNodeId,
+        planItemIds: ['P-001', 'P-002'],
+        now: '2026-08-13T07:00:00.000Z',
+      });
+
+      const completed = await runtime.executeNodeAction(localRoot, goalNodeId, 'goal.complete', {
+        actorNodeId: agentNodeId,
+        note: 'All plan items verified.',
+        now: '2026-08-13T08:00:00.000Z',
+      });
+      assert.equal(completed.result.taskUpdate, 'completed');
+      assert.equal(completed.result.state.status, 'proposed-complete', 'Goal sidecar status unchanged');
+
+      const state = capsuleState(localRoot, 'task-goal-autoclose');
+      assert.equal(state.phase, 'completed');
+      assert.equal(state.status, 'active', 'capsule status must stay active (archive is a separate step)');
+      assert.equal(state.closedBy, 'goal-complete');
+      assert.equal(state.preCompletePhase, 'implement');
+      assert.equal(state.updatedAt, '2026-08-13T08:00:00.000Z');
+      assert.equal(state.taskId, 'task-goal-autoclose', 'unrelated capsule fields preserved');
+
+      const progress = fs.readFileSync(path.join(localRoot, 'Harness', 'tasks', 'task-goal-autoclose', 'PROGRESS.md'), 'utf8');
+      assert.ok(progress.startsWith('# Autoclose progress'), 'original PROGRESS content preserved');
+      assert.ok(progress.includes('## Goal Completed'), progress);
+      assert.ok(progress.includes('2026-08-13T08:00:00.000Z'), 'timestamp recorded');
+      assert.ok(progress.includes(goalNodeId), 'goal node id recorded');
+      assert.ok(progress.includes('- items: 2'), 'item count recorded');
+
+      // The capsule stays resolvable so the Goal node keeps working.
+      const after = await runtime.executeNodeAction(localRoot, goalNodeId, 'goal.read', {});
+      assert.equal(after.result.status, 'proposed-complete');
+    } finally {
+      cleanup(localRoot);
+    }
+  });
+
+  it('C2: goal.complete with unchecked items is still rejected and the capsule is untouched', async () => {
+    const localRoot = tempProjectRoot();
+    try {
+      const goalNodeId = seedActiveTask(localRoot);
+      const agentNodeId = seedAgentGraphNode(localRoot, 'goal-autoclose-agent-02');
+      connectGoal(localRoot, goalNodeId, agentNodeId);
+
+      await runtime.executeNodeAction(localRoot, goalNodeId, 'goal.add', {
+        actorNodeId: agentNodeId,
+        planItems: [{ text: 'Done one' }, { text: 'Open two' }],
+      });
+      await runtime.executeNodeAction(localRoot, goalNodeId, 'goal.check', {
+        actorNodeId: agentNodeId,
+        planItemIds: ['P-001'],
+      });
+
+      const beforeState = capsuleState(localRoot, 'task-goal-autoclose');
+      const beforeProgress = fs.readFileSync(path.join(localRoot, 'Harness', 'tasks', 'task-goal-autoclose', 'PROGRESS.md'), 'utf8');
+
+      await assert.rejects(
+        () => runtime.executeNodeAction(localRoot, goalNodeId, 'goal.complete', {
+          actorNodeId: agentNodeId,
+          note: 'Completing early.',
+        }),
+        (error) => {
+          assert.equal(error.code, 'goal_items_pending');
+          assert.deepEqual(error.remaining, ['P-002']);
+          return true;
+        },
+      );
+
+      const afterState = capsuleState(localRoot, 'task-goal-autoclose');
+      assert.deepEqual(afterState, beforeState, 'capsule STATE.json must be untouched after a rejected complete');
+      const afterProgress = fs.readFileSync(path.join(localRoot, 'Harness', 'tasks', 'task-goal-autoclose', 'PROGRESS.md'), 'utf8');
+      assert.equal(afterProgress, beforeProgress, 'capsule PROGRESS.md must be untouched after a rejected complete');
+    } finally {
+      cleanup(localRoot);
+    }
+  });
+
+  it('C3: no task binding reports no-task-binding without an error', () => {
+    const localRoot = tempProjectRoot();
+    try {
+      const at = '2026-08-13T09:00:00.000Z';
+      assert.equal(goalNodeModule.updateTaskCapsuleOnComplete(localRoot, '', 'goal-x', at, 3), 'no-task-binding');
+      assert.equal(goalNodeModule.updateTaskCapsuleOnReopen(localRoot, '', 'goal-x', at), 'no-task-binding');
+      assert.equal(fs.existsSync(path.join(localRoot, 'Harness', 'tasks')), false, 'no capsule files created');
+    } finally {
+      cleanup(localRoot);
+    }
+  });
+
+  it('C4: missing capsule dir is non-fatal and reports no-capsule', () => {
+    const localRoot = tempProjectRoot();
+    try {
+      const at = '2026-08-13T09:05:00.000Z';
+      assert.equal(goalNodeModule.updateTaskCapsuleOnComplete(localRoot, 'task-never-created', 'goal-x', at, 2), 'no-capsule');
+      assert.equal(goalNodeModule.updateTaskCapsuleOnReopen(localRoot, 'task-never-created', 'goal-x', at), 'no-capsule');
+    } finally {
+      cleanup(localRoot);
+    }
+  });
+
+  it('C5: goal.reopen restores the pre-complete phase and appends a Goal Reopened note', async () => {
+    const localRoot = tempProjectRoot();
+    try {
+      const goalNodeId = seedActiveTask(localRoot);
+      const agentNodeId = seedAgentGraphNode(localRoot, 'goal-autoclose-agent-03');
+      connectGoal(localRoot, goalNodeId, agentNodeId);
+
+      await runtime.executeNodeAction(localRoot, goalNodeId, 'goal.add', {
+        actorNodeId: agentNodeId,
+        planItems: [{ text: 'Solo item' }],
+      });
+      await runtime.executeNodeAction(localRoot, goalNodeId, 'goal.check', {
+        actorNodeId: agentNodeId,
+        planItemIds: ['P-001'],
+      });
+      await runtime.executeNodeAction(localRoot, goalNodeId, 'goal.complete', {
+        actorNodeId: agentNodeId,
+        note: 'Marking complete.',
+        now: '2026-08-13T10:00:00.000Z',
+      });
+      assert.equal(capsuleState(localRoot, 'task-goal-autoclose').phase, 'completed');
+
+      const reopened = await runtime.executeNodeAction(localRoot, goalNodeId, 'goal.reopen', {
+        actorNodeId: agentNodeId,
+        note: 'One more round of review.',
+        now: '2026-08-13T11:00:00.000Z',
+      });
+      assert.equal(reopened.result.taskUpdate, 'reopened');
+      assert.equal(reopened.result.state.status, 'active');
+
+      const state = capsuleState(localRoot, 'task-goal-autoclose');
+      assert.equal(state.phase, 'implement', 'phase restored from preCompletePhase');
+      assert.equal(state.preCompletePhase, undefined, 'preCompletePhase cleared after restore');
+      assert.equal(state.closedBy, undefined, 'closedBy cleared on reopen');
+      assert.equal(state.status, 'active');
+      assert.equal(state.updatedAt, '2026-08-13T11:00:00.000Z');
+
+      const progress = fs.readFileSync(path.join(localRoot, 'Harness', 'tasks', 'task-goal-autoclose', 'PROGRESS.md'), 'utf8');
+      assert.ok(progress.includes('## Goal Completed'), progress);
+      assert.ok(progress.includes('## Goal Reopened'), progress);
+      assert.ok(progress.includes('2026-08-13T11:00:00.000Z'), 'reopen timestamp recorded');
+      assert.ok(progress.includes(goalNodeId), 'goal node id recorded');
+    } finally {
+      cleanup(localRoot);
+    }
+  });
+});

package/src/wf-ui-server/__tests__/workflow-graceful-stop.test.mjs

@@ -0,0 +1,108 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { gracefulStopPty, registerPtyProcess, unregisterPtyProcess } from '../ws-terminal.mjs';
+
+// Graceful stop contract (fake-PTY fixture, same style as ws-terminal.integration):
+// claude/cc persist their transcript only on graceful exit, so the stop path
+// writes `/exit\r` first, then Ctrl+C (`\x03`) after the grace period, and
+// only hard-kills as the bounded fallback. codex/opencode persist their
+// session state continuously and go straight to the hard kill.
+
+/**
+ * Fake node-pty process. Records writes/kills and exposes onExit + fireExit
+ * so the graceful-stop sequence can be driven deterministically.
+ */
+function makeFakePty() {
+  const state = {
+    writes: [],
+    kills: [],
+    _exitHandlers: [],
+    _exited: false,
+    write(data) {
+      state.writes.push(String(data));
+    },
+    kill() {
+      state.kills.push(true);
+    },
+    onExit(handler) {
+      if (state._exited) {
+        queueMicrotask(() => handler({ exitCode: 0, signal: 0 }));
+        return;
+      }
+      state._exitHandlers.push(handler);
+    },
+    fireExit() {
+      if (state._exited) return;
+      state._exited = true;
+      const handlers = state._exitHandlers.splice(0);
+      for (const handler of handlers) {
+        queueMicrotask(() => handler({ exitCode: 0, signal: 0 }));
+      }
+    },
+  };
+  return state;
+}
+
+test('claude/cc graceful stop writes /exit then \\r; process exit after the writes means no kill', async () => {
+  for (const runtime of ['claude', 'cc']) {
+    const sessionId = `gs-exit-${runtime}`;
+    const pty = makeFakePty();
+    registerPtyProcess(sessionId, pty);
+
+    const promise = gracefulStopPty(sessionId, { runtime });
+    assert.deepEqual(pty.writes, ['/exit', '\r'],
+      `${runtime} must write /exit then \\r before anything else`);
+    assert.deepEqual(pty.kills, [], 'no kill may happen before the exit check');
+
+    pty.fireExit();
+    const result = await promise;
+
+    assert.equal(result.killed, false, `${runtime} must not be killed after a graceful exit`);
+    assert.equal(result.graceful, true, `${runtime} exit must count as graceful`);
+    assert.deepEqual(pty.kills, [], `${runtime} kill must never be called`);
+    unregisterPtyProcess(sessionId);
+  }
+});
+
+test('claude stop sends Ctrl+C when /exit does not terminate, hard-kills as fallback, and stays bounded', async () => {
+  const pty = makeFakePty();
+  registerPtyProcess('gs-stuck', pty);
+
+  const startedAt = Date.now();
+  const result = await gracefulStopPty('gs-stuck', { runtime: 'claude' });
+  const elapsed = Date.now() - startedAt;
+
+  assert.deepEqual(pty.writes.slice(0, 2), ['/exit', '\r'], '/exit then \\r must be written first');
+  assert.ok(pty.writes.includes('\x03'), 'Ctrl+C must be written after the /exit grace period');
+  assert.deepEqual(pty.kills, [true], 'hard kill must fire exactly once when the process stays alive');
+  assert.equal(result.killed, true, 'still-alive process must be reported as killed');
+  assert.equal(result.graceful, false, 'a hard-killed stop must not be reported graceful');
+  assert.ok(elapsed <= 7000, `stop must stay bounded within ~7s (elapsed ${elapsed}ms)`);
+  unregisterPtyProcess('gs-stuck');
+});
+
+test('codex and opencode stop kill directly without any exit writes', async () => {
+  for (const runtime of ['codex', 'opencode']) {
+    const sessionId = `gs-kill-${runtime}`;
+    const pty = makeFakePty();
+    registerPtyProcess(sessionId, pty);
+
+    const result = await gracefulStopPty(sessionId, { runtime });
+
+    assert.equal(result.killed, true, `${runtime} must be hard-killed`);
+    assert.equal(result.graceful, false, `${runtime} stop is never graceful`);
+    assert.deepEqual(pty.writes, [], `${runtime} must not receive /exit or Ctrl+C writes`);
+    assert.deepEqual(pty.kills, [true], `${runtime} kill must fire exactly once`);
+    unregisterPtyProcess(sessionId);
+  }
+});
+
+test('graceful stop with no attached PTY resolves immediately without waiting', async () => {
+  const startedAt = Date.now();
+  const result = await gracefulStopPty('gs-missing', { runtime: 'claude' });
+  const elapsed = Date.now() - startedAt;
+
+  assert.equal(result.killed, false, 'no pty attached means nothing was killed');
+  assert.equal(result.graceful, false, 'no pty attached means no graceful exit happened');
+  assert.ok(elapsed < 1000, `no-pty stop must not wait for the grace window (elapsed ${elapsed}ms)`);
+});