create-harness-vibe-coding 0.8.19 → 0.9.3

package/src/wf-ui-server/__tests__/workflow-file-node-actions.test.mjs

@@ -0,0 +1,294 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { makeHarnessTempRoot } from '../../../tests/support/temp-root.js';
+
+async function loadFileNode() {
+  return import('../workflow-node-types/file-node.mjs');
+}
+
+async function loadComponentStore() {
+  return import('../component-node-store.mjs');
+}
+
+async function loadWorkspaceStore() {
+  return import('../workspace-store.mjs');
+}
+
+function makeProject(prefix = 'wf-file-node-actions-') {
+  const projectRoot = makeHarnessTempRoot(prefix);
+  fs.mkdirSync(path.join(projectRoot, 'Harness', 'tasks'), { recursive: true });
+  fs.mkdirSync(path.join(projectRoot, 'src'), { recursive: true });
+  return projectRoot;
+}
+
+function createFileNode(projectRoot, store, filePayload) {
+  return store.createComponentNode(projectRoot, {
+    type: 'file',
+    title: filePayload.title || 'File Node',
+    file: filePayload.file,
+  });
+}
+
+const TINY_PNG_BASE64 = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII=';
+
+test('AC-038 file.meta returns metadata for the bound workspace file', async () => {
+  const projectRoot = makeProject();
+  try {
+    const store = await loadComponentStore();
+    const fileNode = await loadFileNode();
+    fs.writeFileSync(path.join(projectRoot, 'src', 'notes.md'), '# Title\nbody\n');
+    const created = createFileNode(projectRoot, store, {
+      file: { path: 'src/notes.md', mime: 'text/markdown', name: 'notes.md', size: 0 },
+    });
+
+    const result = fileNode.meta(created.node.nodeId, projectRoot);
+    assert.equal(result.file.path, 'src/notes.md');
+    assert.equal(result.file.exists, true);
+    assert.equal(result.file.stale, false);
+    assert.equal(result.file.mime, 'text/markdown; charset=utf-8');
+    assert.ok(result.file.size > 0);
+
+    // Alias equivalence: file.meta and file.readMeta return the same shape.
+    const readMetaResult = fileNode.readMeta(created.node.nodeId, projectRoot);
+    assert.deepEqual(readMetaResult, result);
+  } finally {
+    fs.rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+test('AC-038 file.writeText round-trips UTF-8 content through the workspace boundary', async () => {
+  const projectRoot = makeProject();
+  try {
+    const store = await loadComponentStore();
+    const fileNode = await loadFileNode();
+    fs.writeFileSync(path.join(projectRoot, 'src', 'draft.txt'), 'old content\n');
+    const created = createFileNode(projectRoot, store, {
+      file: { path: 'src/draft.txt', mime: 'text/plain', name: 'draft.txt', size: 12 },
+    });
+
+    const payload = 'Hello — writeText round-trip · UTF-8 ✓\nsecond line\n';
+    const result = fileNode.writeText(created.node.nodeId, projectRoot, { content: payload });
+    assert.equal(result.ok, true);
+    assert.equal(result.path, 'src/draft.txt');
+    assert.equal(result.bytes, Buffer.byteLength(payload, 'utf8'));
+    assert.equal(typeof result.mtime, 'string');
+    assert.equal(typeof result.revision, 'number');
+    assert.ok(result.revision > 0);
+
+    // Round-trip: read it back via readText and via fs directly.
+    const readResult = fileNode.readText(created.node.nodeId, projectRoot);
+    assert.equal(readResult.text, payload);
+    assert.equal(readResult.truncated, false);
+    assert.equal(
+      fs.readFileSync(path.join(projectRoot, 'src', 'draft.txt'), 'utf8'),
+      payload,
+    );
+  } finally {
+    fs.rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+test('AC-038 file.writeText rejects non-string content', async () => {
+  const projectRoot = makeProject();
+  try {
+    const store = await loadComponentStore();
+    const fileNode = await loadFileNode();
+    fs.writeFileSync(path.join(projectRoot, 'src', 'data.txt'), 'x');
+    const created = createFileNode(projectRoot, store, {
+      file: { path: 'src/data.txt', mime: 'text/plain', name: 'data.txt' },
+    });
+
+    assert.throws(
+      () => fileNode.writeText(created.node.nodeId, projectRoot, { content: Buffer.from([1, 2, 3]) }),
+      (err) => {
+        assert.equal(err.code, 'BAD_REQUEST');
+        assert.equal(err.constructor.name, 'ComponentNodeError');
+        return true;
+      },
+    );
+  } finally {
+    fs.rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+test('AC-038 file.writeText rejects paths that escape the workspace (defense-in-depth)', async () => {
+  const projectRoot = makeProject();
+  try {
+    const store = await loadComponentStore();
+    const fileNode = await loadFileNode();
+    fs.writeFileSync(path.join(projectRoot, 'src', 'safe.txt'), 'x');
+    const created = createFileNode(projectRoot, store, {
+      file: { path: 'src/safe.txt', mime: 'text/plain', name: 'safe.txt' },
+    });
+
+    // Mutate the persisted state to point outside the workspace, simulating a
+    // stale/drifted node. writeText must still refuse to escape via the
+    // workspace boundary even though the node was tampered with.
+    const statePath = path.join(projectRoot, created.node.statePath);
+    const state = JSON.parse(fs.readFileSync(statePath, 'utf8'));
+    state.file.path = '../outside-workspace.txt';
+    fs.writeFileSync(statePath, JSON.stringify(state, null, 2));
+
+    assert.throws(
+      () => fileNode.writeText(created.node.nodeId, projectRoot, { content: 'escape' }),
+      (err) => /outside workspace|traversal|escape/i.test(err.message || ''),
+    );
+
+    // And nothing should have been written outside the project root.
+    assert.equal(fs.existsSync(path.join(projectRoot, '..', 'outside-workspace.txt')), false);
+  } finally {
+    fs.rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+test('AC-038 file.preview returns previewKind and bounded snippet for text-like files', async () => {
+  const projectRoot = makeProject();
+  try {
+    const store = await loadComponentStore();
+    const fileNode = await loadFileNode();
+    const body = '# Markdown Title\n\nparagraph text here\n';
+    fs.writeFileSync(path.join(projectRoot, 'src', 'doc.md'), body);
+    const created = createFileNode(projectRoot, store, {
+      file: { path: 'src/doc.md', mime: 'text/markdown', name: 'doc.md' },
+    });
+
+    const result = fileNode.preview(created.node.nodeId, projectRoot);
+    assert.equal(result.ok, true);
+    assert.equal(result.path, 'src/doc.md');
+    assert.equal(result.previewKind, 'text');
+    assert.equal(result.available, true);
+    assert.equal(result.mime, 'text/markdown; charset=utf-8');
+    assert.equal(typeof result.size, 'number');
+    assert.ok(result.size > 0);
+    assert.equal(result.textSnippet, body);
+    assert.equal(result.textTruncated, false);
+  } finally {
+    fs.rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+test('AC-038 file.preview returns image previewKind for PNG fixtures', async () => {
+  const projectRoot = makeProject();
+  try {
+    const store = await loadComponentStore();
+    const fileNode = await loadFileNode();
+    fs.writeFileSync(path.join(projectRoot, 'src', 'pixel.png'), Buffer.from(TINY_PNG_BASE64, 'base64'));
+    const created = createFileNode(projectRoot, store, {
+      file: { path: 'src/pixel.png', mime: 'image/png', name: 'pixel.png' },
+    });
+
+    const result = fileNode.preview(created.node.nodeId, projectRoot);
+    assert.equal(result.ok, true);
+    assert.equal(result.previewKind, 'image');
+    assert.equal(result.available, true);
+    assert.equal(result.mime, 'image/png');
+    assert.equal(Object.hasOwn(result, 'textSnippet'), false,
+      'image preview must not include a text snippet');
+  } finally {
+    fs.rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+test('AC-038 file.preview reports missing files without throwing', async () => {
+  const projectRoot = makeProject();
+  try {
+    const store = await loadComponentStore();
+    const fileNode = await loadFileNode();
+    const created = createFileNode(projectRoot, store, {
+      file: { path: 'src/ghost.txt', mime: 'text/plain', name: 'ghost.txt' },
+    });
+
+    const result = fileNode.preview(created.node.nodeId, projectRoot);
+    assert.equal(result.ok, true);
+    assert.equal(result.available, false);
+    assert.equal(result.previewKind, 'missing');
+  } finally {
+    fs.rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+test('AC-038 file.preview returns previewKind pdf without extracting any text', async () => {
+  const projectRoot = makeProject();
+  try {
+    const store = await loadComponentStore();
+    const fileNode = await loadFileNode();
+    // Preview only stats the file and classifies by mime/extension; the backend
+    // performs NO PDF text extraction. Content need not be a valid PDF body.
+    fs.writeFileSync(path.join(projectRoot, 'src', 'doc.pdf'), Buffer.from('%PDF-1.4 placeholder\n'));
+    const created = createFileNode(projectRoot, store, {
+      file: { path: 'src/doc.pdf', mime: 'application/pdf', name: 'doc.pdf' },
+    });
+
+    const result = fileNode.preview(created.node.nodeId, projectRoot);
+    assert.equal(result.ok, true);
+    assert.equal(result.previewKind, 'pdf');
+    assert.equal(result.available, true);
+    assert.equal(result.mime, 'application/pdf');
+    assert.equal(Object.hasOwn(result, 'textSnippet'), false,
+      'PDF preview must not extract or return any text snippet');
+  } finally {
+    fs.rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+test('AC-038 file actions never directly mutate Harness/a2a component or event state files', async () => {
+  const projectRoot = makeProject();
+  try {
+    const store = await loadComponentStore();
+    const fileNode = await loadFileNode();
+    fs.writeFileSync(path.join(projectRoot, 'src', 'audit.txt'), 'start\n');
+    const created = createFileNode(projectRoot, store, {
+      file: { path: 'src/audit.txt', mime: 'text/plain', name: 'audit.txt' },
+    });
+
+    const componentStatePath = path.join(projectRoot, created.node.statePath);
+    const stateBefore = fs.readFileSync(componentStatePath, 'utf8');
+
+    fileNode.meta(created.node.nodeId, projectRoot);
+    fileNode.readText(created.node.nodeId, projectRoot);
+    fileNode.preview(created.node.nodeId, projectRoot);
+    fileNode.writeText(created.node.nodeId, projectRoot, { content: 'updated by action\n' });
+
+    const stateAfter = fs.readFileSync(componentStatePath, 'utf8');
+    assert.equal(stateAfter, stateBefore,
+      'file.* actions must not mutate the component-node state.json directly');
+
+    // The file content on disk IS expected to change via writeText, but that
+    // goes through the workspace boundary, not through node state mutation.
+    assert.equal(
+      fs.readFileSync(path.join(projectRoot, 'src', 'audit.txt'), 'utf8'),
+      'updated by action\n',
+    );
+
+    // workspace-ops.jsonl should record the write (proves we routed through the boundary).
+    const { workspaceOpsLogPath } = await loadWorkspaceStore();
+    const opsLog = workspaceOpsLogPath(projectRoot);
+    assert.ok(fs.existsSync(opsLog), 'writeText should append to workspace-ops.jsonl');
+    const ops = fs.readFileSync(opsLog, 'utf8').trim().split(/\r?\n/).map((line) => JSON.parse(line));
+    assert.ok(ops.some((row) => row.op === 'write' && row.target === 'src/audit.txt'),
+      'workspace-ops log must contain the write row');
+  } finally {
+    fs.rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+test('AC-038 file.writeText requires an existing file target (no implicit create)', async () => {
+  const projectRoot = makeProject();
+  try {
+    const store = await loadComponentStore();
+    const fileNode = await loadFileNode();
+    const created = createFileNode(projectRoot, store, {
+      file: { path: 'src/never-created.txt', mime: 'text/plain', name: 'never-created.txt' },
+    });
+
+    assert.throws(
+      () => fileNode.writeText(created.node.nodeId, projectRoot, { content: 'payload' }),
+      (err) => /not found/i.test(err.message || ''),
+    );
+    assert.equal(fs.existsSync(path.join(projectRoot, 'src', 'never-created.txt')), false);
+  } finally {
+    fs.rmSync(projectRoot, { recursive: true, force: true });
+  }
+});

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

@@ -0,0 +1,357 @@
+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-actions-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-actions-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 Actions Agent',
+        cwd: root,
+        taskId: null,
+        role: 'main',
+      },
+    ],
+    positions: {
+      ...(graph.positions || {}),
+      [nodeId]: { x: 100, y: 120 },
+    },
+  });
+  return nodeId;
+}
+
+function seedActiveTask(root, taskId = 'task-goal-actions') {
+  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 Goal item actions.',
+    acceptance: [
+      { id: 'AC-ITEM-ACTIONS', status: 'tracked', text: 'Goal item actions are callable.' },
+      { id: 'AC-COMPLETE-GATE', status: 'tracked', text: 'Complete requires all plan items checked.' },
+    ],
+    links: { dependsOn: [], blocks: [], related: [] },
+  }, null, 2), 'utf8');
+  fs.writeFileSync(path.join(root, 'Harness', 'tasks', taskId, 'PLAN.md'), '# Goal plan\n', 'utf8');
+  fs.writeFileSync(path.join(root, 'Harness', 'tasks', taskId, 'PROGRESS.md'), '# Goal 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',
+  });
+}
+
+let runtime;
+let graphStore;
+
+before(async () => {
+  runtime = await import('../workflow-node-runtime.mjs');
+  graphStore = await import('../workflow-graph-store.mjs');
+});
+
+// ── Goal item actions (spec §7: AC-013, AC-014, T11 backend part) ──
+describe('Workflow Goal Actions', () => {
+  it('goal.add appends plan and acceptance items with new sequential ids', async () => {
+    const localRoot = tempProjectRoot();
+    try {
+      const goalNodeId = seedActiveTask(localRoot);
+      const agentNodeId = seedAgentGraphNode(localRoot, 'goal-actions-agent-01');
+      connectGoal(localRoot, goalNodeId, agentNodeId);
+
+      const added = await runtime.executeNodeAction(localRoot, goalNodeId, 'goal.add', {
+        actorNodeId: agentNodeId,
+        planItems: [{ text: 'Write backend tests', status: 'todo' }, { text: 'Run the suite' }],
+        acceptance: [{ text: 'Actions are callable' }],
+      });
+      assert.equal(added.result.state.planItems.length, 2);
+      assert.equal(added.result.state.planItems[0].id, 'P-001');
+      assert.equal(added.result.state.planItems[0].text, 'Write backend tests');
+      assert.equal(added.result.state.planItems[0].status, 'todo');
+      assert.equal(added.result.state.planItems[1].id, 'P-002');
+      assert.equal(added.result.state.acceptance.length, 3, 'task acceptance plus the appended item');
+      const appendedAc = added.result.state.acceptance.find(item => item.id === 'AC-001');
+      assert.ok(appendedAc, JSON.stringify(added.result.state.acceptance));
+      assert.equal(appendedAc.text, 'Actions are callable');
+      assert.equal(appendedAc.status, 'tracked');
+      assert.ok(added.result.revision > 0);
+      assert.equal(added.ok, true);
+
+      const appended = await runtime.executeNodeAction(localRoot, goalNodeId, 'goal.add', {
+        actorNodeId: agentNodeId,
+        planItems: [{ text: 'Third item' }],
+      });
+      assert.equal(appended.result.state.planItems.length, 3);
+      assert.equal(appended.result.state.planItems[2].id, 'P-003');
+    } finally {
+      cleanup(localRoot);
+    }
+  });
+
+  it('goal.delete removes items and reports unknown ids as skipped', async () => {
+    const localRoot = tempProjectRoot();
+    try {
+      const goalNodeId = seedActiveTask(localRoot);
+      const agentNodeId = seedAgentGraphNode(localRoot, 'goal-actions-agent-02');
+      connectGoal(localRoot, goalNodeId, agentNodeId);
+
+      await runtime.executeNodeAction(localRoot, goalNodeId, 'goal.add', {
+        actorNodeId: agentNodeId,
+        planItems: [{ text: 'Keep me' }, { text: 'Drop me' }],
+        acceptance: [{ text: 'Keep AC' }, { text: 'Drop AC' }],
+      });
+
+      const removed = await runtime.executeNodeAction(localRoot, goalNodeId, 'goal.delete', {
+        actorNodeId: agentNodeId,
+        planItemIds: ['P-002', 'P-999'],
+        acceptanceIds: ['AC-002', 'AC-999'],
+      });
+      assert.equal(removed.result.state.planItems.length, 1);
+      assert.equal(removed.result.state.planItems[0].id, 'P-001');
+      assert.equal(removed.result.state.planItems[0].text, 'Keep me');
+      assert.equal(removed.result.state.acceptance.length, 3, 'task acceptance plus the kept AC-001 item');
+      assert.equal(removed.result.state.acceptance.some(item => item.id === 'AC-001' && item.text === 'Keep AC'), true);
+      assert.equal(removed.result.state.acceptance.some(item => item.text === 'Drop AC'), false);
+      assert.deepEqual(removed.result.skipped, ['P-999', 'AC-999']);
+    } finally {
+      cleanup(localRoot);
+    }
+  });
+
+  it('goal.replace replaces the full list while preserving ids of kept items', async () => {
+    const localRoot = tempProjectRoot();
+    try {
+      const goalNodeId = seedActiveTask(localRoot);
+      const agentNodeId = seedAgentGraphNode(localRoot, 'goal-actions-agent-03');
+      connectGoal(localRoot, goalNodeId, agentNodeId);
+
+      await runtime.executeNodeAction(localRoot, goalNodeId, 'goal.add', {
+        actorNodeId: agentNodeId,
+        planItems: [{ text: 'Old A' }, { text: 'Old B' }],
+      });
+
+      const replaced = await runtime.executeNodeAction(localRoot, goalNodeId, 'goal.replace', {
+        actorNodeId: agentNodeId,
+        planItems: [{ id: 'P-001', text: 'Old A rewritten', status: 'todo' }, { text: 'Brand new' }],
+      });
+      assert.equal(replaced.result.state.planItems.length, 2);
+      assert.equal(replaced.result.state.planItems[0].id, 'P-001', 'kept item id preserved');
+      assert.equal(replaced.result.state.planItems[0].text, 'Old A rewritten');
+      assert.equal(replaced.result.state.planItems[1].id, 'P-002', 'new item continues sequence');
+      assert.equal(replaced.result.state.planItems[1].text, 'Brand new');
+    } finally {
+      cleanup(localRoot);
+    }
+  });
+
+  it('goal.check sets status done and records updatedBy/updatedAt; goal.uncheck returns to todo', async () => {
+    const localRoot = tempProjectRoot();
+    try {
+      const goalNodeId = seedActiveTask(localRoot);
+      const agentNodeId = seedAgentGraphNode(localRoot, 'goal-actions-agent-04');
+      connectGoal(localRoot, goalNodeId, agentNodeId);
+
+      await runtime.executeNodeAction(localRoot, goalNodeId, 'goal.add', {
+        actorNodeId: agentNodeId,
+        planItems: [{ text: 'Task one' }, { text: 'Task two' }],
+      });
+
+      const checked = await runtime.executeNodeAction(localRoot, goalNodeId, 'goal.check', {
+        actorNodeId: agentNodeId,
+        planItemIds: ['P-001'],
+        now: '2026-08-12T10:00:00.000Z',
+      });
+      assert.equal(checked.result.state.planItems[0].status, 'done');
+      assert.equal(checked.result.state.planItems[0].updatedBy, agentNodeId);
+      assert.equal(checked.result.state.planItems[0].updatedAt, '2026-08-12T10:00:00.000Z');
+      assert.equal(checked.result.state.planItems[1].status, 'todo');
+      assert.equal(checked.result.state.status, 'active', 'checking an item must not complete the Goal');
+
+      const unchecked = await runtime.executeNodeAction(localRoot, goalNodeId, 'goal.uncheck', {
+        actorNodeId: agentNodeId,
+        planItemIds: ['P-001'],
+        now: '2026-08-12T10:05:00.000Z',
+      });
+      assert.equal(unchecked.result.state.planItems[0].status, 'todo');
+      assert.equal(unchecked.result.state.planItems[0].updatedBy, agentNodeId);
+      assert.equal(unchecked.result.state.planItems[0].updatedAt, '2026-08-12T10:05:00.000Z');
+    } finally {
+      cleanup(localRoot);
+    }
+  });
+
+  it('goal.complete with unchecked items rejects with goal_items_pending and remaining ids', async () => {
+    const localRoot = tempProjectRoot();
+    try {
+      const goalNodeId = seedActiveTask(localRoot);
+      const agentNodeId = seedAgentGraphNode(localRoot, 'goal-actions-agent-05');
+      connectGoal(localRoot, goalNodeId, agentNodeId);
+
+      await runtime.executeNodeAction(localRoot, goalNodeId, 'goal.add', {
+        actorNodeId: agentNodeId,
+        planItems: [{ text: 'Done one' }, { text: 'Open two' }, { text: 'Open three' }],
+      });
+      await runtime.executeNodeAction(localRoot, goalNodeId, 'goal.check', {
+        actorNodeId: agentNodeId,
+        planItemIds: ['P-001'],
+      });
+
+      await assert.rejects(
+        () => runtime.executeNodeAction(localRoot, goalNodeId, 'goal.complete', {
+          actorNodeId: agentNodeId,
+          evidenceRefs: ['goal-actions-tests'],
+          note: 'Completing early.',
+        }),
+        (error) => {
+          assert.equal(error.code, 'goal_items_pending');
+          assert.match(error.message, /Complete all plan items/);
+          assert.deepEqual(error.remaining, ['P-002', 'P-003']);
+          return true;
+        },
+      );
+
+      const after = await runtime.executeNodeAction(localRoot, goalNodeId, 'goal.read', {});
+      assert.equal(after.result.status, 'active', 'failed complete must not change Goal status');
+    } finally {
+      cleanup(localRoot);
+    }
+  });
+
+  it('goal.complete after all items checked sets proposed-complete with audit fields', async () => {
+    const localRoot = tempProjectRoot();
+    try {
+      const goalNodeId = seedActiveTask(localRoot);
+      const agentNodeId = seedAgentGraphNode(localRoot, 'goal-actions-agent-06');
+      connectGoal(localRoot, goalNodeId, agentNodeId);
+
+      await runtime.executeNodeAction(localRoot, goalNodeId, 'goal.add', {
+        actorNodeId: agentNodeId,
+        planItems: [{ text: 'Done one' }, { text: 'Done two' }],
+      });
+      await runtime.executeNodeAction(localRoot, goalNodeId, 'goal.check', {
+        actorNodeId: agentNodeId,
+        planItemIds: ['P-001', 'P-002'],
+        now: '2026-08-12T11:00:00.000Z',
+      });
+
+      const completed = await runtime.executeNodeAction(localRoot, goalNodeId, 'goal.complete', {
+        actorNodeId: agentNodeId,
+        evidenceRefs: ['goal-actions-tests'],
+        note: 'All plan items verified.',
+        now: '2026-08-12T11:05:00.000Z',
+      });
+      assert.equal(completed.result.state.status, 'proposed-complete');
+      assert.equal(completed.result.state.confirmation.state, 'proposed');
+      assert.equal(completed.result.state.confirmation.proposedBy, agentNodeId);
+      assert.equal(completed.result.state.confirmation.proposedAt, '2026-08-12T11:05:00.000Z');
+      assert.deepEqual(completed.result.state.confirmation.evidenceRefs, ['goal-actions-tests']);
+      assert.equal(completed.result.state.confirmation.note, 'All plan items verified.');
+    } finally {
+      cleanup(localRoot);
+    }
+  });
+
+  it('goal.reopen returns a proposed-complete Goal to active', async () => {
+    const localRoot = tempProjectRoot();
+    try {
+      const goalNodeId = seedActiveTask(localRoot);
+      const agentNodeId = seedAgentGraphNode(localRoot, 'goal-actions-agent-07');
+      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.',
+      });
+
+      const reopened = await runtime.executeNodeAction(localRoot, goalNodeId, 'goal.reopen', {
+        actorNodeId: agentNodeId,
+        note: 'One more round of review.',
+        now: '2026-08-12T12:00:00.000Z',
+      });
+      assert.equal(reopened.result.state.status, 'active');
+      assert.equal(reopened.result.state.confirmation.state, 'returned');
+      assert.equal(reopened.result.state.confirmation.note, 'One more round of review.');
+    } finally {
+      cleanup(localRoot);
+    }
+  });
+
+  it('legacy goal.update still replaces acceptance/planItems wholesale (T14-style compat)', async () => {
+    const localRoot = tempProjectRoot();
+    try {
+      const goalNodeId = seedActiveTask(localRoot);
+      const agentNodeId = seedAgentGraphNode(localRoot, 'goal-actions-agent-08');
+      connectGoal(localRoot, goalNodeId, agentNodeId);
+
+      await runtime.executeNodeAction(localRoot, goalNodeId, 'goal.add', {
+        actorNodeId: agentNodeId,
+        planItems: [{ text: 'To be replaced' }],
+        acceptance: [{ text: 'To be replaced AC' }],
+      });
+
+      const updated = await runtime.executeNodeAction(localRoot, goalNodeId, 'goal.update', {
+        actorNodeId: agentNodeId,
+        nextAction: 'Legacy wholesale replace.',
+        acceptance: ['Fresh acceptance'],
+        planItems: [{ id: 'P-010', text: 'Fresh plan', status: 'todo' }],
+      });
+      assert.equal(updated.result.state.nextAction, 'Legacy wholesale replace.');
+      assert.equal(updated.result.state.planItems.length, 1);
+      assert.equal(updated.result.state.planItems[0].id, 'P-010');
+      assert.equal(updated.result.state.planItems[0].text, 'Fresh plan');
+      assert.equal(updated.result.state.acceptance.length, 1);
+      assert.equal(updated.result.state.acceptance[0].id, 'AC-001');
+      assert.equal(updated.result.state.acceptance[0].text, 'Fresh acceptance');
+    } finally {
+      cleanup(localRoot);
+    }
+  });
+});