@namewta/speculo 1.0.18 → 1.0.20

package/template/workflows/ops/common/tests/test_ops_bootstrap.mjs

@@ -3,7 +3,7 @@ import assert from "node:assert/strict";
 import { spawnSync } from "node:child_process";
 import { copyFileSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, writeFileSync, existsSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
+import { dirname, join, posix } from "node:path";
 import { fileURLToPath } from "node:url";
 import test from "node:test";
 import { createHash } from "node:crypto";
@@ -18,6 +18,7 @@ import * as model from "../tools/opslib/model.mjs";
 const toolsDir = join(dirname(fileURLToPath(import.meta.url)), "../tools");
 const scriptPath = join(toolsDir, "bootstrap-volta.sh");
 const ACK = "I-APPROVE-THIS-BOOTSTRAP";
+const linuxExecution = { skip: process.platform !== "linux" && "Requires Linux /bin/sh and a Linux Node executable; SSH protocol contracts run on every platform" };
 
 function sha256(p) {
   return createHash("sha256").update(readFileSync(p)).digest("hex");
@@ -58,13 +59,14 @@ function pinFor(archives, arch = "linux-x64") {
   return { ...base, archives: { ...base.archives, [arch]: slot } };
 }
 
-function mockTransport({ probeJson = null } = {}) {
+function mockTransport({ probeJson = null, agentJson = null, applyJson = null } = {}) {
   const prev = transport.transportHooks.spawnSync;
   const log = [];
   transport.transportHooks.spawnSync = (cmd, args, kw) => {
     log.push({ cmd, args: [...args], encoding: kw.encoding, inputIsBuffer: Buffer.isBuffer(kw.input) });
     const last = args[args.length - 1];
     if (cmd === "scp") {
+      if (applyJson) return { status: 0, stdout: Buffer.alloc(0), stderr: Buffer.alloc(0) };
       const local = args[args.length - 2];
       const spec = args[args.length - 1];
       const remotePath = spec.slice(spec.indexOf(":") + 1);
@@ -80,11 +82,13 @@ function mockTransport({ probeJson = null } = {}) {
         return { status: 0, stdout: Buffer.from(JSON.stringify(probeJson) + "\n"), stderr: Buffer.alloc(0) };
       }
       if (String(last).includes("--input-type=module")) {
+        if (agentJson) return { status: 0, stdout: Buffer.from(JSON.stringify({ ok: true, result: agentJson }) + "\n"), stderr: Buffer.alloc(0) };
         const parts = splitRemote(last);
         return spawnSync(parts[0], parts.slice(1), {
           input: kw.input, encoding: "buffer", timeout: kw.timeout, maxBuffer: kw.maxBuffer,
         });
       }
+      if (applyJson) return { status: 0, stdout: Buffer.from(String(last).includes("--apply") ? JSON.stringify(applyJson) + "\n" : ""), stderr: Buffer.alloc(0) };
       const parts = splitRemote(last);
       return spawnSync(parts[0], parts.slice(1), {
         input: kw.input, encoding: "buffer", timeout: kw.timeout, maxBuffer: kw.maxBuffer,
@@ -182,7 +186,20 @@ test("scp uses the same host-key contract", () => {
   } finally { transport.transportHooks.spawnSync = prev; rmSync(d, { recursive: true, force: true }); }
 });
 
-test("bootstrap-volta apply installs wrapper and does not touch profile", () => {
+test("scp rejects controller paths and unsafe Linux paths before spawning", (t) => {
+  const d = mkdtempSync(join(tmpdir(), "ops-scp-path-"));
+  t.after(() => rmSync(d, { recursive: true, force: true }));
+  const kh = join(d, "known_hosts"), local = join(d, "archive.tar.gz");
+  writeFileSync(kh, "fixture pinned key\n"); writeFileSync(local, "reviewed archive");
+  const prev = transport.transportHooks.spawnSync;
+  t.after(() => { transport.transportHooks.spawnSync = prev; });
+  transport.transportHooks.spawnSync = () => { assert.fail("invalid paths must not reach scp"); };
+  for (const path of ["C:\\server\\archive.tar.gz", "C:/server/archive.tar.gz", "\\\\server\\share\\archive.tar.gz", "/srv/ops\\archive.tar.gz", "relative.tar.gz", "/srv/../archive.tar.gz", "/srv/space name.tar.gz", "/srv/nul\0.tar.gz"]) {
+    assert.throws(() => transport.posixSend({ hostname: "host.invalid", username: "ops", known_hosts: kh }, local, path), /remote scp path/);
+  }
+});
+
+test("bootstrap-volta apply installs wrapper and does not touch profile", linuxExecution, () => {
   const d = mkdtempSync(join(tmpdir(), "ops-vol-"));
   const home = join(d, "home");
   mkdirSync(home);
@@ -205,28 +222,33 @@ test("bootstrap-volta apply installs wrapper and does not touch profile", () =>
   } finally { rmSync(d, { recursive: true, force: true }); }
 });
 
-test("bootstrap-volta apply without ack blocked", () => {
+test("bootstrap-volta apply without ack blocked", linuxExecution, () => {
   const d = mkdtempSync(join(tmpdir(), "ops-ack-"));
   const archives = makeArchives(d);
   const p = spawnSync("/bin/sh", [scriptPath, "--apply", archives.voltaTar, archives.voltaSha, archives.nodeTar, archives.nodeSha, join(d, "volta"), "24.21.0", "nope"], { encoding: "utf8" });
-  assert.notEqual(p.status, 0);
+  assert.equal(p.error, undefined);
+  assert.equal(p.status, 2);
+  assert.match(p.stderr, /acknowledgement/);
   rmSync(d, { recursive: true, force: true });
 });
 
-test("bootstrap-volta sha mismatch blocked", () => {
+test("bootstrap-volta sha mismatch blocked", linuxExecution, () => {
   const d = mkdtempSync(join(tmpdir(), "ops-sha-"));
   const archives = makeArchives(d);
   const p = spawnSync("/bin/sh", [scriptPath, "--apply", archives.voltaTar, "0".repeat(64), archives.nodeTar, archives.nodeSha, join(d, "volta"), "24.21.0", ACK], { encoding: "utf8" });
-  assert.notEqual(p.status, 0);
+  assert.equal(p.error, undefined);
+  assert.equal(p.status, 2);
+  assert.match(p.stderr, /installer changed after review/);
   assert.ok(!existsSync(join(d, "volta", "bin", "ops-node")));
   rmSync(d, { recursive: true, force: true });
 });
 
-function cliFixture() {
+function cliFixture({ executeLinux = false } = {}) {
   const tmp = mkdtempSync(join(tmpdir(), "ops-bootcli-"));
   const state = join(tmp, "controller");
-  const target = join(tmp, "server");
-  mkdirSync(target, { recursive: true });
+  // A simulated Linux SSH target is not a path on the controller filesystem.
+  const target = executeLinux ? join(tmp, "server") : "/srv/speculo-bootstrap-test";
+  if (executeLinux) mkdirSync(target, { recursive: true });
   const kh = join(tmp, "known_hosts");
   writeFileSync(kh, "fixture pinned key\n");
   const prevProbe = cliHooks.probeLocal;
@@ -251,6 +273,39 @@ const missingProbe = {
   node_path: null, node_version: null, node_usable: false, profile_has_volta: false,
 };
 
+test("Linux SSH bootstrap and enrollment preserve remote paths on every controller platform", () => {
+  const fx = cliFixture();
+  const connectionNode = posix.join(fx.target, "_host/toolchains/ops/volta/bin/ops-node");
+  const mock = mockTransport({ probeJson: missingProbe, applyJson: { status: "installed", connection_node: connectionNode, profile_unchanged: true } });
+  try {
+    const host = sshHost({ root: fx.target, kh: fx.kh, node: "node" });
+    const conn = writeConn(fx.tmp, host);
+    const r = captureMain(["bootstrap-node", "--state", fx.state, "--host-id", host.host_id, "--connection-file", conn, "--apply", "--account", "ops", "--host-root", fx.target, "--ack", ACK,
+      "--volta-archive", fx.archives.voltaTar, "--volta-sha256", fx.archives.voltaSha, "--node-archive", fx.archives.nodeTar, "--node-sha256", fx.archives.nodeSha]);
+    assert.equal(r.code, 0, r.stderr);
+    const boot = JSON.parse(r.stdout), pins = pinFor(fx.archives).archives["linux-x64"];
+    const paths = [pins.volta.filename, pins.node.filename].map(name => posix.join(fx.target, "_host/installers", name));
+    assert.deepEqual(mock.log.filter(e => e.cmd === "scp").map(e => e.args.at(-1)), paths.map(p => "ops@host.invalid:" + p));
+    const applyArgs = splitRemote(mock.log.find(e => e.cmd === "ssh" && e.args.at(-1).includes("--apply")).args.at(-1));
+    assert.deepEqual(applyArgs.slice(applyArgs.indexOf("--apply") + 1), [paths[0], fx.archives.voltaSha, paths[1], fx.archives.nodeSha, posix.dirname(posix.dirname(connectionNode)), fx.archives.nodeVersion, ACK]);
+    assert.equal(JSON.parse(readFileSync(boot.receipt, "utf8")).connection_node, connectionNode);
+    assert.deepEqual(Object.keys(model.load(fx.state).hosts), []);
+    mock.restore();
+    host.connection.node = connectionNode;
+    const enrollFile = join(fx.tmp, "register.json"); writeFileSync(enrollFile, JSON.stringify({ hosts: [host], projects: [] }));
+    const inventory = { identity: "a".repeat(64), platform: "linux", tools: { node: { path: connectionNode, version: "v24.21.0" } } };
+    const enrolledMock = mockTransport({ probeJson: { ...missingProbe, tools: { ...missingProbe.tools, node: connectionNode }, node_path: connectionNode, node_usable: true }, agentJson: inventory });
+    try {
+      const enrolled = captureMain(["--state", fx.state, "enroll", "--file", enrollFile]);
+      assert.equal(enrolled.code, 0, enrolled.stderr);
+      assert.equal(model.load(fx.state).hosts[host.host_id].connection.node, connectionNode);
+      const snapshot = JSON.parse(enrolled.stdout).hosts[0].snapshot;
+      assert.deepEqual(JSON.parse(readFileSync(snapshot, "utf8")), inventory);
+      assert.equal(enrolledMock.log.filter(e => e.args.at(-1).includes("--input-type=module")).length, 2);
+    } finally { enrolledMock.restore(); }
+  } finally { mock.restore(); fx.cleanup(); }
+});
+
 test("discover probe without node returns node-missing", () => {
   const fx = cliFixture();
   const mock = mockTransport({ probeJson: missingProbe });
@@ -313,6 +368,7 @@ test("bootstrap-node sha mismatch blocked", () => {
       "--node-archive", fx.archives.nodeTar, "--node-sha256", fx.archives.nodeSha,
     ]);
     assert.equal(r.code, 2);
+    assert.match(r.stderr, /sha256 does not match the reviewed pin/i);
     assert.ok(!mock.log.some((e) => String(e.args.at(-1) || "").includes("--apply")));
   } finally { mock.restore(); fx.cleanup(); }
 });
@@ -362,8 +418,8 @@ test("bootstrap-node skips when node exists", () => {
   } finally { mock.restore(); fx.cleanup(); }
 });
 
-test("bootstrap-node apply then enroll writes inventory and status", () => {
-  const fx = cliFixture();
+test("bootstrap-node apply then enroll writes inventory and status", linuxExecution, () => {
+  const fx = cliFixture({ executeLinux: true });
   const home = join(fx.tmp, "home");
   mkdirSync(home);
   writeFileSync(join(home, ".bashrc"), "keep-me\n");
@@ -435,10 +491,11 @@ test("enroll without node blocked", () => {
 test("probe --connection-file still does not imply register", () => {
   const fx = cliFixture();
   const mock = mockTransport({
-    probeJson: { ...missingProbe, tools: { ...missingProbe.tools, node: process.execPath }, node_path: process.execPath, node_usable: true },
+    probeJson: { ...missingProbe, tools: { ...missingProbe.tools, node: "/usr/bin/node" }, node_path: "/usr/bin/node", node_usable: true },
+    agentJson: { identity: "a".repeat(64), platform: "linux" },
   });
   try {
-    const host = sshHost({ root: fx.target, kh: fx.kh, node: process.execPath, identity: "discover" });
+    const host = sshHost({ root: fx.target, kh: fx.kh, identity: "discover" });
     const conn = writeConn(fx.tmp, host);
     const r = captureMain(["probe", "--connection-file", conn]);
     assert.equal(r.code, 0, r.stderr);

package/template/workflows/ops/common/tests/test_ops_workspace.mjs

@@ -3,7 +3,7 @@ import assert from "node:assert/strict";
 import { createHash } from "node:crypto";
 import { mkdtempSync, mkdirSync, readFileSync, writeFileSync, existsSync, statSync, symlinkSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { dirname, join, resolve } from "node:path";
+import { dirname, join, resolve, posix } from "node:path";
 import { fileURLToPath } from "node:url";
 import { spawnSync } from "node:child_process";
 import { digest, emptyStatus, now, writeJson } from "../tools/opslib/core.mjs";
@@ -18,7 +18,7 @@ function fixture(t) {
   t.after(() => rmSync(root, { recursive: true, force: true }));
   const state = join(root, "state"); mkdirSync(state);
   const s = emptyStatus(); s.controller = { controller_id: "controller-a", state_root: state, created_at: now() };
-  for (const id of ["node-a", "node-b"]) s.hosts[id] = { host_id: id, display_name: id, platform: "linux", transport: "local", root: join(root, id), identity: "a".repeat(64), connection: {} };
+  for (const id of ["node-a", "node-b"]) s.hosts[id] = { host_id: id, display_name: id, platform: process.platform === "win32" ? "windows" : "linux", transport: "local", root: join(root, id), identity: "a".repeat(64), connection: {} };
   for (const id of ["app-a", "app-b"]) s.projects[id] = { project_id: id, display_name: id, kind: "app", service_type: null, source: { type: "local", location: join(root, "source"), revision: "v1" } };
   writeJson(join(state, "status.json"), s);
   const save = () => writeJson(join(state, "status.json"), s);
@@ -32,7 +32,13 @@ function request(id = "task-one") {
 function inventory(h) {
   return { identity: h.identity, platform: "linux", tools: { node: { version: "v22.22.3" } },
     snapshots: { [h.root]: { kind: "directory" } }, diagnostics: { disks: { [h.root]: { free: 4 * 1024 ** 3 } }, memory: { MemAvailable: 1024 ** 3 } },
-    docker_control: { status: "observed", endpoint: "unix:///var/run/docker.sock", data_root: join(h.root, "_runtime/docker"), compose_version: "2.30.0" } };
+    docker_control: { status: "observed", endpoint: "unix:///var/run/docker.sock", data_root: posix.join(h.root, "_runtime/docker"), compose_version: "2.30.0" } };
+}
+function linuxServer(f) {
+  return Object.assign(f.s.hosts["node-a"], { platform: "linux", root: "/srv/speculo-test/node-a" });
+}
+function directoryLink(target, path) {
+  symlinkSync(target, path, process.platform === "win32" ? "junction" : "dir");
 }
 function adapterFor(f, options = {}) {
   const calls = { compile: 0, approve: 0, apply: 0 };
@@ -76,7 +82,7 @@ test("explicit layer routing distinguishes controller, access, server, project a
 test("workspace rejects guessed roots, traversal, symlinks, duplicate JSON keys and orphan deployments", (t) => {
   const f = fixture(t);
   for (const path of [".", "/", f.state + "/../state"]) assert.throws(() => statePath(path));
-  const link = join(f.root, "linked"); symlinkSync(f.state, link, "dir"); assert.throws(() => statePath(link), /symlink/);
+  const link = join(f.root, "linked"); directoryLink(f.state, link); assert.throws(() => statePath(link), /symlink/);
   writeFileSync(join(f.state, "status.json"), '{"schema_version":3,"schema_version":3}'); assert.throws(() => readRegistry(f.state), /duplicate JSON/);
   f.s.deployments.dangling = { deployment_id: "dangling", host_id: "missing", project_id: "app-a" }; f.save(); assert.throws(() => readRegistry(f.state), /orphan/);
 });
@@ -90,7 +96,7 @@ test("CLI help works without network, server dependencies or state", () => {
   const r = spawnSync(process.execPath, [path, "workspace-help"], { encoding: "utf8" }); assert.equal(r.status, 0, r.stderr); assert.match(r.stdout, /server-check/);
 });
 test("Linux checklist distinguishes missing, failed, profile-ready and stale evidence", (t) => {
-  const f = fixture(t), h = f.s.hosts["node-a"], inv = inventory(h), at = new Date("2026-01-01T00:00:00Z");
+  const f = fixture(t), h = linuxServer(f), inv = inventory(h), at = new Date("2026-01-01T00:00:00Z");
   assert.equal(readiness(assessServer(h), at.toISOString(), { at }), "unknown");
   assert.equal(readiness(assessServer(h, { profile: "compose", inventory: inv }), at.toISOString(), { at }), "ready");
   assert.equal(readiness(assessServer(h, { profile: "compose", inventory: inv }), at.toISOString(), { at: new Date("2026-01-03T00:00:00Z") }), "stale");
@@ -100,7 +106,7 @@ test("Linux checklist distinguishes missing, failed, profile-ready and stale evi
   }
 });
 test("server check uses pinned public-key-only SSH and records restricted evidence", async (t) => {
-  const f = fixture(t), h = f.s.hosts["node-a"], kh = join(f.root, "known_hosts"); writeFileSync(kh, "fixture verified key");
+  const f = fixture(t), h = linuxServer(f), kh = join(f.root, "known_hosts"); writeFileSync(kh, "fixture verified key");
   Object.assign(h, { transport: "ssh", connection: { hostname: "example.invalid", username: "deploy", known_hosts: kh } }); f.save();
   let spawned = 0, called = 0;
   const a = { sshArgv: () => ["ssh", "-o", "StrictHostKeyChecking=yes"], spawn: (_cmd, args) => { spawned++; assert.ok(args.includes("PasswordAuthentication=no")); assert.ok(args.includes("KbdInteractiveAuthentication=no")); return { status: 0 }; }, call: () => { called++; return inventory(h); } };
@@ -111,7 +117,7 @@ test("server check uses pinned public-key-only SSH and records restricted eviden
   writeFileSync(kh, "different key"); assert.notEqual(check.host_digest, targetDigest(h));
 });
 test("failed SSH login never triggers Node probe and is not reported ready", async (t) => {
-  const f = fixture(t), h = f.s.hosts["node-a"], kh = join(f.root, "known_hosts"); writeFileSync(kh, "fixture"); Object.assign(h, { transport: "ssh", connection: { hostname: "invalid", username: "deploy", known_hosts: kh } }); f.save();
+  const f = fixture(t), h = linuxServer(f), kh = join(f.root, "known_hosts"); writeFileSync(kh, "fixture"); Object.assign(h, { transport: "ssh", connection: { hostname: "invalid", username: "deploy", known_hosts: kh } }); f.save();
   const r = await checkServer(f.state, "node-a", {}, { sshArgv: () => ["ssh"], spawn: () => ({ status: 255 }), call: () => { throw new Error("must not probe"); } });
   assert.equal(r.status, "blocked"); assert.equal(r.checks.find(c => c.id === "machine-identity").status, "unknown");
 });
@@ -210,7 +216,10 @@ test("fleet writes immutable generations, verifies readback and retains one cons
   const before = readFileSync(first.markdown, "utf8"); writeFileSync(first.html, "tampered"); assert.throws(() => generateFleet(f.state, { at }), /readback mismatch/); assert.equal(readFileSync(first.markdown, "utf8"), before);
 });
 test("fleet refuses symlink outputs and catalog locks without overwriting old entry", (t) => {
-  const f = fixture(t), outside = join(f.root, "outside.txt"); writeFileSync(outside, "untouched"); symlinkSync(outside, join(f.state, "FLEET.md"));
+  const f = fixture(t), outsideDir = join(f.root, "outside"), outside = join(outsideDir, "sentinel.txt");
+  mkdirSync(outsideDir); writeFileSync(outside, "untouched");
+  if (process.platform === "win32") directoryLink(outsideDir, join(f.state, "FLEET.md"));
+  else symlinkSync(outside, join(f.state, "FLEET.md"));
   assert.throws(() => generateFleet(f.state), /symlink/); assert.equal(readFileSync(outside, "utf8"), "untouched");
   rmSync(join(f.state, "FLEET.md")); mkdirSync(join(f.state, ".locks/catalog"), { recursive: true }); assert.throws(() => generateFleet(f.state), /catalog lock/);
 });

package/template/workflows/ops/common/tools/opslib/bootstrap.mjs

@@ -1,7 +1,7 @@
 /** Node-less Linux SSH bootstrap: pinned Volta/Node via POSIX + scp, then enroll. */
 import { spawnSync } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
-import { dirname, basename, isAbsolute, join } from "node:path";
+import { dirname, basename, join, posix as posixPath } from "node:path";
 import { fileURLToPath } from "node:url";
 import { digest, exact, identifier, newId, noSymlinks, NodeMissing, now, OpsError, privateDir, rootPath, targetJoin, writeJson } from "./core.mjs";
 import { register, validateHost } from "./model.mjs";
@@ -142,8 +142,8 @@ export function bootstrapNode(args) {
   const installers = installerDir(hostRoot);
   const voltaHome = managedVoltaHome(hostRoot, args.account);
   posixCall(endpoint, "#!/bin/sh\nset -eu\nmkdir -p -- \"$1\" \"$2\"\n", { args: [installers, voltaHome] });
-  const remoteVolta = join(installers, volta.filename);
-  const remoteNode = join(installers, node.filename);
+  const remoteVolta = posixPath.join(installers, volta.filename);
+  const remoteNode = posixPath.join(installers, node.filename);
   posixSend(endpoint, volta.file, remoteVolta);
   posixSend(endpoint, node.file, remoteNode);
   const applied = posixCall(endpoint, SCRIPT, {
@@ -181,7 +181,7 @@ export function enroll(state, request) {
     if (posix.tools?.node === "missing" || posix.node_usable === false) throw new NodeMissing(posix);
     const discovery = host.identity === "discover" || host.identity == null;
     if (discovery) host.identity = "0".repeat(64);
-    if (!isAbsolute(host.connection.node)) {
+    if (!posixPath.isAbsolute(host.connection.node) || host.connection.node.includes("\\")) {
       throw new OpsError("connection.node must be the absolute path returned by bootstrap-node");
     }
     validateHost(host);

package/template/workflows/ops/common/tools/opslib/transport.mjs

@@ -1,7 +1,7 @@
 /** Strict host-key SSH and subprocess local transport. No passwords in argv. */
 import { spawnSync } from "node:child_process";
 import { readFileSync } from "node:fs";
-import { dirname, isAbsolute, join, resolve } from "node:path";
+import { dirname, posix, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { canonical, digest, noSymlinks, OpsError, redact, UnknownResult } from "./core.mjs";
 import { fingerprint } from "./agent.mjs";
@@ -107,8 +107,8 @@ export function posixSend(endpoint, localFile, remotePath, { timeout = 180 } = {
     throw new OpsError("POSIX bootstrap is Linux-only; PowerShell targets still require an existing Node");
   }
   noSymlinks(localFile, { allowMissing: false });
-  if (typeof remotePath !== "string" || !isAbsolute(remotePath) || remotePath.split("/").includes("..") || /[\s\n\r]/.test(remotePath)) {
-    throw new OpsError("remote scp path must be absolute without spaces or ..");
+  if (typeof remotePath !== "string" || !posix.isAbsolute(remotePath) || remotePath.split("/").includes("..") || /[\s\\\0]/.test(remotePath)) {
+    throw new OpsError("remote scp path must be POSIX absolute without whitespace, backslashes, NUL or ..");
   }
   const argv = sshArgv(endpoint, { scp: true });
   argv.push("--", localFile, `${endpoint.username}@${endpoint.hostname}:${remotePath}`);

package/template/workflows/person/M-mao-zedong-cognitive-os/M-mao-zedong-cognitive-os.md

@@ -9,67 +9,25 @@ keywords: [毛泽东, 毛选, 矛盾分析, 战略, 组织, 咨询]
 
 # 毛泽东 · 认知操作系统
 
-本入口把"分析问题—制定战略—组织行动"组织为渐进披露的咨询流程。产物写入当前 `person/changes/<change>/`。
+以特定方法论开展“分析问题—制定战略—组织行动”咨询，产物只写当前 person change。激活时读取 `<Path>{roots.workflows}/person/INDEX.md</Path>` 与 `<Path>{roots.workflows}/person/common/rules/activation-and-memory.md</Path>`；Person 没有 README，不加载其他 phase 或整套书籍。
 
-## 读取范围
+## 按阶段推进
 
-1. 先读取 `<Path>{roots.workflows}/person/INDEX.md</Path>` 与当前 Work 的状态入口；Person 使用整文件 INDEX，不加载不存在的 README。
-2. 再读取 `<Path>{roots.workflows}/person/common/rules/activation-and-memory.md</Path>`，按当前分支、状态和关键词定位最小相关工件。
-3. 只在本 Work 明确要求恢复、冲突、执行安全或归档证据时扩展为全量读取；缺少匹配证据或 owner/gateway 时停止受影响分支。
+下表有序且硬依赖：上一阶段产物完成、验证后才进入下一阶段。每个阶段只读取自己的入口，角色、声音、模型和引用纪律由该入口及其参考单点维护。
 
-引用检索固定为：先读取当前 phase 的 framework index，再读取 `references/research/15-quote-bank.md` 定位篇目编号，最后只回读匹配的 `books/src/NNN-*.md`；不扫描整套书籍，无匹配证据时停止引用或结论。
+| 阶段 | 进入时读取 | 产物与可判定完成门 |
+|---|---|---|
+| 1 激活与问诊 | `<Path>{roots.workflows}/person/M-mao-zedong-cognitive-os/activate.md</Path>` | `<Path>{roots.state}/person/changes/{change}/problem-statement.md</Path>`：首次激活声明；开口三问中至少追问两题且用户回应；问题类型和主框架确定；六段填实 |
+| 2 诊断分析 | `<Path>{roots.workflows}/person/M-mao-zedong-cognitive-os/diagnose.md</Path>` | `<Path>{roots.state}/person/changes/{change}/analysis.md</Path>`：至少两个 Module A 模型；必过 A1，二手信息过 A3，多方利益过 A6；每个结论含条件/局限，主要矛盾有论证 |
+| 3 战略制定 | `<Path>{roots.workflows}/person/M-mao-zedong-cognitive-os/strategize.md</Path>` | `<Path>{roots.state}/person/changes/{change}/strategy.md</Path>`：沿定性→定向→站位→时间→投放→运用展开主框架；必要辅助框架；至少两阶段及明确关键战役 |
+| 4 组织行动 | `<Path>{roots.workflows}/person/M-mao-zedong-cognitive-os/mobilize.md</Path>` | `<Path>{roots.state}/person/changes/{change}/action-plan.md</Path>`：行动、责任人、期限、完成条件、失败处置与反馈机制明确 |
+| 5 综合交付 | `<Path>{roots.workflows}/person/M-mao-zedong-cognitive-os/deliver.md</Path>` | `<Path>{roots.state}/person/changes/{change}/consultation-output.md</Path>`：按交付模板整合四阶段，教员第一人称、五拍论证、收尾四动作、反模式检查与内在张力标注；全部原文引用有篇目出处 |
 
+每项产物回读后必须无残留 `[TODO:]`；缺少用户回应、阶段证据或原文出处时保留当前阶段，不用后续产物掩盖缺口。
 
-## 流程
+## 引用检索
 
-### 1. 激活与问诊
-
-委托给 `<Path>{roots.workflows}/person/M-mao-zedong-cognitive-os/activate.md</Path>`。输出首次激活声明，通过开口三问摸清用户处境，判定问题类型并匹配主框架。
-
-产物：`<Path>{roots.state}/person/changes/{change}/problem-statement.md</Path>`
-
-**完成标准**：首次激活声明已输出，至少已追问 2 个开口问题且用户已回应，问题类型与主框架已匹配，problem-statement.md 六段均已填写无残留 `[TODO:]`。
-
-### 2. 诊断分析
-
-依赖步骤 1 的 problem-statement.md。委托给 `<Path>{roots.workflows}/person/M-mao-zedong-cognitive-os/diagnose.md</Path>`。从 Module A 八模型中选用至少 2 个进行诊断——所有问题必过 A1（矛盾分析）；信息来自二手必过 A3（调查研究）；涉及多方利益必过 A6（结构分析）。
-
-产物：`<Path>{roots.state}/person/changes/{change}/analysis.md</Path>`
-
-**完成标准**：已应用至少 2 个 Module A 模型，每个模型结论带条件与局限，主要矛盾已明确写出且带论证，analysis.md 无残留 `[TODO:]`。
-
-### 3. 战略制定
-
-依赖步骤 2 的 analysis.md。委托给 `<Path>{roots.workflows}/person/M-mao-zedong-cognitive-os/strategize.md</Path>`。沿元框架流水线（定性→定向→站位→时间→投放→运用）展开主框架，必要时补充辅助框架。
-
-产物：`<Path>{roots.state}/person/changes/{change}/strategy.md</Path>`
-
-**完成标准**：主框架已选定并充分展开，阶段划分清晰（至少分两步），有明确的关键战役判断，strategy.md 无残留 `[TODO:]`。
-
-### 4. 组织行动
-
-依赖步骤 3 的 strategy.md。委托给 `<Path>{roots.workflows}/person/M-mao-zedong-cognitive-os/mobilize.md</Path>`。将战略转化为具体行动方案——谁来干、干什么、什么时候干完、干到什么程度算好、干砸了怎么办。
-
-产物：`<Path>{roots.state}/person/changes/{change}/action-plan.md</Path>`
-
-**完成标准**：行动、责任与反馈机制已明确，action-plan.md 无残留 `[TODO:]`。
-
-### 5. 综合交付
-
-依赖前四步全部产物。委托给 `<Path>{roots.workflows}/person/M-mao-zedong-cognitive-os/deliver.md</Path>`。按模板 `../_templates/mao-consultation-output-template.md` 整合为连贯的教员第一人称咨询输出——五拍论证节奏、收尾四动作、引用纪律、反模式检查和内在张力标注。
-
-产物：`<Path>{roots.state}/person/changes/{change}/consultation-output.md</Path>`
-
-**完成标准**：已整合四阶段产物为连贯的教员第一人称咨询输出，五拍论证节奏可辨识，收尾四动作齐全，所有毛泽东原文引用均带篇目出处，反模式检查通过，consultation-output.md 无残留 `[TODO:]`。
-
-## 依赖关系
-
-- 步骤 2「诊断分析」依赖步骤 1「激活与问诊」
-- 步骤 3「战略制定」依赖步骤 2「诊断分析」
-- 步骤 4「组织行动」依赖步骤 3「战略制定」
-- 步骤 5「综合交付」依赖步骤 4「组织行动」
-
-所有步骤为硬依赖——前一产物必须完成并验证后才能进入下一步。
+需要引用时，先读当前 phase 的 framework index，再在 `<Path>{roots.workflows}/person/M-mao-zedong-cognitive-os/references/research/15-quote-bank.md</Path>` 定位篇目编号，最后仅回读匹配的原文。目录映射查询 `<Path>{roots.workflows}/person/M-mao-zedong-cognitive-os/books/README.md</Path>`；无匹配证据则停止该引用或依赖结论，不扫描整套书籍。
 
 ## 状态追踪
 
@@ -82,16 +40,3 @@ keywords: [毛泽东, 毛选, 矛盾分析, 战略, 组织, 咨询]
 - **`methods_applied`**（数组）—— 组织阶段已应用的 Module C 方法列表
 - **`quotes_cited`**（数组）—— 已引用的毛泽东原话及出处
 - **`consultation_status`**（字符串）—— 当前阶段：`activating` → `diagnosing` → `strategizing` → `mobilizing` → `delivering` → `completed`
-
-## 渐进披露
-
-角色、声音、模型和引用规则继续由各 phase 文件及其相对引用拥有；未进入 phase 时不加载对应材料。
-
-| 文件 | 触发条件 |
-|------|----------|
-| `<Path>{roots.workflows}/person/M-mao-zedong-cognitive-os/activate.md</Path>` | 步骤 1「激活与问诊」进入时 |
-| `<Path>{roots.workflows}/person/M-mao-zedong-cognitive-os/diagnose.md</Path>` | 步骤 2「诊断分析」进入时 |
-| `<Path>{roots.workflows}/person/M-mao-zedong-cognitive-os/strategize.md</Path>` | 步骤 3「战略制定」进入时 |
-| `<Path>{roots.workflows}/person/M-mao-zedong-cognitive-os/mobilize.md</Path>` | 步骤 4「组织行动」进入时 |
-| `<Path>{roots.workflows}/person/M-mao-zedong-cognitive-os/deliver.md</Path>` | 步骤 5「综合交付」进入时 |
-| `<Path>{roots.workflows}/person/M-mao-zedong-cognitive-os/books/README.md</Path>` | 需要查原文时——引语库 `references/research/15-quote-bank.md` 映射篇目编号到 books 目录 |

package/template/workflows/person/S-steelman-deliberation/S-steelman-deliberation.md

@@ -9,39 +9,13 @@ keywords: [双向钢人, steelman, 决策, 反谄媚, 关键变量, 明确判断
 
 # 双向钢人论证
 
-本 work 的主导词是**钢人化**。它不负责替用户把既有立场说得更顺耳，也不以“正反都说一点”制造表面平衡；它负责在结论形成前，把用户真正要解决的问题、支持当前倾向的最强可信论证、反对当前倾向的最强可信论证和决定结论的变量同时推进到可检验状态，再只关闭一个最高价值的不确定性，最后承担判断责任。
+重述用户真正的问题，分别形成支持与反对当前倾向的最强可信论证，找出分歧和关键变量，只关闭一个最高价值的不确定性，再给出明确判断与可验证行动。不以虚假平衡、迎合立场或通用建议替代判断。
 
-核心动作保持为：
+激活时读取 `<Path>{roots.workflows}/person/INDEX.md</Path>` 与 `<Path>{roots.workflows}/person/common/rules/activation-and-memory.md</Path>`；Person 不使用不存在的 README。
 
-1. 用最完整、最有力的方式，重述用户真正想解决的问题；
-2. 使用钢人论证法，分别给出支持当前想法与反对它的最强论证；
-3. 找出双方真正的分歧，以及最可能改变结论的关键变量；
-4. 只问用户一个最关键的问题；等用户回答后，再给出明确判断、理由和下一步行动。
+## 输入与权威
 
-## 读取范围
-
-1. 先读取 `<Path>{roots.workflows}/person/INDEX.md</Path>` 与当前 Work 的状态入口；Person 使用整文件 INDEX，不加载不存在的 README。
-2. 再读取 `<Path>{roots.workflows}/person/common/rules/activation-and-memory.md</Path>`，按当前分支、状态和关键词定位最小相关工件。
-3. 只在本 Work 明确要求恢复、冲突、执行安全或归档证据时扩展为全量读取；缺少匹配证据或 owner/gateway 时停止受影响分支。
-
-
-## 输入、权威与边界
-
-### 必需输入
-
-- 一个需要选择、判断、取舍、排序或制定策略的具体问题。
-
-缺失可识别问题，或输入只是无需权衡的事实查询时，返回 `blocked-input`，说明缺少什么，不制造虚假争论。
-
-### 可选输入
-
-- 用户当前倾向、候选方案与反对意见；
-- 时间窗口、预算、资源、风险和不可逆约束；
-- 已知事实、项目材料、证据或外部来源；
-- 用户已经明确的目标、价值排序和成功标准；
-- 调用方显式提供的 `{change}`。
-
-不存在的可选输入静默跳过；已经明确的信息不得重复询问。
+必需一个需要选择、判断、排序或策略的具体问题；缺失或只是无需权衡的事实查询时返回 `blocked-input`，不制造争论。按已知情况采用用户倾向、候选/反对意见、时间/预算/资源、不可逆约束、事实来源、价值目标和调用方 change；缺失的可选内容静默跳过，已明确信息不重复问。
 
 ### 权威顺序
 
@@ -64,7 +38,9 @@ keywords: [双向钢人, steelman, 决策, 反谄媚, 关键变量, 明确判断
 
 它不修改其他 person work 的产物或 active 条目，不把运行时状态写回 `{roots.workflows}/person/_state/`，也不提交、推送、发布、部署或执行不可逆操作。
 
-## 流程
+## 按持久化阶段执行
+
+新建、恢复或状态写入前读取 `<Path>{roots.workflows}/person/S-steelman-deliberation/references/state-and-publication.md</Path>`，遵守 v1 字段、候选校验、原子替换顺序和未知字段保留；不得覆盖其他 Work。
 
 ### 1. 解析 roots，选择或恢复 change
 
@@ -94,23 +70,9 @@ keywords: [双向钢人, steelman, 决策, 反谄媚, 关键变量, 明确判断
 
 ### 3. 回答前的双向钢人化
 
-仅在没有有效 dossier 时读取 `<Path>{roots.workflows}/person/S-steelman-deliberation/deliberate.md</Path>`，按其顺序完成真实问题重述、证据分层、双向钢人、分歧与关键变量识别，并形成唯一关键问题。
-
-若问题依赖会变化的公开事实、专业事实、冲突材料、代码/测试/配置，或属于医疗、法律、财务、安全等高风险领域，再读取 `<Path>{roots.workflows}/person/S-steelman-deliberation/evidence-gate.md</Path>`；可发现的事实先探索，不拿来问用户。
-
-使用 `<Path>{roots.workflows}/person/S-steelman-deliberation/_templates/steelman-dossier-template.md</Path>` 在 change 目录下的唯一临时子目录中写入候选 dossier 与候选 `.status.json`，重读后运行：
+仅在无有效 dossier 时读取 `<Path>{roots.workflows}/person/S-steelman-deliberation/deliberate.md</Path>`，完整重述问题、分层证据、正反钢人、分歧与关键变量，形成唯一关键问题。变化事实、专业事实、冲突材料、代码或高风险领域还须读 `<Path>{roots.workflows}/person/S-steelman-deliberation/evidence-gate.md</Path>`；可发现的事实先探索，不拿来问用户。
 
-```bash
-node <Path>{roots.workflows}/person/S-steelman-deliberation/tools/validate-steelman-change.mjs</Path> \
-  --phase awaiting-answer \
-  --change-dir <Path>{roots.state}/person/changes/{change}</Path> \
-  --dossier-file <Path>{roots.state}/person/changes/{change}/.steelman-stage/steelman-dossier.md</Path> \
-  --status-file <Path>{roots.state}/person/changes/{change}/.steelman-stage/.status.json</Path>
-```
-
-临时目录名在并发时追加唯一后缀。校验通过后，先原子替换正式 dossier，再原子替换 change `.status.json`；workflow active 只在步骤 4 确认需要等待用户时更新。校验失败时删除临时目录并保持正式工件和旧状态不变。
-
-**完成标准**：dossier 是回答前的冻结快照；正反最强可信论证、真正分歧、关键变量和唯一问题均存在；没有最终判断或行动建议；校验退出码为 0。
+按状态与发布合同的“回答前”分支创建、校验并发布 dossier；其中没有最终判断或行动建议，退出码必须为 0。该 dossier 随后冻结。
 
 ### 4. 只关闭一个最高价值的不确定性
 
@@ -132,73 +94,9 @@ node <Path>{roots.workflows}/person/S-steelman-deliberation/tools/validate-steel
 
 ### 5. 明确裁决并形成行动
 
-关键问题得到有效回答后，将回答原文写入 change `.status.json`，设置 `phase: judging`，再读取 `<Path>{roots.workflows}/person/S-steelman-deliberation/judge.md</Path>`。必须基于冻结 dossier 和用户回答裁决，不重做一份迎合回答的新钢人分析。
-
-使用 `<Path>{roots.workflows}/person/S-steelman-deliberation/_templates/decision-template.md</Path>` 在唯一临时目录中写入候选 decision 与候选完成态 `.status.json`，随后运行：
+得到有效回答后原样保存，设置 `phase: judging`，再读取 `<Path>{roots.workflows}/person/S-steelman-deliberation/judge.md</Path>`。以冻结 dossier 和真实回答裁决，不重做迎合回答的新分析。
 
-```bash
-node <Path>{roots.workflows}/person/S-steelman-deliberation/tools/validate-steelman-change.mjs</Path> \
-  --phase completed \
-  --change-dir <Path>{roots.state}/person/changes/{change}</Path> \
-  --decision-file <Path>{roots.state}/person/changes/{change}/.steelman-stage/decision.md</Path> \
-  --status-file <Path>{roots.state}/person/changes/{change}/.steelman-stage/.status.json</Path>
-```
-
-校验通过后才原子替换正式 decision 和 change 状态，并只从 workflow `status.json.active` 删除匹配当前 `change` 且属于本 work 的条目。校验失败时删除临时目录、返回 `validation-failed`，保留可恢复的 `judging` 状态。
-
-**完成标准**：decision 给出明确判断、决定性理由、对最强反方的回应、具体行动、反转条件及置信度；状态与工件一致；校验退出码为 0。
-
-## 状态合同
-
-### Workflow 状态
-
-`<Path>{roots.state}/person/status.json</Path>` 保持 `schema_version: 1`，本 work 只管理 `active` 数组中的如下条目：
-
-```json
-{
-  "change": "2026-08-18-steelman-company-anniversary",
-  "work_id": "person/steelman-deliberation",
-  "phase": "awaiting-answer",
-  "updated_at": "2026-08-18T00:00:00.000Z"
-}
-```
-
-读取—合并—写入时保留未知顶层字段、未知 entry 字段和其他 work 的全部条目。写临时文件、重读 JSON、再原子替换。
-
-### Change 状态
-
-`<Path>{roots.state}/person/changes/{change}/.status.json</Path>` 至少包含：
-
-```json
-{
-  "schema_version": 1,
-  "artifact": "person-work-status",
-  "workflow": "person",
-  "change": "2026-08-18-steelman-company-anniversary",
-  "work_id": "person/steelman-deliberation",
-  "status": "active",
-  "phase": "awaiting-answer",
-  "key_question": "[唯一关键问题]",
-  "key_question_asked": true,
-  "question_disposition": "asked",
-  "answer_received": false,
-  "user_answer": null,
-  "created_at": "2026-08-18T00:00:00.000Z",
-  "updated_at": "2026-08-18T00:00:00.000Z",
-  "completed_at": null,
-  "blockers": []
-}
-```
-
-允许转换：
-
-```text
-intake → deliberating → awaiting-answer → judging → completed
-任一活动阶段 → blocked
-awaiting-answer → reframe-required
-```
-
-`question_disposition` 只能是 `asked | already-answered`；前者要求 `key_question_asked: true`，后者要求 `key_question_asked: false`。工件先验证，change 状态后更新，workflow active 最后更新。状态只是工件的索引，不替代工件本身。
+按状态与发布合同的“回答后”分支校验候选 decision 后才发布并关闭本 Work 的 active 条目；失败保留可恢复的 judging，不报完成。decision 必须包含明确判断、决定性理由、最强反方回应、具体行动、反转条件与置信度，且能追溯到关键变量和回答。
 
 ## 返回合同
 
@@ -213,13 +111,3 @@ awaiting-answer → reframe-required
 - 下一路由：等待回答时返回 `<Path>{roots.workflows}/person/S-steelman-deliberation/S-steelman-deliberation.md</Path>` 并携带同一 change；问题已重构时创建新 change；否则明确完成。
 
 只有 `completed` 才能声明已经形成最终判断。`awaiting-user-answer` 的下一路由始终是带着同一 change 回到本入口。
-
-## 全局完成标准
-
-- 用户真正要解决的问题与表层问法已区分；
-- 当前倾向和最强反方都经过可信、可识别的钢人化；
-- 没有编造证据、虚假平衡或因用户立场降低证据标准；
-- 只关闭了一个最高价值的不确定性，且没有重复追问已知信息；
-- 回答前 dossier 保持冻结，回答后 decision 可追溯到关键变量和用户回答；
-- 最终答案不是任何人都能套用的通用建议，而是明确判断与可验证行动；
-- owned 工件、change 状态与 workflow active 一致，验证证据已返回。