@xulthekl/team-flow 0.22.4

package/tests/lib/cmd-list.test.mjs

@@ -0,0 +1,127 @@
+// tests/lib/cmd-list.test.mjs
+// Tests for scripts/lib/cmd-list.mjs — detectChangeStatus logic
+import { describe, it, before, 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';
+
+let tempDir;
+
+describe('cmd-list: detectChangeStatus()', () => {
+  let detectChangeStatus;
+
+  before(async () => {
+    tempDir = mkdtempSync(join(tmpdir(), 'tf-list-test-'));
+    const modulePath = join(process.cwd(), 'scripts/lib/cmd-list.mjs');
+    const mod = await import(modulePath);
+    detectChangeStatus = mod.detectChangeStatus;
+  });
+
+  after(() => {
+    if (tempDir) rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  function writeStateFile(dir, state) {
+    const lines = [];
+    for (const [key, value] of Object.entries(state)) {
+      lines.push(`${key}: ${value}`);
+    }
+    writeFileSync(join(dir, '.team-flow.yaml'), lines.join('\n'));
+  }
+
+  it('returns EXPLORING when state file says exploring', () => {
+    writeStateFile(tempDir, { state: 'exploring' });
+    const result = detectChangeStatus(tempDir);
+    assert.equal(result.status, 'EXPLORING');
+    assert.ok(result.detail.includes('exploring'));
+  });
+
+  it('returns SPECIFYING when state file says specifying', () => {
+    writeStateFile(tempDir, { state: 'specifying' });
+    const result = detectChangeStatus(tempDir);
+    assert.equal(result.status, 'SPECIFYING');
+  });
+
+  it('returns BRIDGED when state file says bridging', () => {
+    writeStateFile(tempDir, { state: 'bridging' });
+    const result = detectChangeStatus(tempDir);
+    assert.equal(result.status, 'BRIDGED');
+  });
+
+  it('returns APPROVED when state file says approved-for-build', () => {
+    writeStateFile(tempDir, { state: 'approved-for-build' });
+    const result = detectChangeStatus(tempDir);
+    assert.equal(result.status, 'APPROVED');
+  });
+
+  it('returns EXECUTING when state file says executing', () => {
+    writeStateFile(tempDir, { state: 'executing' });
+    const result = detectChangeStatus(tempDir);
+    assert.equal(result.status, 'EXECUTING');
+  });
+
+  it('returns DEBUGGING when state file says debugging', () => {
+    writeStateFile(tempDir, { state: 'debugging' });
+    const result = detectChangeStatus(tempDir);
+    assert.equal(result.status, 'DEBUGGING');
+  });
+
+  it('returns CLOSED when state file says closing', () => {
+    writeStateFile(tempDir, { state: 'closing' });
+    const result = detectChangeStatus(tempDir);
+    assert.equal(result.status, 'CLOSED');
+  });
+
+  it('returns ABANDONED when state file says abandoned', () => {
+    writeStateFile(tempDir, { state: 'abandoned' });
+    const result = detectChangeStatus(tempDir);
+    assert.equal(result.status, 'ABANDONED');
+  });
+
+  it('includes workflow mode in detail for non-full workflows', () => {
+    writeStateFile(tempDir, { state: 'executing', workflow: 'hotfix' });
+    const result = detectChangeStatus(tempDir);
+    assert.equal(result.status, 'EXECUTING');
+    assert.ok(result.detail.includes('hotfix'));
+  });
+
+  it('does not include workflow detail for full mode', () => {
+    writeStateFile(tempDir, { state: 'executing', workflow: 'full' });
+    const result = detectChangeStatus(tempDir);
+    assert.equal(result.status, 'EXECUTING');
+    assert.equal(result.detail, 'executing');
+  });
+
+  // Fallback: when no state file exists, infer from file presence
+  // Each test must clean up previous state file to test fallback path
+  it('falls back to INCOMPLETE when no state file and no proposal', () => {
+    rmSync(join(tempDir, '.team-flow.yaml'), { force: true });
+    const result = detectChangeStatus(tempDir);
+    assert.equal(result.status, 'INCOMPLETE');
+    assert.ok(result.detail.includes('Missing proposal.md'));
+  });
+
+  it('falls back to SPECIFYING when proposal exists but no contract and no state file', () => {
+    rmSync(join(tempDir, '.team-flow.yaml'), { force: true });
+    writeFileSync(join(tempDir, 'proposal.md'), '## Why\nTest proposal');
+    const result = detectChangeStatus(tempDir);
+    assert.equal(result.status, 'SPECIFYING');
+  });
+
+  it('falls back to ABANDONED when abandonment-summary.md exists', () => {
+    rmSync(join(tempDir, '.team-flow.yaml'), { force: true });
+    writeFileSync(join(tempDir, 'abandonment-summary.md'), '# Abandoned\nGave up on this');
+    const result = detectChangeStatus(tempDir);
+    assert.equal(result.status, 'ABANDONED');
+  });
+
+  it('falls back to UNKNOWN when artifacts exist but no state file', () => {
+    rmSync(join(tempDir, '.team-flow.yaml'), { force: true });
+    rmSync(join(tempDir, 'abandonment-summary.md'), { force: true });
+    writeFileSync(join(tempDir, 'proposal.md'), '## Why\nTest proposal');
+    writeFileSync(join(tempDir, 'execution-contract.md'), '## Intent Lock\nTest contract');
+    const result = detectChangeStatus(tempDir);
+    assert.equal(result.status, 'UNKNOWN');
+  });
+});

package/tests/lib/cmd-runtime.test.mjs

@@ -0,0 +1,83 @@
+// Runtime facade regression tests. These execute the public CLI so the
+// canonical-skill protocol is tested without relying on a plugin-root env var.
+import { afterEach, describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { chmodSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { join, delimiter } from 'node:path';
+import { tmpdir } from 'node:os';
+
+const ROOT = process.cwd();
+const CLI = join(ROOT, 'scripts', 'team-flow.mjs');
+const tempDirs = [];
+
+afterEach(() => {
+  while (tempDirs.length > 0) {
+    rmSync(tempDirs.pop(), { recursive: true, force: true });
+  }
+});
+
+function runRuntime(args, options = {}) {
+  return spawnSync(process.execPath, [CLI, 'runtime', ...args], {
+    cwd: options.cwd || ROOT,
+    encoding: 'utf8',
+    env: { ...process.env, ...options.env },
+  });
+}
+
+describe('tf runtime', () => {
+  it('reads approved assets from the package root without a plugin-root environment variable', () => {
+    const result = runRuntime(['asset', 'read', 'templates/execution-contract.md'], {
+      env: { CLAUDE_PLUGIN_ROOT: '', PLUGIN_ROOT: '' },
+    });
+
+    assert.equal(result.status, 0, result.stderr);
+    assert.match(result.stdout, /# 执行合同/);
+  });
+
+  it('rejects traversal and assets outside the allowlist', () => {
+    const result = runRuntime(['asset', 'read', '../package.json']);
+
+    assert.equal(result.status, 2);
+    assert.match(result.stderr, /allowed|allowlist/i);
+  });
+
+  it('dispatches infer and guard while preserving their established output', () => {
+    const infer = runRuntime(['infer', '/tmp/tf-runtime-missing-change']);
+    const guard = runRuntime(['guard', 'check', 'docs/examples/add-dark-mode', 'exploring', 'specifying', '--json']);
+
+    assert.equal(infer.status, 0, infer.stderr);
+    assert.deepEqual(JSON.parse(infer.stdout).mode, 'full');
+    assert.equal(guard.status, 0, guard.stderr);
+    assert.equal(JSON.parse(guard.stdout).pass, true);
+  });
+
+  it('provides read-only config and rejects config writes', () => {
+    const tempDir = mkdtempSync(join(tmpdir(), 'tf-runtime-config-'));
+    tempDirs.push(tempDir);
+    const read = runRuntime(['config', '--get', 'execution.inlineThreshold'], { cwd: tempDir });
+    const write = runRuntime(['config', '--set', 'execution.inlineThreshold=99'], { cwd: tempDir });
+
+    assert.equal(read.status, 0, read.stderr);
+    assert.equal(read.stdout.trim(), '3');
+    assert.equal(write.status, 2);
+    assert.match(write.stderr, /read-only|--set/i);
+  });
+
+  it('uses the existing update-check result without requiring a global tf command', () => {
+    const tempDir = mkdtempSync(join(tmpdir(), 'tf-runtime-update-'));
+    tempDirs.push(tempDir);
+    const binDir = join(tempDir, 'bin');
+    const fakeNpm = join(binDir, 'npm');
+    mkdirSync(binDir);
+    writeFileSync(fakeNpm, '#!/bin/sh\nprintf "0.9.0\\n"\n', 'utf8');
+    chmodSync(fakeNpm, 0o755);
+
+    const result = runRuntime(['check-update'], {
+      env: { PATH: `${binDir}${delimiter}${process.env.PATH}` },
+    });
+
+    assert.equal(result.status, 0, result.stderr);
+    assert.match(result.stdout, /up to date/i);
+  });
+});

package/tests/lib/cmd-state-missing.test.mjs

@@ -0,0 +1,65 @@
+// tests/lib/cmd-state-missing.test.mjs
+// Regression for BUG-B: `tf state` subcommands must error (not silently drift)
+// when the .team-flow.yaml does not exist. Previously `set` would create a
+// phantom state file in the wrong directory.
+
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { execSync } from 'node:child_process';
+import { mkdtempSync, rmSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = join(__dirname, '..', '..');
+const CLI = join(ROOT, 'scripts', 'team-flow.mjs');
+
+function makeEmptyDir() {
+  // A directory with NO .team-flow.yaml on purpose.
+  return mkdtempSync(join(tmpdir(), 'tf-state-missing-'));
+}
+
+function cleanup(dir) {
+  if (existsSync(dir)) rmSync(dir, { recursive: true, force: true });
+}
+
+function run(args) {
+  try {
+    execSync(`node ${CLI} ${args}`, { stdio: 'pipe', timeout: 5000 });
+    return { ok: true, out: '' };
+  } catch (e) {
+    const out = `${e.stdout?.toString() || ''}\n${e.stderr?.toString() || ''}`;
+    return { ok: false, out: out || e.message };
+  }
+}
+
+describe('BUG-B: tf state errors on missing state file (no phantom drift)', () => {
+  let dir;
+  before(() => { dir = makeEmptyDir(); });
+  after(() => { cleanup(dir); });
+
+  it('SHALL error on `state transition` when no state file', () => {
+    const r = run(`state transition "${dir}" closing`);
+    assert.equal(r.ok, false, 'transition must fail without a state file');
+    assert.match(r.out, /No state file/i);
+  });
+
+  it('SHALL error on `state get` when no state file', () => {
+    const r = run(`state get "${dir}" workflow`);
+    assert.equal(r.ok, false, 'get must fail without a state file');
+    assert.match(r.out, /No state file/i);
+  });
+
+  it('SHALL error on `state set` and NOT create a phantom state file', () => {
+    const r = run(`state set "${dir}" dp_0_confirmed true`);
+    assert.equal(r.ok, false, 'set must fail without a state file');
+    assert.match(r.out, /No state file/i);
+    assert.equal(
+      existsSync(join(dir, '.team-flow.yaml')),
+      false,
+      'set must NOT create a phantom .team-flow.yaml in a missing-state directory',
+    );
+  });
+});

package/tests/lib/cmd-state.test.mjs

@@ -0,0 +1,365 @@
+// tests/lib/cmd-state.test.mjs
+// Tests for scripts/lib/cmd-state.mjs
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, writeFileSync, mkdirSync, rmSync, existsSync, chmodSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { execSync } from 'node:child_process';
+
+const CLI_PATH = join(process.cwd(), 'scripts/team-flow.mjs');
+let tempDir;
+
+function tf(args, options = {}) {
+  try {
+    const result = execSync(
+      `${shellQuote(process.execPath)} ${shellQuote(CLI_PATH)} ${args}`,
+      { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], ...options }
+    );
+    return { exitCode: 0, stdout: result.trim(), stderr: '' };
+  } catch (err) {
+    return { exitCode: err.status || 1, stdout: err.stdout?.trim() || '', stderr: err.stderr?.trim() || err.message };
+  }
+}
+
+function shellQuote(value) {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+
+describe('cmd-state: init', () => {
+  before(() => {
+    tempDir = mkdtempSync(join(tmpdir(), 'tf-state-cmd-'));
+    // Create minimal artifacts for hash computation
+    writeFileSync(join(tempDir, 'proposal.md'), '## Why\nTest proposal for state command testing, needs to be long enough for validation rules\n## What Changes\n- Add feature X');
+  });
+
+  after(() => {
+    if (tempDir) rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('creates .team-flow.yaml with hashes', () => {
+    const result = tf(`state init ${tempDir}`);
+    assert.equal(result.exitCode, 0, `Expected exit 0 but got ${result.exitCode}: ${result.stderr}`);
+
+    const stateFile = join(tempDir, '.team-flow.yaml');
+    assert.ok(existsSync(stateFile));
+  });
+
+  it('reports artifacts_hash in init output', () => {
+    const result = tf(`state init ${tempDir}`);
+    assert.ok(result.stdout.includes('artifacts_hash'));
+  });
+
+  it('--json flag outputs JSON with ok: true', () => {
+    const result = tf(`state init ${tempDir} --json`);
+    const parsed = JSON.parse(result.stdout);
+    assert.equal(parsed.ok, true);
+    assert.ok(parsed.artifacts_hash.startsWith('sha256:'));
+  });
+});
+
+describe('cmd-state: check', () => {
+  before(() => {
+    tempDir = mkdtempSync(join(tmpdir(), 'tf-state-check-'));
+    writeFileSync(join(tempDir, 'proposal.md'), '## Why\nTest proposal for state checking with enough chars to pass validation rules.\n## What Changes\n- Feature X');
+  });
+
+  after(() => {
+    if (tempDir) rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('reports consistent after init', () => {
+    tf(`state init ${tempDir}`);
+    const result = tf(`state check ${tempDir}`);
+    assert.equal(result.exitCode, 0);
+    assert.ok(result.stdout.includes('consistent'));
+  });
+
+  it('reports inconsistent after artifact change', () => {
+    tf(`state init ${tempDir}`);
+    // Modify an artifact
+    writeFileSync(join(tempDir, 'proposal.md'), '## Why\nModified proposal with different content for inconsistency testing.\n## What Changes\n- Modified feature');
+    const result = tf(`state check ${tempDir}`);
+    assert.equal(result.exitCode, 1);
+    assert.ok(result.stdout.includes('INCONSISTENT'));
+  });
+
+  it('--json outputs structured data', () => {
+    tf(`state init ${tempDir}`);
+    const result = tf(`state check ${tempDir} --json`);
+    const parsed = JSON.parse(result.stdout);
+    assert.equal(parsed.consistent, true);
+    assert.ok(parsed.stored_hash);
+    assert.ok(parsed.current_hash);
+    assert.equal(parsed.state, 'exploring');
+  });
+});
+
+describe('cmd-state: transition', () => {
+  before(() => {
+    tempDir = mkdtempSync(join(tmpdir(), 'tf-state-trans-'));
+    writeFileSync(join(tempDir, 'proposal.md'), '## Why\nTest proposal for state transition validation, meeting the minimum length requirement.\n## What Changes\n- Add feature');
+    writeFileSync(join(tempDir, 'design.md'), '# Design\n## Context\nTest.\n## Goals\nTest.\n## Decisions\n### D1\n- Choice: Test\n- Rationale: Test\n\n## Risks And Trade-Offs\nNone.');
+    writeFileSync(join(tempDir, 'tasks.md'), '# Tasks\n- [x] Task 1');
+    mkdirSync(join(tempDir, 'specs', 'test'), { recursive: true });
+    writeFileSync(join(tempDir, 'specs', 'test', 'spec.md'), '## ADDED Requirements\n### Requirement: Test\nSHALL work.\n#### Scenario: Test\n- **WHEN** test\n- **THEN** test');
+  });
+
+  after(() => {
+    if (tempDir) rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('transitions from exploring to specifying', () => {
+    tf(`state init ${tempDir}`);
+    const result = tf(`state transition ${tempDir} specifying`);
+    assert.equal(result.exitCode, 0);
+    assert.ok(result.stdout.includes('exploring -> specifying'));
+  });
+
+  it('--json outputs from/to', () => {
+    // Re-init to ensure we start from exploring
+    rmSync(join(tempDir, '.team-flow.yaml'), { force: true });
+    tf(`state init ${tempDir}`);
+    // exploring→specifying is the next legal mainline transition
+    const result = tf(`state transition ${tempDir} specifying --json`);
+    const parsed = JSON.parse(result.stdout);
+    assert.equal(parsed.ok, true);
+    assert.equal(parsed.from, 'exploring');
+    assert.equal(parsed.to, 'specifying');
+  });
+
+  it('persists state across invocations', () => {
+    tf(`state init ${tempDir}`);
+    // Legal transition: exploring → specifying
+    tf(`state transition ${tempDir} specifying`);
+
+    // Check state persisted
+    const result = tf(`state check ${tempDir} --json`);
+    const parsed = JSON.parse(result.stdout);
+    assert.equal(parsed.state, 'specifying');
+  });
+
+  it('rejects exploring to approved-for-build when workflow is auto', () => {
+    rmSync(join(tempDir, '.team-flow.yaml'), { force: true });
+    tf(`state init ${tempDir}`);
+
+    const result = tf(`state transition ${tempDir} approved-for-build`);
+    assert.equal(result.exitCode, 1);
+    const output = result.stderr || result.stdout;
+    assert.match(output, /workflow-mode/i);
+    assert.match(output, /fast-path/i);
+    assert.match(output, /tweak/i);
+
+    const check = tf(`state get ${tempDir} state`);
+    assert.equal(check.stdout.trim(), 'exploring');
+  });
+
+  it('rejects exploring to bridging when workflow is full', () => {
+    rmSync(join(tempDir, '.team-flow.yaml'), { force: true });
+    tf(`state init ${tempDir}`);
+    tf(`state set ${tempDir} workflow full`);
+
+    const result = tf(`state transition ${tempDir} bridging`);
+    assert.equal(result.exitCode, 1);
+    const output = result.stderr || result.stdout;
+    assert.match(output, /workflow-mode/i);
+    assert.match(output, /fast-path/i);
+    assert.match(output, /hotfix/i);
+
+    const check = tf(`state get ${tempDir} state`);
+    assert.equal(check.stdout.trim(), 'exploring');
+  });
+
+  it('rejects transition when guard output is not valid JSON', () => {
+    rmSync(join(tempDir, '.team-flow.yaml'), { force: true });
+    tf(`state init ${tempDir}`);
+    tf(`state set ${tempDir} workflow invalid-mode`);
+
+    const result = tf(`state transition ${tempDir} specifying`);
+    assert.equal(result.exitCode, 1);
+    assert.match(result.stderr || result.stdout, /valid JSON|Invalid workflow|guard-error/i);
+
+    const check = tf(`state get ${tempDir} state`);
+    assert.equal(check.stdout.trim(), 'exploring');
+  });
+
+  it('rejects transition when guard pass is a truthy non-boolean value', () => {
+    rmSync(join(tempDir, '.team-flow.yaml'), { force: true });
+    tf(`state init ${tempDir}`);
+
+    const shimDir = mkdtempSync(join(tmpdir(), 'tf-node-shim-'));
+    const nodeShim = join(shimDir, 'node');
+    writeFileSync(nodeShim, [
+      '#!/bin/sh',
+      'case "$1" in',
+      '  */scripts/guard/guard.mjs)',
+      '    printf \'%s\\n\' \'{"pass":"false","checks":[]}\'',
+      '    exit 0',
+      '    ;;',
+      'esac',
+      `exec ${shellQuote(process.execPath)} "$@"`,
+      '',
+    ].join('\n'));
+    chmodSync(nodeShim, 0o755);
+
+    try {
+      const result = tf(`state transition ${tempDir} specifying`, {
+        env: { ...process.env, PATH: `${shimDir}:${process.env.PATH}` },
+      });
+      assert.equal(result.exitCode, 1);
+      assert.match(result.stderr || result.stdout, /guard-error|Guard check failed/i);
+
+      const check = tf(`state get ${tempDir} state`);
+      assert.equal(check.stdout.trim(), 'exploring');
+    } finally {
+      rmSync(shimDir, { recursive: true, force: true });
+    }
+  });
+
+  it('reports guard spawn errors without changing state', () => {
+    rmSync(join(tempDir, '.team-flow.yaml'), { force: true });
+    tf(`state init ${tempDir}`);
+
+    const result = tf(`state transition ${tempDir} specifying`, {
+      env: { ...process.env, PATH: '' },
+    });
+    assert.equal(result.exitCode, 1);
+    const output = result.stderr || result.stdout;
+    assert.match(output, /guard-error|spawn|ENOENT/i);
+    assert.doesNotMatch(output, /TypeError/i);
+
+    const check = tf(`state get ${tempDir} state`);
+    assert.equal(check.stdout.trim(), 'exploring');
+  });
+});
+
+describe('cmd-state: get', () => {
+  before(() => {
+    tempDir = mkdtempSync(join(tmpdir(), 'tf-state-get-'));
+    writeFileSync(join(tempDir, 'proposal.md'), '## Why\nTest proposal for get command, needs to be long enough.\n## What Changes\n- Feature');
+  });
+
+  after(() => {
+    if (tempDir) rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('gets a field value', () => {
+    tf(`state init ${tempDir}`);
+    const result = tf(`state get ${tempDir} state`);
+    assert.equal(result.exitCode, 0);
+    assert.equal(result.stdout.trim(), 'exploring');
+  });
+
+  it('returns null for unset fields', () => {
+    tf(`state init ${tempDir}`);
+    const result = tf(`state get ${tempDir} dp_5_result`);
+    assert.ok(result.stdout.includes('null'));
+  });
+
+  it('--json returns structured output', () => {
+    tf(`state init ${tempDir}`);
+    const result = tf(`state get ${tempDir} state --json`);
+    const parsed = JSON.parse(result.stdout);
+    assert.equal(parsed.field, 'state');
+    assert.equal(parsed.value, 'exploring');
+  });
+
+  it('errors without field argument', () => {
+    const result = tf(`state get ${tempDir}`);
+    assert.equal(result.exitCode, 2);
+  });
+});
+
+describe('cmd-state: set', () => {
+  before(() => {
+    tempDir = mkdtempSync(join(tmpdir(), 'tf-state-set-'));
+    writeFileSync(join(tempDir, 'proposal.md'), '## Why\nTest proposal for the set subcommand validation.\n## What Changes\n- Test feature');
+  });
+
+  after(() => {
+    if (tempDir) rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('sets a settable field', () => {
+    tf(`state init ${tempDir}`);
+    const result = tf(`state set ${tempDir} workflow hotfix`);
+    assert.equal(result.exitCode, 0);
+    assert.ok(result.stdout.includes('hotfix'));
+  });
+
+  it('sets a DP field', () => {
+    tf(`state init ${tempDir}`);
+    tf(`state set ${tempDir} dp_1_result "confirmed: csv export"`);
+    const get = tf(`state get ${tempDir} dp_1_result`);
+    assert.ok(get.stdout.includes('confirmed: csv export'));
+  });
+
+  it('rejects non-settable fields', () => {
+    tf(`state init ${tempDir}`);
+    const result = tf(`state set ${tempDir} state executing`);
+    assert.equal(result.exitCode, 1);
+    // Error goes to stderr for console.error
+    assert.ok(result.stderr.includes('not settable') || result.stdout.includes('not settable'),
+      `Expected 'not settable' in output but got stdout: "${result.stdout}" stderr: "${result.stderr}"`);
+  });
+
+  it('rejects manual edits to execution DP-4 fields', () => {
+    tf(`state init ${tempDir}`);
+    const result = tf(`state set ${tempDir} dp_4_result "forged execution approval"`);
+    assert.equal(result.exitCode, 1);
+    assert.match(result.stderr || result.stdout, /not settable/);
+  });
+
+  it('rejects unknown fields', () => {
+    tf(`state init ${tempDir}`);
+    const result = tf(`state set ${tempDir} nonexistent_field value`);
+    assert.equal(result.exitCode, 1);
+  });
+
+  it('--json outputs structured result', () => {
+    tf(`state init ${tempDir}`);
+    const result = tf(`state set ${tempDir} test_result pass --json`);
+    const parsed = JSON.parse(result.stdout);
+    assert.equal(parsed.ok, true);
+    assert.equal(parsed.field, 'test_result');
+    assert.equal(parsed.value, 'pass');
+  });
+});
+
+describe('cmd-state: rebuild', () => {
+  before(() => {
+    tempDir = mkdtempSync(join(tmpdir(), 'tf-state-rebuild-'));
+    writeFileSync(join(tempDir, 'proposal.md'), '## Why\nRebuild test proposal with sufficient content length.\n## What Changes\n- Rebuild feature');
+  });
+
+  after(() => {
+    if (tempDir) rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('rebuilds state from artifacts', () => {
+    tf(`state init ${tempDir}`);
+    const result = tf(`state rebuild ${tempDir}`);
+    assert.equal(result.exitCode, 0);
+    assert.ok(result.stdout.includes('rebuilt'));
+  });
+
+  it('--json returns ok with state', () => {
+    tf(`state init ${tempDir}`);
+    const result = tf(`state rebuild ${tempDir} --json`);
+    const parsed = JSON.parse(result.stdout);
+    assert.equal(parsed.ok, true);
+    assert.equal(parsed.state, 'exploring');
+  });
+});
+
+describe('cmd-state: error handling', () => {
+  it('errors when no change-dir provided', () => {
+    const result = tf('state init');
+    assert.equal(result.exitCode, 2);
+  });
+
+  it('errors on unknown subcommand', () => {
+    const result = tf('state invalid-subcommand /tmp');
+    assert.equal(result.exitCode, 2);
+  });
+});