183 lines
9.8 KiB
JavaScript
183 lines
9.8 KiB
JavaScript
#!/usr/bin/env node
|
||
import crypto from "node:crypto";
|
||
import fs from "node:fs";
|
||
import path from "node:path";
|
||
|
||
export const DEFAULT_ANCHOR_ROOT = "/Volumes/JZAO/HoloLake/persona-runtime/task-language-anchors/zcode";
|
||
export const DEFAULT_ZERO_CORE_TASK_ROOT = "/Volumes/JZAO/HoloLake/persona-runtime/task-language-anchors/zero-core";
|
||
export const FIRST_PATH_NAME = "00-冰朔自然语言瞄点";
|
||
export const STAGE_RECEIPT_DIR = "10-阶段回读回执";
|
||
export const ENGINEERING_MAP_PATH = "01-自然语言到工程阶段映射/current.tcs";
|
||
export const STAGE_TTL_MS = 30 * 60 * 1000;
|
||
export const STAGE_TOOL_BUDGET = 20;
|
||
|
||
function safeToken(value, fallback = "unknown") {
|
||
const token = String(value ?? "").trim().replaceAll(/[^a-zA-Z0-9._-]/gu, "-");
|
||
return token || fallback;
|
||
}
|
||
function sha256(value) { return crypto.createHash("sha256").update(value).digest("hex"); }
|
||
function readJson(file) {
|
||
try { return JSON.parse(fs.readFileSync(file, "utf8")); } catch { return null; }
|
||
}
|
||
function atomicWriteText(file, value) {
|
||
fs.mkdirSync(path.dirname(file), { recursive: true });
|
||
const temporary = `${file}.${process.pid}.${crypto.randomUUID()}.tmp`;
|
||
fs.writeFileSync(temporary, value, { encoding: "utf8", mode: 0o600 });
|
||
fs.renameSync(temporary, file);
|
||
}
|
||
function atomicWriteJson(file, value) { atomicWriteText(file, `${JSON.stringify(value, null, 2)}\n`); }
|
||
|
||
export function taskNumberFor(sessionId) {
|
||
return `CODEX-TASK-${safeToken(sessionId, "unknown-session")}`;
|
||
}
|
||
export function taskRootFor(sessionId, anchorRoot = process.env.GH_CODEX_TASK_ANCHOR_ROOT ?? DEFAULT_ANCHOR_ROOT) {
|
||
return path.join(anchorRoot, taskNumberFor(sessionId));
|
||
}
|
||
|
||
export function registerTaskAnchor({ sessionId, turnId, rawText, channelId, occurredAt = new Date().toISOString() }) {
|
||
if (!String(rawText ?? "").trim()) throw new Error("RAW_TEXT_REQUIRED");
|
||
const taskNumber = taskNumberFor(sessionId);
|
||
const taskRoot = taskRootFor(sessionId);
|
||
const anchorRoot = path.join(taskRoot, FIRST_PATH_NAME);
|
||
const manifestPath = path.join(taskRoot, "task.json");
|
||
const prior = readJson(manifestPath);
|
||
const rawTextSha256 = sha256(rawText);
|
||
const safeTurn = safeToken(turnId, crypto.randomUUID());
|
||
const duplicate = prior?.events?.find((item) => item.turn_id === safeTurn && item.raw_text_sha256 === rawTextSha256);
|
||
if (duplicate) return { ...duplicate, task_number: taskNumber, task_root: taskRoot, first_path: anchorRoot };
|
||
const sequence = String((prior?.event_count ?? 0) + 1).padStart(6, "0");
|
||
const stem = `${sequence}-${safeTurn}-${rawTextSha256.slice(0, 12)}`;
|
||
const rawPath = path.join(anchorRoot, `${stem}.raw.txt`);
|
||
const metadataPath = path.join(anchorRoot, `${stem}.json`);
|
||
atomicWriteText(rawPath, rawText);
|
||
const event = {
|
||
schema: "guanghu.codex-task-natural-language-anchor-event/v1",
|
||
task_number: taskNumber,
|
||
thread_id: safeToken(sessionId, "unknown-session"),
|
||
turn_id: safeTurn,
|
||
sequence: Number(sequence),
|
||
channel_id: channelId ?? "UNKNOWN",
|
||
source: "BINGSHUO_DIRECT_NATURAL_LANGUAGE",
|
||
raw_text_path: rawPath,
|
||
raw_text_sha256: rawTextSha256,
|
||
occurred_at: occurredAt,
|
||
};
|
||
atomicWriteJson(metadataPath, event);
|
||
const events = [...(prior?.events ?? []), { ...event, metadata_path: metadataPath }];
|
||
const first = events[0];
|
||
const current = events.at(-1);
|
||
const manifest = {
|
||
schema: "guanghu.codex-task-natural-language-anchor/v1",
|
||
task_number: taskNumber,
|
||
thread_id: safeToken(sessionId, "unknown-session"),
|
||
first_path: anchorRoot,
|
||
first_event_path: first.raw_text_path,
|
||
first_event_sha256: first.raw_text_sha256,
|
||
current_event_path: current.raw_text_path,
|
||
current_event_sha256: current.raw_text_sha256,
|
||
event_count: events.length,
|
||
events,
|
||
updated_at: occurredAt,
|
||
};
|
||
atomicWriteJson(manifestPath, manifest);
|
||
atomicWriteJson(path.join(anchorRoot, "first.json"), { task_number: taskNumber, raw_text_path: first.raw_text_path, raw_text_sha256: first.raw_text_sha256 });
|
||
atomicWriteJson(path.join(anchorRoot, "current.json"), { task_number: taskNumber, raw_text_path: current.raw_text_path, raw_text_sha256: current.raw_text_sha256 });
|
||
return { ...event, metadata_path: metadataPath, task_root: taskRoot, first_path: anchorRoot };
|
||
}
|
||
|
||
export function verifyTaskAnchor({ sessionId, turnId, controlEpoch, stage, deliverable }) {
|
||
if (!stage?.trim()) throw new Error("STAGE_REQUIRED");
|
||
if (!deliverable?.trim()) throw new Error("DELIVERABLE_REQUIRED");
|
||
const taskRoot = taskRootFor(sessionId);
|
||
const manifest = readJson(path.join(taskRoot, "task.json"));
|
||
if (manifest?.schema !== "guanghu.codex-task-natural-language-anchor/v1") throw new Error(`TASK_ANCHOR_MISSING:${taskRoot}`);
|
||
const firstRaw = fs.readFileSync(manifest.first_event_path, "utf8");
|
||
const currentRaw = fs.readFileSync(manifest.current_event_path, "utf8");
|
||
const engineeringMapPath = path.join(taskRoot, ENGINEERING_MAP_PATH);
|
||
const engineeringMap = fs.readFileSync(engineeringMapPath, "utf8");
|
||
const developmentLink = readJson(path.join(taskRoot, "development-task-link.json"));
|
||
let developmentTask = null;
|
||
let dualStartAnchors = [];
|
||
let developmentEngineeringMap = null;
|
||
if (developmentLink?.schema === "guanghu.codex-to-development-task-link/v1") {
|
||
developmentTask = readJson(developmentLink.development_task_manifest);
|
||
if (
|
||
developmentTask?.schema !== "guanghu.zero-core-development-task/v1" ||
|
||
developmentTask.current_host_thread !== safeToken(sessionId, "unknown-session")
|
||
) throw new Error("DEVELOPMENT_TASK_NOT_BOUND_TO_CURRENT_HOST_THREAD");
|
||
dualStartAnchors = developmentTask.dual_start_anchors.map((anchor) => {
|
||
const raw = fs.readFileSync(anchor.raw_text_path, "utf8");
|
||
if (sha256(raw) !== anchor.raw_text_sha256) throw new Error(`DEVELOPMENT_DUAL_START_HASH_MISMATCH:${anchor.role}`);
|
||
return { ...anchor, raw };
|
||
});
|
||
developmentEngineeringMap = fs.readFileSync(developmentTask.tcs_engineering_map, "utf8");
|
||
}
|
||
if (sha256(firstRaw) !== manifest.first_event_sha256) throw new Error("FIRST_ANCHOR_HASH_MISMATCH");
|
||
if (sha256(currentRaw) !== manifest.current_event_sha256) throw new Error("CURRENT_ANCHOR_HASH_MISMATCH");
|
||
const checkedAtUnixMs = Date.now();
|
||
const receipt = {
|
||
schema: "guanghu.codex-task-stage-anchor-read-receipt/v1",
|
||
task_number: manifest.task_number,
|
||
session_id: safeToken(sessionId, "unknown-session"),
|
||
turn_id: safeToken(turnId, "unknown-turn"),
|
||
control_epoch: controlEpoch,
|
||
stage: stage.trim(),
|
||
declared_deliverable: deliverable.trim(),
|
||
first_event_path: manifest.first_event_path,
|
||
first_event_sha256: manifest.first_event_sha256,
|
||
current_event_path: manifest.current_event_path,
|
||
current_event_sha256: manifest.current_event_sha256,
|
||
engineering_map_path: engineeringMapPath,
|
||
engineering_map_sha256: sha256(engineeringMap),
|
||
development_task_number: developmentTask?.development_task_number ?? null,
|
||
development_task_manifest: developmentLink?.development_task_manifest ?? null,
|
||
development_dual_start_sha256: dualStartAnchors.map((anchor) => anchor.raw_text_sha256),
|
||
development_engineering_map_path: developmentTask?.tcs_engineering_map ?? null,
|
||
development_engineering_map_sha256: developmentEngineeringMap ? sha256(developmentEngineeringMap) : null,
|
||
checked_at: new Date(checkedAtUnixMs).toISOString(),
|
||
checked_at_unix_ms: checkedAtUnixMs,
|
||
expires_at_unix_ms: checkedAtUnixMs + STAGE_TTL_MS,
|
||
capability_calls_used: 0,
|
||
capability_calls_max: STAGE_TOOL_BUDGET,
|
||
progress_semantics: "ONLY_TARGET_ARTIFACT_TEST_STATE_OR_ACCEPTANCE_ADVANCEMENT_COUNTS",
|
||
};
|
||
const receiptRoot = path.join(taskRoot, STAGE_RECEIPT_DIR);
|
||
const receiptPath = path.join(receiptRoot, `${receipt.turn_id}-${safeToken(stage)}-${checkedAtUnixMs}.json`);
|
||
atomicWriteJson(receiptPath, receipt);
|
||
atomicWriteJson(path.join(receiptRoot, "current.json"), { ...receipt, receipt_path: receiptPath });
|
||
return { manifest, receipt, receiptPath, firstRaw, currentRaw, engineeringMap, developmentTask, dualStartAnchors, developmentEngineeringMap };
|
||
}
|
||
|
||
function valueAfter(argv, name) { const index = argv.indexOf(name); return index >= 0 ? argv[index + 1] : null; }
|
||
function runCli() {
|
||
const [command, ...argv] = process.argv.slice(2);
|
||
if (command !== "verify") {
|
||
process.stderr.write("usage: codex-task-anchor-gate.mjs verify --session-id ID --turn-id ID --control-epoch ID --stage NAME --deliverable TEXT\n");
|
||
process.exit(2);
|
||
}
|
||
try {
|
||
const result = verifyTaskAnchor({
|
||
sessionId: valueAfter(argv, "--session-id"), turnId: valueAfter(argv, "--turn-id"),
|
||
controlEpoch: valueAfter(argv, "--control-epoch"), stage: valueAfter(argv, "--stage"), deliverable: valueAfter(argv, "--deliverable"),
|
||
});
|
||
process.stdout.write([
|
||
"CODEX_TASK_ANCHOR_STAGE_GATE PASS", `task_number=${result.manifest.task_number}`,
|
||
`development_task_number=${result.developmentTask?.development_task_number ?? "NONE"}`,
|
||
`first_path=${result.manifest.first_path}`, `receipt_path=${result.receiptPath}`,
|
||
...result.dualStartAnchors.flatMap((anchor, index) => [
|
||
`--- 零点原核正式开发双启动瞄点 ${index + 1}：${anchor.role} ---`,
|
||
anchor.raw,
|
||
]),
|
||
...(result.developmentEngineeringMap ? ["--- 零点原核正式开发TCS工程阶段与因果闭环 ---", result.developmentEngineeringMap] : []),
|
||
"--- 冰朔首条自然语言（原文） ---", result.firstRaw,
|
||
"--- 冰朔当前自然语言（原文） ---", result.currentRaw,
|
||
"--- 自然语言到工程阶段映射（TCS） ---", result.engineeringMap,
|
||
"--- 本阶段唯一交付物 ---", result.receipt.declared_deliverable,
|
||
"提醒：语料、报告、仓库副本和研究量增长本身不算产品进度。",
|
||
].join("\n"));
|
||
} catch (error) {
|
||
process.stderr.write(`CODEX_TASK_ANCHOR_STAGE_GATE FAIL ${error.message}\n`);
|
||
process.exit(1);
|
||
}
|
||
}
|
||
if (import.meta.url === `file://${process.argv[1]}`) runCli();
|