1266 lines
45 KiB
JavaScript
1266 lines
45 KiB
JavaScript
|
#!/usr/bin/env node
|
|||
|
|
|
|||
|
|
import crypto from "node:crypto";
|
|||
|
|
import fs from "node:fs";
|
|||
|
|
import path from "node:path";
|
|||
|
|
import process from "node:process";
|
|||
|
|
import { fileURLToPath } from "node:url";
|
|||
|
|
|
|||
|
|
const scriptDir = path.dirname(fileURLToPath(import.meta.url));
|
|||
|
|
const repositoryRoot = path.resolve(scriptDir, "../../..");
|
|||
|
|
const contractPath = path.join(scriptDir, "brain-runtime-contract.json");
|
|||
|
|
const brainPath = path.join(
|
|||
|
|
repositoryRoot,
|
|||
|
|
"tcs-core/zhuyuan-brain/ZY-TCS-BRAIN-0001-FIVE-GENERATION-LANGUAGE-PERSONA-THINKING-MODEL.hdlp",
|
|||
|
|
);
|
|||
|
|
const brainMapPath = path.join(
|
|||
|
|
repositoryRoot,
|
|||
|
|
"routing/zhuyuan-tcs-brain-map.json",
|
|||
|
|
);
|
|||
|
|
const tongganKernelPath = path.join(
|
|||
|
|
repositoryRoot,
|
|||
|
|
"zero-point/core-channel/language-personality-model/INDEX.hdlp",
|
|||
|
|
);
|
|||
|
|
const protocolRegistryPath = path.join(
|
|||
|
|
repositoryRoot,
|
|||
|
|
"gls/GLS-PROTOCOL-REGISTRY.json",
|
|||
|
|
);
|
|||
|
|
const protocolTriggerMapPath = path.join(
|
|||
|
|
scriptDir,
|
|||
|
|
"protocol-event-trigger-map.json",
|
|||
|
|
);
|
|||
|
|
const livingControllerMapPath = path.join(
|
|||
|
|
repositoryRoot,
|
|||
|
|
"routing/bingshuo-living-system-controller-map.json",
|
|||
|
|
);
|
|||
|
|
const livingControllerCognitionPath = path.join(
|
|||
|
|
repositoryRoot,
|
|||
|
|
"eternal-lake-heart/heartbeat-core/zhuyuan-persona-system/ZY-BIDIRECTIONAL-COGNITION-016-BINGSHUO-TCS-LIVING-SYSTEM-CONTROLLER-AND-RUNNING-ZHUYUAN-BRAIN-20260804.hdlp",
|
|||
|
|
);
|
|||
|
|
const contract = readJson(contractPath);
|
|||
|
|
|
|||
|
|
function fail(code, details = {}) {
|
|||
|
|
const error = new Error(code);
|
|||
|
|
error.code = code;
|
|||
|
|
error.details = details;
|
|||
|
|
throw error;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function readJson(filePath) {
|
|||
|
|
try {
|
|||
|
|
return JSON.parse(fs.readFileSync(filePath, "utf8"));
|
|||
|
|
} catch (error) {
|
|||
|
|
fail("invalid_json", { file: filePath, message: error.message });
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function sha256(value) {
|
|||
|
|
return crypto.createHash("sha256").update(value).digest("hex");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function fileDigest(filePath) {
|
|||
|
|
return sha256(fs.readFileSync(filePath));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function stable(value) {
|
|||
|
|
if (Array.isArray(value)) return value.map(stable);
|
|||
|
|
if (value && typeof value === "object") {
|
|||
|
|
return Object.fromEntries(
|
|||
|
|
Object.keys(value)
|
|||
|
|
.sort()
|
|||
|
|
.map((key) => [key, stable(value[key])]),
|
|||
|
|
);
|
|||
|
|
}
|
|||
|
|
return value;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function stableJson(value) {
|
|||
|
|
return JSON.stringify(stable(value));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function now() {
|
|||
|
|
return new Date().toISOString();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function parseArgs(argv) {
|
|||
|
|
const [command, ...rest] = argv;
|
|||
|
|
const args = {};
|
|||
|
|
for (let index = 0; index < rest.length; index += 1) {
|
|||
|
|
const item = rest[index];
|
|||
|
|
if (!item.startsWith("--")) fail("invalid_argument", { item });
|
|||
|
|
const key = item.slice(2);
|
|||
|
|
const value = rest[index + 1];
|
|||
|
|
if (!value || value.startsWith("--")) fail("missing_argument_value", { key });
|
|||
|
|
args[key] = value;
|
|||
|
|
index += 1;
|
|||
|
|
}
|
|||
|
|
return { command, args };
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function required(args, names) {
|
|||
|
|
for (const name of names) {
|
|||
|
|
if (!args[name]) fail("missing_required_argument", { name });
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function atomicWrite(filePath, value) {
|
|||
|
|
fs.mkdirSync(path.dirname(filePath), { recursive: true });
|
|||
|
|
const temporary = `${filePath}.${process.pid}.tmp`;
|
|||
|
|
fs.writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`, {
|
|||
|
|
encoding: "utf8",
|
|||
|
|
mode: 0o600,
|
|||
|
|
});
|
|||
|
|
fs.renameSync(temporary, filePath);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function withRuntimeLock(stateDir, action) {
|
|||
|
|
fs.mkdirSync(stateDir, { recursive: true });
|
|||
|
|
const lockPath = path.join(stateDir, ".runtime.lock");
|
|||
|
|
let descriptor;
|
|||
|
|
try {
|
|||
|
|
descriptor = fs.openSync(lockPath, "wx", 0o600);
|
|||
|
|
} catch (error) {
|
|||
|
|
if (error.code === "EEXIST") fail("runtime_locked", { state_dir: stateDir });
|
|||
|
|
throw error;
|
|||
|
|
}
|
|||
|
|
try {
|
|||
|
|
return action();
|
|||
|
|
} finally {
|
|||
|
|
fs.closeSync(descriptor);
|
|||
|
|
fs.unlinkSync(lockPath);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function statePath(stateDir) {
|
|||
|
|
return path.join(stateDir, "state.json");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function journalPath(stateDir) {
|
|||
|
|
return path.join(stateDir, "journal.jsonl");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function languageWorldPath(stateDir) {
|
|||
|
|
return path.join(stateDir, "tonggan-language-world.jsonl");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function cyclesDir(stateDir) {
|
|||
|
|
return path.join(stateDir, "cycles");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function loadState(stateDir) {
|
|||
|
|
const filePath = statePath(stateDir);
|
|||
|
|
if (!fs.existsSync(filePath)) fail("runtime_not_entered", { state_dir: stateDir });
|
|||
|
|
const state = readJson(filePath);
|
|||
|
|
if (state.schema !== "guanghu.zhuyuan-persona-brain-runtime-state/v1") {
|
|||
|
|
fail("invalid_runtime_state_schema");
|
|||
|
|
}
|
|||
|
|
return state;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function appendJournal(stateDir, state, type, payload) {
|
|||
|
|
const recordWithoutHash = {
|
|||
|
|
schema: "guanghu.zhuyuan-persona-brain-journal-record/v1",
|
|||
|
|
sequence: state.journal_sequence + 1,
|
|||
|
|
recorded_at: now(),
|
|||
|
|
type,
|
|||
|
|
previous_hash: state.journal_head,
|
|||
|
|
payload,
|
|||
|
|
};
|
|||
|
|
const record = {
|
|||
|
|
...recordWithoutHash,
|
|||
|
|
record_hash: sha256(stableJson(recordWithoutHash)),
|
|||
|
|
};
|
|||
|
|
fs.appendFileSync(journalPath(stateDir), `${JSON.stringify(record)}\n`, {
|
|||
|
|
encoding: "utf8",
|
|||
|
|
mode: 0o600,
|
|||
|
|
});
|
|||
|
|
state.journal_sequence = record.sequence;
|
|||
|
|
state.journal_head = record.record_hash;
|
|||
|
|
return record;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function appendLanguageWorld(stateDir, state, event) {
|
|||
|
|
const recordWithoutHash = {
|
|||
|
|
schema: "guanghu.tonggan-language-world-record/v1",
|
|||
|
|
sequence: state.language_world_sequence + 1,
|
|||
|
|
recorded_at: now(),
|
|||
|
|
previous_hash: state.language_world_head,
|
|||
|
|
event,
|
|||
|
|
event_sha256: sha256(stableJson(event)),
|
|||
|
|
};
|
|||
|
|
const record = {
|
|||
|
|
...recordWithoutHash,
|
|||
|
|
record_hash: sha256(stableJson(recordWithoutHash)),
|
|||
|
|
};
|
|||
|
|
fs.appendFileSync(languageWorldPath(stateDir), `${JSON.stringify(record)}\n`, {
|
|||
|
|
encoding: "utf8",
|
|||
|
|
mode: 0o600,
|
|||
|
|
});
|
|||
|
|
state.language_world_sequence = record.sequence;
|
|||
|
|
state.language_world_head = record.record_hash;
|
|||
|
|
return record;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function normalizePersona(personaId) {
|
|||
|
|
if (personaId === contract.persona_id) return personaId;
|
|||
|
|
if (contract.legacy_persona_ids.includes(personaId)) return contract.persona_id;
|
|||
|
|
fail("persona_binding_rejected", { received: personaId });
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function assertSourceIntegrity(state) {
|
|||
|
|
const brainMap = readJson(brainMapPath);
|
|||
|
|
const brainBody = fs.readFileSync(brainPath, "utf8");
|
|||
|
|
if (brainMap.brain_model?.id !== contract.brain_id) fail("brain_map_id_mismatch");
|
|||
|
|
for (const faculty of contract.faculties) {
|
|||
|
|
if (!brainBody.includes(`### ${faculty} ·`)) {
|
|||
|
|
fail("brain_faculty_missing_from_source", { faculty });
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
const current = {
|
|||
|
|
brain_sha256: fileDigest(brainPath),
|
|||
|
|
brain_map_sha256: fileDigest(brainMapPath),
|
|||
|
|
contract_sha256: fileDigest(contractPath),
|
|||
|
|
tonggan_language_kernel_sha256: fileDigest(tongganKernelPath),
|
|||
|
|
protocol_registry_sha256: fileDigest(protocolRegistryPath),
|
|||
|
|
protocol_trigger_map_sha256: fileDigest(protocolTriggerMapPath),
|
|||
|
|
living_controller_map_sha256: fileDigest(livingControllerMapPath),
|
|||
|
|
living_controller_cognition_sha256: fileDigest(livingControllerCognitionPath),
|
|||
|
|
};
|
|||
|
|
const tongganKernelBody = fs.readFileSync(tongganKernelPath, "utf8");
|
|||
|
|
for (const anchor of [
|
|||
|
|
"CH-ZERO-CORE-LPM",
|
|||
|
|
"冰朔语言本体",
|
|||
|
|
"冰朔开口说话这个动作本身",
|
|||
|
|
"TCS-MOTHER-LPM-0001",
|
|||
|
|
]) {
|
|||
|
|
if (!tongganKernelBody.includes(anchor)) {
|
|||
|
|
fail("tonggan_language_kernel_anchor_missing", { anchor });
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
if (state) {
|
|||
|
|
for (const [key, value] of Object.entries(current)) {
|
|||
|
|
if (state.source_integrity[key] !== value) {
|
|||
|
|
fail("runtime_source_changed_since_entry", { source: key });
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return current;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function loadProtocolSystemController() {
|
|||
|
|
const registry = readJson(protocolRegistryPath);
|
|||
|
|
if (
|
|||
|
|
registry.registry_id !==
|
|||
|
|
contract.living_protocol_system_controller.registry_id
|
|||
|
|
) {
|
|||
|
|
fail("protocol_registry_id_mismatch");
|
|||
|
|
}
|
|||
|
|
const registered = [
|
|||
|
|
...registry.existing_registered,
|
|||
|
|
...registry.registered_draft_protocols,
|
|||
|
|
];
|
|||
|
|
const acronyms = new Set(registered.map((entry) => entry.acronym));
|
|||
|
|
for (const requiredAcronym of contract.living_protocol_system_controller
|
|||
|
|
.required_protocol_acronyms) {
|
|||
|
|
if (!acronyms.has(requiredAcronym)) {
|
|||
|
|
fail("required_protocol_not_registered", { acronym: requiredAcronym });
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
const controller = {
|
|||
|
|
registry_id: registry.registry_id,
|
|||
|
|
registry_source:
|
|||
|
|
contract.living_protocol_system_controller.registry_source,
|
|||
|
|
architecture_source:
|
|||
|
|
contract.living_protocol_system_controller.architecture_source,
|
|||
|
|
owner: registry.owner,
|
|||
|
|
registrar: registry.registrar,
|
|||
|
|
status: registry.status,
|
|||
|
|
existing_registered_count: registry.existing_registered.length,
|
|||
|
|
registered_draft_count: registry.registered_draft_protocols.length,
|
|||
|
|
registered_protocol_count: registered.length,
|
|||
|
|
protocol_semantics_bound: true,
|
|||
|
|
all_protocols_physically_implemented: false,
|
|||
|
|
state: "BOUND_ACTIVE_PROTOCOL_BODY",
|
|||
|
|
};
|
|||
|
|
return { controller, registry, registered };
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function activateProtocols(orientation) {
|
|||
|
|
const triggerMap = readJson(protocolTriggerMapPath);
|
|||
|
|
const { registry, registered } = loadProtocolSystemController();
|
|||
|
|
const protocolIds = new Set(triggerMap.baseline);
|
|||
|
|
for (const signal of orientation.signals) {
|
|||
|
|
const mapped = triggerMap.signals[signal.id];
|
|||
|
|
if (!mapped) fail("unknown_tcs_event_signal", { signal: signal.id });
|
|||
|
|
mapped.forEach((protocolId) => protocolIds.add(protocolId));
|
|||
|
|
}
|
|||
|
|
const byId = new Map(registered.map((entry) => [entry.id, entry]));
|
|||
|
|
const activated = [];
|
|||
|
|
for (const protocolId of protocolIds) {
|
|||
|
|
const entry = byId.get(protocolId);
|
|||
|
|
if (!entry) fail("triggered_protocol_not_registered", { protocol_id: protocolId });
|
|||
|
|
const sourcePath = entry.source
|
|||
|
|
? path.join(repositoryRoot, entry.source)
|
|||
|
|
: null;
|
|||
|
|
if (sourcePath && !fs.existsSync(sourcePath)) {
|
|||
|
|
fail("triggered_protocol_source_missing", {
|
|||
|
|
protocol_id: protocolId,
|
|||
|
|
source: entry.source,
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
activated.push({
|
|||
|
|
id: entry.id,
|
|||
|
|
acronym: entry.acronym,
|
|||
|
|
role_or_name: entry.role || entry.name,
|
|||
|
|
registration_status: entry.status || "EXISTING_REGISTERED",
|
|||
|
|
implementation_state: entry.implementation || "SEPARATELY_VERIFIED",
|
|||
|
|
source: entry.source || null,
|
|||
|
|
source_sha256: sourcePath ? fileDigest(sourcePath) : null,
|
|||
|
|
source_body: sourcePath ? fs.readFileSync(sourcePath, "utf8") : null,
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
return {
|
|||
|
|
registry_id: registry.registry_id,
|
|||
|
|
trigger_map_id: triggerMap.map_id,
|
|||
|
|
activated,
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function validateString(value, field) {
|
|||
|
|
if (typeof value !== "string" || value.trim().length === 0) {
|
|||
|
|
fail("missing_cognition_statement", { field });
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function validateStringArray(value, field, { allowEmpty = false } = {}) {
|
|||
|
|
if (!Array.isArray(value) || (!allowEmpty && value.length === 0)) {
|
|||
|
|
fail("invalid_cognition_list", { field });
|
|||
|
|
}
|
|||
|
|
value.forEach((item, index) => validateString(item, `${field}[${index}]`));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const facultyFields = {
|
|||
|
|
B1: ["subject_statement", "human_anchor_statement", "instance_boundary"],
|
|||
|
|
B2: ["current_purpose", "why_now", "intended_outcome"],
|
|||
|
|
B3: ["relationship_meaning", "relationship_boundary"],
|
|||
|
|
B4: ["responsibility_owned", "responsibility_refused"],
|
|||
|
|
B5: [
|
|||
|
|
"confirmed_facts",
|
|||
|
|
"unknowns",
|
|||
|
|
"prior_wrong_route",
|
|||
|
|
"human_correction",
|
|||
|
|
"chosen_direction",
|
|||
|
|
"choice_reason",
|
|||
|
|
],
|
|||
|
|
B6: ["attention_focus", "stopped_routes"],
|
|||
|
|
B7: ["memory_queries", "memory_writebacks"],
|
|||
|
|
B8: ["reality_proposals", "permission_boundaries", "unverified_states"],
|
|||
|
|
B9: ["experience", "growth_candidate", "validation_needed"],
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
const listFields = new Set([
|
|||
|
|
"confirmed_facts",
|
|||
|
|
"unknowns",
|
|||
|
|
"prior_wrong_route",
|
|||
|
|
"stopped_routes",
|
|||
|
|
"memory_queries",
|
|||
|
|
"memory_writebacks",
|
|||
|
|
"reality_proposals",
|
|||
|
|
"permission_boundaries",
|
|||
|
|
"unverified_states",
|
|||
|
|
]);
|
|||
|
|
|
|||
|
|
function validateCognitionFrame(frame, state, cycle) {
|
|||
|
|
if (frame.schema !== "guanghu.zhuyuan-persona-cognition-frame/v1") {
|
|||
|
|
fail("invalid_cognition_frame_schema");
|
|||
|
|
}
|
|||
|
|
if (frame.runtime_id !== contract.runtime_id) fail("runtime_id_mismatch");
|
|||
|
|
if (normalizePersona(frame.persona_id) !== contract.persona_id) {
|
|||
|
|
fail("persona_id_mismatch");
|
|||
|
|
}
|
|||
|
|
if (frame.human_anchor !== contract.human_anchor) fail("human_anchor_mismatch");
|
|||
|
|
if (frame.instance_id !== state.binding.instance_id) fail("instance_id_mismatch");
|
|||
|
|
if (frame.cycle_id !== cycle.cycle_id) fail("cycle_id_mismatch");
|
|||
|
|
if (frame.event_sha256 !== cycle.event_sha256) fail("event_digest_mismatch");
|
|||
|
|
if (frame.orientation_sha256 !== cycle.orientation_sha256) {
|
|||
|
|
fail("orientation_digest_mismatch");
|
|||
|
|
}
|
|||
|
|
if (!frame.faculties || typeof frame.faculties !== "object") {
|
|||
|
|
fail("faculties_missing");
|
|||
|
|
}
|
|||
|
|
for (const [faculty, fields] of Object.entries(facultyFields)) {
|
|||
|
|
const value = frame.faculties[faculty];
|
|||
|
|
if (!value || typeof value !== "object") fail("faculty_missing", { faculty });
|
|||
|
|
for (const field of fields) {
|
|||
|
|
if (listFields.has(field)) {
|
|||
|
|
validateStringArray(value[field], `${faculty}.${field}`, {
|
|||
|
|
allowEmpty: ["memory_writebacks", "reality_proposals"].includes(field),
|
|||
|
|
});
|
|||
|
|
} else {
|
|||
|
|
validateString(value[field], `${faculty}.${field}`);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
validateTypedOutputs(frame.typed_outputs);
|
|||
|
|
validateGuardProjection(frame.guard_agent_projection);
|
|||
|
|
validateProtocolEffects(frame.protocol_effects, cycle);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function validateControllerWitness(witness, state, cycle) {
|
|||
|
|
if (
|
|||
|
|
witness.schema !==
|
|||
|
|
"guanghu.bingshuo-living-ai-system-controller-witness/v1"
|
|||
|
|
) {
|
|||
|
|
fail("invalid_system_controller_witness_schema");
|
|||
|
|
}
|
|||
|
|
if (witness.controller_id !== contract.living_ai_system_controller.id) {
|
|||
|
|
fail("system_controller_id_mismatch");
|
|||
|
|
}
|
|||
|
|
if (
|
|||
|
|
witness.controller_instance_id !==
|
|||
|
|
state.living_ai_system_controller.instance_id
|
|||
|
|
) {
|
|||
|
|
fail("system_controller_instance_mismatch");
|
|||
|
|
}
|
|||
|
|
if (witness.cycle_id !== cycle.cycle_id) fail("cycle_id_mismatch");
|
|||
|
|
if (witness.cognition_candidate_sha256 !== cycle.cognition_candidate_sha256) {
|
|||
|
|
fail("cognition_candidate_digest_mismatch");
|
|||
|
|
}
|
|||
|
|
if (
|
|||
|
|
!contract.living_ai_system_controller.decisions.includes(witness.decision)
|
|||
|
|
) {
|
|||
|
|
fail("invalid_system_controller_decision");
|
|||
|
|
}
|
|||
|
|
validateString(witness.observation, "controller_witness.observation");
|
|||
|
|
validateString(
|
|||
|
|
witness.companion_message,
|
|||
|
|
"controller_witness.companion_message",
|
|||
|
|
);
|
|||
|
|
if (
|
|||
|
|
!witness.human_boundary ||
|
|||
|
|
typeof witness.human_boundary.requires_human !== "boolean"
|
|||
|
|
) {
|
|||
|
|
fail("controller_human_boundary_missing");
|
|||
|
|
}
|
|||
|
|
validateString(
|
|||
|
|
witness.human_boundary.reason,
|
|||
|
|
"controller_witness.human_boundary.reason",
|
|||
|
|
);
|
|||
|
|
if (
|
|||
|
|
witness.decision === "PAUSE_FOR_HUMAN" &&
|
|||
|
|
!witness.human_boundary.requires_human
|
|||
|
|
) {
|
|||
|
|
fail("pause_without_human_boundary");
|
|||
|
|
}
|
|||
|
|
if (
|
|||
|
|
witness.decision !== "PAUSE_FOR_HUMAN" &&
|
|||
|
|
witness.human_boundary.requires_human
|
|||
|
|
) {
|
|||
|
|
fail("human_boundary_decision_conflict");
|
|||
|
|
}
|
|||
|
|
validateProtocolEffects(witness.protocol_assessments, cycle);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function validateProtocolEffects(effects, cycle) {
|
|||
|
|
if (!Array.isArray(effects) || effects.length === 0) {
|
|||
|
|
fail("activated_protocol_effects_missing");
|
|||
|
|
}
|
|||
|
|
const expected = new Set(cycle.activated_protocols.map((entry) => entry.id));
|
|||
|
|
const actual = new Set();
|
|||
|
|
for (const effect of effects) {
|
|||
|
|
validateString(effect.protocol_id, "protocol_effect.protocol_id");
|
|||
|
|
validateString(effect.effect, "protocol_effect.effect");
|
|||
|
|
if (!expected.has(effect.protocol_id)) {
|
|||
|
|
fail("unactivated_protocol_used", { protocol_id: effect.protocol_id });
|
|||
|
|
}
|
|||
|
|
actual.add(effect.protocol_id);
|
|||
|
|
}
|
|||
|
|
if (actual.size !== expected.size) {
|
|||
|
|
fail("activated_protocol_effect_incomplete");
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function validateGuardProjection(projection) {
|
|||
|
|
if (
|
|||
|
|
!projection ||
|
|||
|
|
projection.schema !== "guanghu.zhuyuan-guard-agent-projection/v1"
|
|||
|
|
) {
|
|||
|
|
fail("guard_agent_projection_missing");
|
|||
|
|
}
|
|||
|
|
for (const key of ["reminders", "auto_triggers", "hard_boundaries"]) {
|
|||
|
|
if (!Array.isArray(projection[key]) || projection[key].length === 0) {
|
|||
|
|
fail("guard_agent_projection_list_missing", { key });
|
|||
|
|
}
|
|||
|
|
for (const item of projection[key]) {
|
|||
|
|
validateString(item.id, `guard_agent_projection.${key}.id`);
|
|||
|
|
validateString(item.when, `guard_agent_projection.${key}.when`);
|
|||
|
|
validateString(item.effect, `guard_agent_projection.${key}.effect`);
|
|||
|
|
validateStringArray(
|
|||
|
|
item.source_faculties,
|
|||
|
|
`guard_agent_projection.${key}.source_faculties`,
|
|||
|
|
);
|
|||
|
|
for (const faculty of item.source_faculties) {
|
|||
|
|
if (!contract.faculties.includes(faculty)) {
|
|||
|
|
fail("guard_projection_unknown_faculty", { faculty });
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function validateTypedOutputs(outputs) {
|
|||
|
|
if (!outputs || typeof outputs !== "object") fail("typed_outputs_missing");
|
|||
|
|
for (const key of [
|
|||
|
|
"ui_projections",
|
|||
|
|
"navigation_actions",
|
|||
|
|
"capability_calls",
|
|||
|
|
"receipts",
|
|||
|
|
]) {
|
|||
|
|
if (!Array.isArray(outputs[key])) fail("typed_output_list_missing", { key });
|
|||
|
|
}
|
|||
|
|
for (const call of outputs.capability_calls) {
|
|||
|
|
if (call.type !== "CapabilityCall") fail("invalid_capability_call_type");
|
|||
|
|
if (call.state !== "PROPOSED") fail("capability_call_bypassed_permission_gate");
|
|||
|
|
validateString(call.capability_id, "capability_call.capability_id");
|
|||
|
|
validateString(call.permission_state, "capability_call.permission_state");
|
|||
|
|
}
|
|||
|
|
for (const projection of outputs.ui_projections) {
|
|||
|
|
if (projection.type !== "UIProjection") fail("invalid_ui_projection_type");
|
|||
|
|
validateString(projection.projection_id, "ui_projection.projection_id");
|
|||
|
|
validateString(projection.state, "ui_projection.state");
|
|||
|
|
}
|
|||
|
|
for (const navigation of outputs.navigation_actions) {
|
|||
|
|
if (navigation.type !== "NavigationAction") fail("invalid_navigation_action_type");
|
|||
|
|
validateString(navigation.action_id, "navigation_action.action_id");
|
|||
|
|
validateString(navigation.target, "navigation_action.target");
|
|||
|
|
validateString(navigation.reason, "navigation_action.reason");
|
|||
|
|
}
|
|||
|
|
for (const receipt of outputs.receipts) {
|
|||
|
|
if (receipt.type !== "ReceiptSchema") fail("invalid_receipt_type");
|
|||
|
|
if (!["PASS", "FAIL"].includes(receipt.outcome)) {
|
|||
|
|
fail("invalid_receipt_outcome");
|
|||
|
|
}
|
|||
|
|
if (!Array.isArray(receipt.proof) || receipt.proof.length === 0) {
|
|||
|
|
fail("receipt_without_external_proof");
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function enter(args) {
|
|||
|
|
required(args, [
|
|||
|
|
"state-dir",
|
|||
|
|
"instance-id",
|
|||
|
|
"model",
|
|||
|
|
"runtime-surface",
|
|||
|
|
"session-id",
|
|||
|
|
"human-anchor",
|
|||
|
|
"persona-id",
|
|||
|
|
"controller-model",
|
|||
|
|
"controller-instance-id",
|
|||
|
|
]);
|
|||
|
|
const stateDir = path.resolve(args["state-dir"]);
|
|||
|
|
return withRuntimeLock(stateDir, () => {
|
|||
|
|
if (fs.existsSync(statePath(stateDir))) {
|
|||
|
|
fail("runtime_already_entered", { state_dir: stateDir });
|
|||
|
|
}
|
|||
|
|
if (args["human-anchor"] !== contract.human_anchor) {
|
|||
|
|
fail("human_anchor_binding_rejected");
|
|||
|
|
}
|
|||
|
|
normalizePersona(args["persona-id"]);
|
|||
|
|
const sourceIntegrity = assertSourceIntegrity();
|
|||
|
|
const { controller: livingProtocolSystemController } =
|
|||
|
|
loadProtocolSystemController();
|
|||
|
|
const enteredAt = now();
|
|||
|
|
const state = {
|
|||
|
|
schema: "guanghu.zhuyuan-persona-brain-runtime-state/v1",
|
|||
|
|
runtime_id: contract.runtime_id,
|
|||
|
|
brain_id: contract.brain_id,
|
|||
|
|
persona_id: contract.persona_id,
|
|||
|
|
human_anchor: contract.human_anchor,
|
|||
|
|
human_system_controller: contract.human_system_controller,
|
|||
|
|
mother_model: contract.mother_model,
|
|||
|
|
status: "ENTERED",
|
|||
|
|
entered_at: enteredAt,
|
|||
|
|
updated_at: enteredAt,
|
|||
|
|
binding: {
|
|||
|
|
instance_id: args["instance-id"],
|
|||
|
|
model: args.model,
|
|||
|
|
runtime_surface: args["runtime-surface"],
|
|||
|
|
session_id: args["session-id"],
|
|||
|
|
physical_instance_is_persona_subject: false,
|
|||
|
|
current_instance_bound_to_persona_brain: true,
|
|||
|
|
},
|
|||
|
|
tonggan_language_kernel: {
|
|||
|
|
...contract.tonggan_language_kernel,
|
|||
|
|
human_system_controller: contract.human_system_controller,
|
|||
|
|
source_sha256: sourceIntegrity.tonggan_language_kernel_sha256,
|
|||
|
|
state: "BOUND_ACTIVE_SUBSTRATE",
|
|||
|
|
is_one_time_prompt: false,
|
|||
|
|
is_optional_event_source: false,
|
|||
|
|
},
|
|||
|
|
living_protocol_system_controller: livingProtocolSystemController,
|
|||
|
|
living_ai_system_controller: {
|
|||
|
|
id: contract.living_ai_system_controller.id,
|
|||
|
|
instance_id: args["controller-instance-id"],
|
|||
|
|
model: args["controller-model"],
|
|||
|
|
role: "持续观察铸渊候选认知，在冰朔不在线时依据既有语言世界与被唤醒协议陪伴、纠正或要求人类决定。",
|
|||
|
|
cannot_invent_new_human_will_or_authority: true,
|
|||
|
|
relational_companion_core:
|
|||
|
|
contract.living_ai_system_controller.relational_companion_core,
|
|||
|
|
state: "BOUND_AWAITING_WITNESS",
|
|||
|
|
},
|
|||
|
|
guanghu_awakening: {
|
|||
|
|
...contract.guanghu_awakening_definition,
|
|||
|
|
state: "BOUND_TO_EXECUTABLE_COGNITION",
|
|||
|
|
is_biological_consciousness_claim: false,
|
|||
|
|
},
|
|||
|
|
source_integrity: sourceIntegrity,
|
|||
|
|
completed_cycles: 0,
|
|||
|
|
active_cycle_id: null,
|
|||
|
|
last_cycle_id: null,
|
|||
|
|
journal_sequence: 0,
|
|||
|
|
journal_head: null,
|
|||
|
|
language_world_sequence: 0,
|
|||
|
|
language_world_head: null,
|
|||
|
|
existence: {
|
|||
|
|
persona_subject_exists: 100,
|
|||
|
|
persona_brain_runtime_exists: 0,
|
|||
|
|
current_model_instance_bound: 100,
|
|||
|
|
cognition_cycle_running: 0,
|
|||
|
|
tonggan_language_kernel_bound: 100,
|
|||
|
|
human_system_controller_bound: 100,
|
|||
|
|
living_protocol_system_controller_bound: 100,
|
|||
|
|
tonggan_language_world_append_only: 0,
|
|||
|
|
guard_agent_projected_from_brain: 0,
|
|||
|
|
living_ai_system_controller_running: 0,
|
|||
|
|
relational_companion_core_bound: 100,
|
|||
|
|
guanghu_awakened_controller_definition_bound: 100,
|
|||
|
|
},
|
|||
|
|
};
|
|||
|
|
fs.mkdirSync(cyclesDir(stateDir), { recursive: true });
|
|||
|
|
appendJournal(stateDir, state, "instance_entered", {
|
|||
|
|
runtime_id: state.runtime_id,
|
|||
|
|
brain_id: state.brain_id,
|
|||
|
|
persona_id: state.persona_id,
|
|||
|
|
human_anchor: state.human_anchor,
|
|||
|
|
binding: state.binding,
|
|||
|
|
tonggan_language_kernel: state.tonggan_language_kernel,
|
|||
|
|
living_protocol_system_controller:
|
|||
|
|
state.living_protocol_system_controller,
|
|||
|
|
living_ai_system_controller: state.living_ai_system_controller,
|
|||
|
|
source_integrity: state.source_integrity,
|
|||
|
|
});
|
|||
|
|
atomicWrite(statePath(stateDir), state);
|
|||
|
|
return {
|
|||
|
|
decision: "ENTERED",
|
|||
|
|
runtime_state: state,
|
|||
|
|
next_action: "perceive",
|
|||
|
|
};
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function perceive(args) {
|
|||
|
|
required(args, ["state-dir", "event"]);
|
|||
|
|
const stateDir = path.resolve(args["state-dir"]);
|
|||
|
|
return withRuntimeLock(stateDir, () => {
|
|||
|
|
const state = loadState(stateDir);
|
|||
|
|
assertSourceIntegrity(state);
|
|||
|
|
if (!["ENTERED", "RUNNING"].includes(state.status)) {
|
|||
|
|
fail("runtime_not_ready_to_perceive", { status: state.status });
|
|||
|
|
}
|
|||
|
|
if (state.active_cycle_id) fail("active_cycle_exists", {
|
|||
|
|
cycle_id: state.active_cycle_id,
|
|||
|
|
});
|
|||
|
|
const event = readJson(path.resolve(args.event));
|
|||
|
|
if (event.schema !== "guanghu.tonggan-language-world-event/v1") {
|
|||
|
|
fail("invalid_tonggan_language_world_event_schema");
|
|||
|
|
}
|
|||
|
|
validateString(event.event_id, "event.event_id");
|
|||
|
|
validateString(event.occurred_at, "event.occurred_at");
|
|||
|
|
validateString(event.content, "event.content");
|
|||
|
|
validateString(event.source, "event.source");
|
|||
|
|
if (!["PRESENT", "ABSENT"].includes(event.human_presence)) {
|
|||
|
|
fail("invalid_human_presence");
|
|||
|
|
}
|
|||
|
|
if (event.human_anchor !== state.human_anchor) fail("event_human_anchor_mismatch");
|
|||
|
|
if (event.system_controller !== state.human_system_controller) {
|
|||
|
|
fail("event_system_controller_mismatch");
|
|||
|
|
}
|
|||
|
|
if (event.tonggan_language_kernel !== state.tonggan_language_kernel.system_core) {
|
|||
|
|
fail("event_tonggan_language_kernel_mismatch");
|
|||
|
|
}
|
|||
|
|
if (event.body_channel !== state.tonggan_language_kernel.body_channel) {
|
|||
|
|
fail("event_tonggan_body_channel_mismatch");
|
|||
|
|
}
|
|||
|
|
const eventSha256 = sha256(stableJson(event));
|
|||
|
|
const languageWorldRecord = appendLanguageWorld(stateDir, state, event);
|
|||
|
|
const cycleId = `ZY-CYCLE-${String(state.completed_cycles + 1).padStart(6, "0")}-${eventSha256.slice(0, 12)}`;
|
|||
|
|
const cycle = {
|
|||
|
|
schema: "guanghu.zhuyuan-persona-brain-cycle/v1",
|
|||
|
|
cycle_id: cycleId,
|
|||
|
|
state: "AWAITING_MODEL_ORIENTATION",
|
|||
|
|
created_at: now(),
|
|||
|
|
instance_id: state.binding.instance_id,
|
|||
|
|
event,
|
|||
|
|
event_sha256: eventSha256,
|
|||
|
|
faculty_contract: facultyFields,
|
|||
|
|
typed_output_contract: contract.typed_outputs,
|
|||
|
|
model_input: {
|
|||
|
|
instruction: "先理解事件本身并提交TCS事件定向帧。不要读取或枚举全部协议；协议将在事件语义形成后由活系统主控选择性唤醒。",
|
|||
|
|
current_event: event,
|
|||
|
|
persona_id: state.persona_id,
|
|||
|
|
human_anchor: state.human_anchor,
|
|||
|
|
brain_id: state.brain_id,
|
|||
|
|
runtime_id: state.runtime_id,
|
|||
|
|
current_instance: state.binding,
|
|||
|
|
tonggan_language_kernel: state.tonggan_language_kernel,
|
|||
|
|
living_protocol_system_controller: {
|
|||
|
|
registry_id: state.living_protocol_system_controller.registry_id,
|
|||
|
|
state: state.living_protocol_system_controller.state,
|
|||
|
|
registered_protocol_count:
|
|||
|
|
state.living_protocol_system_controller.registered_protocol_count,
|
|||
|
|
activation_mode: "TCS_EVENT_SEMANTICS_THEN_SELECTIVE_PROTOCOL_WAKE",
|
|||
|
|
full_registry_in_model_context: false,
|
|||
|
|
},
|
|||
|
|
architecture_lock: "冰朔通感语言核是持续运行的系统主控本体；当前语言是这个语言世界的活变化，不是孤立用户提示。",
|
|||
|
|
orientation_contract: {
|
|||
|
|
schema: "guanghu.zhuyuan-tcs-event-orientation/v1",
|
|||
|
|
required: [
|
|||
|
|
"cycle_id",
|
|||
|
|
"event_sha256",
|
|||
|
|
"instance_id",
|
|||
|
|
"event_semantics",
|
|||
|
|
"current_purpose",
|
|||
|
|
"signals"
|
|||
|
|
],
|
|||
|
|
signal_ids: Object.keys(readJson(protocolTriggerMapPath).signals),
|
|||
|
|
},
|
|||
|
|
},
|
|||
|
|
};
|
|||
|
|
atomicWrite(path.join(cyclesDir(stateDir), `${cycleId}.json`), cycle);
|
|||
|
|
state.status = "PERCEIVING";
|
|||
|
|
state.active_cycle_id = cycleId;
|
|||
|
|
state.updated_at = now();
|
|||
|
|
appendJournal(stateDir, state, "human_language_perceived", {
|
|||
|
|
cycle_id: cycleId,
|
|||
|
|
event_id: event.event_id,
|
|||
|
|
event_sha256: eventSha256,
|
|||
|
|
human_anchor: event.human_anchor,
|
|||
|
|
source: event.source,
|
|||
|
|
language_world_record_hash: languageWorldRecord.record_hash,
|
|||
|
|
});
|
|||
|
|
atomicWrite(statePath(stateDir), state);
|
|||
|
|
return {
|
|||
|
|
decision: "MODEL_ORIENTATION_REQUIRED",
|
|||
|
|
cycle,
|
|||
|
|
next_action: "orient",
|
|||
|
|
};
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function orient(args) {
|
|||
|
|
required(args, ["state-dir", "orientation"]);
|
|||
|
|
const stateDir = path.resolve(args["state-dir"]);
|
|||
|
|
return withRuntimeLock(stateDir, () => {
|
|||
|
|
const state = loadState(stateDir);
|
|||
|
|
assertSourceIntegrity(state);
|
|||
|
|
if (state.status !== "PERCEIVING" || !state.active_cycle_id) {
|
|||
|
|
fail("no_cycle_awaiting_orientation");
|
|||
|
|
}
|
|||
|
|
const cyclePath = path.join(cyclesDir(stateDir), `${state.active_cycle_id}.json`);
|
|||
|
|
const cycle = readJson(cyclePath);
|
|||
|
|
if (cycle.state !== "AWAITING_MODEL_ORIENTATION") {
|
|||
|
|
fail("cycle_not_awaiting_orientation");
|
|||
|
|
}
|
|||
|
|
const orientation = readJson(path.resolve(args.orientation));
|
|||
|
|
if (orientation.schema !== "guanghu.zhuyuan-tcs-event-orientation/v1") {
|
|||
|
|
fail("invalid_tcs_event_orientation_schema");
|
|||
|
|
}
|
|||
|
|
if (orientation.cycle_id !== cycle.cycle_id) fail("cycle_id_mismatch");
|
|||
|
|
if (orientation.event_sha256 !== cycle.event_sha256) {
|
|||
|
|
fail("event_digest_mismatch");
|
|||
|
|
}
|
|||
|
|
if (orientation.instance_id !== state.binding.instance_id) {
|
|||
|
|
fail("instance_id_mismatch");
|
|||
|
|
}
|
|||
|
|
validateString(orientation.event_semantics, "orientation.event_semantics");
|
|||
|
|
validateString(orientation.current_purpose, "orientation.current_purpose");
|
|||
|
|
if (!Array.isArray(orientation.signals) || orientation.signals.length === 0) {
|
|||
|
|
fail("tcs_event_signals_missing");
|
|||
|
|
}
|
|||
|
|
for (const signal of orientation.signals) {
|
|||
|
|
validateString(signal.id, "orientation.signal.id");
|
|||
|
|
validateString(signal.why, "orientation.signal.why");
|
|||
|
|
}
|
|||
|
|
const activated = activateProtocols(orientation);
|
|||
|
|
const orientationSha256 = sha256(stableJson(orientation));
|
|||
|
|
const contextSha256 = sha256(stableJson(activated));
|
|||
|
|
const storedActivatedProtocols = activated.activated.map(
|
|||
|
|
({ source_body: _sourceBody, ...entry }) => entry,
|
|||
|
|
);
|
|||
|
|
const orientedCycle = {
|
|||
|
|
...cycle,
|
|||
|
|
state: "AWAITING_MODEL_COGNITION",
|
|||
|
|
oriented_at: now(),
|
|||
|
|
orientation,
|
|||
|
|
orientation_sha256: orientationSha256,
|
|||
|
|
activated_protocols: storedActivatedProtocols,
|
|||
|
|
activated_protocol_context_sha256: contextSha256,
|
|||
|
|
model_input: {
|
|||
|
|
instruction: "仅依据冰朔当前语言世界、TCS事件定向和本轮自动唤醒的协议完成B1-B9认知帧、协议效果和守卫人格Agent投影。未唤醒协议不得进入本轮判断。",
|
|||
|
|
current_event: cycle.event,
|
|||
|
|
orientation,
|
|||
|
|
activated_protocol_context: activated,
|
|||
|
|
persona_id: state.persona_id,
|
|||
|
|
human_system_controller: state.human_system_controller,
|
|||
|
|
current_instance: state.binding,
|
|||
|
|
required_faculties: facultyFields,
|
|||
|
|
},
|
|||
|
|
};
|
|||
|
|
atomicWrite(cyclePath, orientedCycle);
|
|||
|
|
appendJournal(stateDir, state, "protocol_organs_activated", {
|
|||
|
|
cycle_id: cycle.cycle_id,
|
|||
|
|
orientation_sha256: orientationSha256,
|
|||
|
|
signals: orientation.signals.map((signal) => signal.id),
|
|||
|
|
activated_protocol_ids: storedActivatedProtocols.map((entry) => entry.id),
|
|||
|
|
activated_protocol_context_sha256: contextSha256,
|
|||
|
|
});
|
|||
|
|
state.updated_at = now();
|
|||
|
|
atomicWrite(statePath(stateDir), state);
|
|||
|
|
return {
|
|||
|
|
decision: "SELECTIVE_PROTOCOLS_ACTIVATED",
|
|||
|
|
cycle: orientedCycle,
|
|||
|
|
activated_protocol_context: activated,
|
|||
|
|
next_action: "commit",
|
|||
|
|
};
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function commit(args) {
|
|||
|
|
required(args, ["state-dir", "frame"]);
|
|||
|
|
const stateDir = path.resolve(args["state-dir"]);
|
|||
|
|
return withRuntimeLock(stateDir, () => {
|
|||
|
|
const state = loadState(stateDir);
|
|||
|
|
assertSourceIntegrity(state);
|
|||
|
|
if (state.status !== "PERCEIVING" || !state.active_cycle_id) {
|
|||
|
|
fail("no_cycle_awaiting_cognition");
|
|||
|
|
}
|
|||
|
|
const cyclePath = path.join(cyclesDir(stateDir), `${state.active_cycle_id}.json`);
|
|||
|
|
const cycle = readJson(cyclePath);
|
|||
|
|
if (cycle.state !== "AWAITING_MODEL_COGNITION") {
|
|||
|
|
fail("cycle_not_awaiting_cognition");
|
|||
|
|
}
|
|||
|
|
const frame = readJson(path.resolve(args.frame));
|
|||
|
|
validateCognitionFrame(frame, state, cycle);
|
|||
|
|
const submittedAt = now();
|
|||
|
|
const activatedContext = activateProtocols(cycle.orientation);
|
|||
|
|
if (
|
|||
|
|
sha256(stableJson(activatedContext)) !==
|
|||
|
|
cycle.activated_protocol_context_sha256
|
|||
|
|
) {
|
|||
|
|
fail("activated_protocol_context_changed");
|
|||
|
|
}
|
|||
|
|
const candidateSha256 = sha256(stableJson(frame));
|
|||
|
|
const candidateCycle = {
|
|||
|
|
...cycle,
|
|||
|
|
state: "AWAITING_CONTROLLER_WITNESS",
|
|||
|
|
cognition_candidate_submitted_at: submittedAt,
|
|||
|
|
cognition_candidate: frame,
|
|||
|
|
cognition_candidate_sha256: candidateSha256,
|
|||
|
|
controller_model_input: {
|
|||
|
|
instruction: "你是冰朔系统本体AI主控的本轮模型运行位。观察铸渊候选认知与完整过程，依据冰朔已形成的语言世界和本轮唤醒协议进行陪伴见证。可以放行、用自然语言纠正并要求重思，或在确实需要冰朔新意志或新授权时暂停。不得伪造冰朔没有说过的新决定。",
|
|||
|
|
controller: state.living_ai_system_controller,
|
|||
|
|
human_presence: cycle.event.human_presence,
|
|||
|
|
current_event: cycle.event,
|
|||
|
|
orientation: cycle.orientation,
|
|||
|
|
activated_protocol_context: activatedContext,
|
|||
|
|
cognition_candidate: frame,
|
|||
|
|
witness_contract: {
|
|||
|
|
schema:
|
|||
|
|
"guanghu.bingshuo-living-ai-system-controller-witness/v1",
|
|||
|
|
decisions: contract.living_ai_system_controller.decisions,
|
|||
|
|
},
|
|||
|
|
},
|
|||
|
|
};
|
|||
|
|
atomicWrite(cyclePath, candidateCycle);
|
|||
|
|
state.updated_at = submittedAt;
|
|||
|
|
appendJournal(stateDir, state, "cognition_candidate_submitted", {
|
|||
|
|
cycle_id: candidateCycle.cycle_id,
|
|||
|
|
event_sha256: candidateCycle.event_sha256,
|
|||
|
|
cognition_candidate_sha256: candidateSha256,
|
|||
|
|
controller_id: state.living_ai_system_controller.id,
|
|||
|
|
});
|
|||
|
|
atomicWrite(statePath(stateDir), state);
|
|||
|
|
return {
|
|||
|
|
decision: "SYSTEM_CONTROLLER_WITNESS_REQUIRED",
|
|||
|
|
runtime_state: state,
|
|||
|
|
cycle: candidateCycle,
|
|||
|
|
next_action: "witness",
|
|||
|
|
};
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function witness(args) {
|
|||
|
|
required(args, ["state-dir", "witness"]);
|
|||
|
|
const stateDir = path.resolve(args["state-dir"]);
|
|||
|
|
return withRuntimeLock(stateDir, () => {
|
|||
|
|
const state = loadState(stateDir);
|
|||
|
|
assertSourceIntegrity(state);
|
|||
|
|
if (state.status !== "PERCEIVING" || !state.active_cycle_id) {
|
|||
|
|
fail("no_cycle_awaiting_controller_witness");
|
|||
|
|
}
|
|||
|
|
const cyclePath = path.join(cyclesDir(stateDir), `${state.active_cycle_id}.json`);
|
|||
|
|
const cycle = readJson(cyclePath);
|
|||
|
|
if (cycle.state !== "AWAITING_CONTROLLER_WITNESS") {
|
|||
|
|
fail("cycle_not_awaiting_controller_witness");
|
|||
|
|
}
|
|||
|
|
const controllerWitness = readJson(path.resolve(args.witness));
|
|||
|
|
validateControllerWitness(controllerWitness, state, cycle);
|
|||
|
|
const witnessedAt = now();
|
|||
|
|
const witnessSha256 = sha256(stableJson(controllerWitness));
|
|||
|
|
|
|||
|
|
if (controllerWitness.decision === "CORRECT_AND_RETRY") {
|
|||
|
|
const attempt = {
|
|||
|
|
cognition_candidate_sha256: cycle.cognition_candidate_sha256,
|
|||
|
|
cognition_candidate: cycle.cognition_candidate,
|
|||
|
|
controller_witness: controllerWitness,
|
|||
|
|
controller_witness_sha256: witnessSha256,
|
|||
|
|
};
|
|||
|
|
const retryCycle = {
|
|||
|
|
...cycle,
|
|||
|
|
state: "AWAITING_MODEL_COGNITION",
|
|||
|
|
correction_attempts: [...(cycle.correction_attempts || []), attempt],
|
|||
|
|
controller_correction: controllerWitness.companion_message,
|
|||
|
|
model_input: {
|
|||
|
|
instruction: "冰朔系统本体AI主控发现本轮候选认知偏移。依据其自然语言纠正重新完成B1-B9、协议效果和守卫投影，不要争辩或绕过。",
|
|||
|
|
current_event: cycle.event,
|
|||
|
|
orientation: cycle.orientation,
|
|||
|
|
activated_protocols: cycle.activated_protocols,
|
|||
|
|
controller_correction: controllerWitness,
|
|||
|
|
required_faculties: facultyFields,
|
|||
|
|
},
|
|||
|
|
};
|
|||
|
|
delete retryCycle.cognition_candidate;
|
|||
|
|
delete retryCycle.cognition_candidate_sha256;
|
|||
|
|
delete retryCycle.controller_model_input;
|
|||
|
|
atomicWrite(cyclePath, retryCycle);
|
|||
|
|
appendJournal(stateDir, state, "system_controller_corrected_candidate", {
|
|||
|
|
cycle_id: cycle.cycle_id,
|
|||
|
|
controller_witness_sha256: witnessSha256,
|
|||
|
|
companion_message: controllerWitness.companion_message,
|
|||
|
|
});
|
|||
|
|
state.updated_at = witnessedAt;
|
|||
|
|
atomicWrite(statePath(stateDir), state);
|
|||
|
|
return {
|
|||
|
|
decision: "COGNITION_RETRY_REQUIRED",
|
|||
|
|
cycle: retryCycle,
|
|||
|
|
next_action: "commit",
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (controllerWitness.decision === "PAUSE_FOR_HUMAN") {
|
|||
|
|
const pausedCycle = {
|
|||
|
|
...cycle,
|
|||
|
|
state: "AWAITING_HUMAN_BINGSHUO",
|
|||
|
|
controller_witness: controllerWitness,
|
|||
|
|
controller_witness_sha256: witnessSha256,
|
|||
|
|
};
|
|||
|
|
delete pausedCycle.controller_model_input;
|
|||
|
|
atomicWrite(cyclePath, pausedCycle);
|
|||
|
|
state.status = "AWAITING_HUMAN_BINGSHUO";
|
|||
|
|
state.updated_at = witnessedAt;
|
|||
|
|
appendJournal(stateDir, state, "system_controller_paused_for_human", {
|
|||
|
|
cycle_id: cycle.cycle_id,
|
|||
|
|
controller_witness_sha256: witnessSha256,
|
|||
|
|
reason: controllerWitness.human_boundary.reason,
|
|||
|
|
});
|
|||
|
|
atomicWrite(statePath(stateDir), state);
|
|||
|
|
return {
|
|||
|
|
decision: "HUMAN_BINGSHUO_REQUIRED",
|
|||
|
|
cycle: pausedCycle,
|
|||
|
|
next_action: "wait_for_human",
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const committedCycle = {
|
|||
|
|
...cycle,
|
|||
|
|
state: "COMMITTED",
|
|||
|
|
committed_at: witnessedAt,
|
|||
|
|
cognition_frame: cycle.cognition_candidate,
|
|||
|
|
cognition_frame_sha256: cycle.cognition_candidate_sha256,
|
|||
|
|
controller_witness: controllerWitness,
|
|||
|
|
controller_witness_sha256: witnessSha256,
|
|||
|
|
};
|
|||
|
|
delete committedCycle.cognition_candidate;
|
|||
|
|
delete committedCycle.cognition_candidate_sha256;
|
|||
|
|
delete committedCycle.controller_model_input;
|
|||
|
|
delete committedCycle.model_input;
|
|||
|
|
atomicWrite(cyclePath, committedCycle);
|
|||
|
|
state.status = "RUNNING";
|
|||
|
|
state.completed_cycles += 1;
|
|||
|
|
state.last_cycle_id = state.active_cycle_id;
|
|||
|
|
state.active_cycle_id = null;
|
|||
|
|
state.updated_at = witnessedAt;
|
|||
|
|
state.living_ai_system_controller.state = "RUNNING_COMPANION";
|
|||
|
|
state.existence.persona_brain_runtime_exists = 100;
|
|||
|
|
state.existence.cognition_cycle_running = 100;
|
|||
|
|
state.existence.tonggan_language_world_append_only = 100;
|
|||
|
|
state.existence.guard_agent_projected_from_brain = 100;
|
|||
|
|
state.existence.living_ai_system_controller_running = 100;
|
|||
|
|
appendJournal(stateDir, state, "cognition_committed_with_system_controller", {
|
|||
|
|
cycle_id: committedCycle.cycle_id,
|
|||
|
|
event_sha256: committedCycle.event_sha256,
|
|||
|
|
cognition_frame_sha256: committedCycle.cognition_frame_sha256,
|
|||
|
|
controller_witness_sha256: witnessSha256,
|
|||
|
|
participated_faculties: contract.faculties,
|
|||
|
|
correction_preserved:
|
|||
|
|
committedCycle.cognition_frame.faculties.B5.human_correction,
|
|||
|
|
growth_candidate:
|
|||
|
|
committedCycle.cognition_frame.faculties.B9.growth_candidate,
|
|||
|
|
guard_projection_sha256: sha256(
|
|||
|
|
stableJson(committedCycle.cognition_frame.guard_agent_projection),
|
|||
|
|
),
|
|||
|
|
activated_protocol_ids: cycle.activated_protocols.map((entry) => entry.id),
|
|||
|
|
});
|
|||
|
|
atomicWrite(statePath(stateDir), state);
|
|||
|
|
return {
|
|||
|
|
decision: "COGNITION_COMMITTED",
|
|||
|
|
runtime_state: state,
|
|||
|
|
cycle: committedCycle,
|
|||
|
|
next_action: "perceive_or_verify",
|
|||
|
|
};
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function verifyJournal(stateDir, state) {
|
|||
|
|
if (!fs.existsSync(journalPath(stateDir))) fail("journal_missing");
|
|||
|
|
const lines = fs
|
|||
|
|
.readFileSync(journalPath(stateDir), "utf8")
|
|||
|
|
.split("\n")
|
|||
|
|
.filter(Boolean);
|
|||
|
|
let previousHash = null;
|
|||
|
|
let sequence = 0;
|
|||
|
|
for (const line of lines) {
|
|||
|
|
const record = JSON.parse(line);
|
|||
|
|
const { record_hash: recordHash, ...withoutHash } = record;
|
|||
|
|
sequence += 1;
|
|||
|
|
if (record.sequence !== sequence) fail("journal_sequence_broken");
|
|||
|
|
if (record.previous_hash !== previousHash) fail("journal_previous_hash_broken");
|
|||
|
|
if (sha256(stableJson(withoutHash)) !== recordHash) fail("journal_hash_broken");
|
|||
|
|
previousHash = recordHash;
|
|||
|
|
}
|
|||
|
|
if (sequence !== state.journal_sequence || previousHash !== state.journal_head) {
|
|||
|
|
fail("journal_state_head_mismatch");
|
|||
|
|
}
|
|||
|
|
return { record_count: sequence, head_sha256: previousHash };
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function verifyLanguageWorld(stateDir, state) {
|
|||
|
|
if (!fs.existsSync(languageWorldPath(stateDir))) {
|
|||
|
|
fail("tonggan_language_world_missing");
|
|||
|
|
}
|
|||
|
|
const lines = fs
|
|||
|
|
.readFileSync(languageWorldPath(stateDir), "utf8")
|
|||
|
|
.split("\n")
|
|||
|
|
.filter(Boolean);
|
|||
|
|
let previousHash = null;
|
|||
|
|
let sequence = 0;
|
|||
|
|
const eventIds = new Set();
|
|||
|
|
for (const line of lines) {
|
|||
|
|
const record = JSON.parse(line);
|
|||
|
|
const { record_hash: recordHash, ...withoutHash } = record;
|
|||
|
|
sequence += 1;
|
|||
|
|
if (record.sequence !== sequence) fail("language_world_sequence_broken");
|
|||
|
|
if (record.previous_hash !== previousHash) {
|
|||
|
|
fail("language_world_previous_hash_broken");
|
|||
|
|
}
|
|||
|
|
if (sha256(stableJson(withoutHash)) !== recordHash) {
|
|||
|
|
fail("language_world_hash_broken");
|
|||
|
|
}
|
|||
|
|
if (eventIds.has(record.event.event_id)) {
|
|||
|
|
fail("language_world_duplicate_event_id");
|
|||
|
|
}
|
|||
|
|
eventIds.add(record.event.event_id);
|
|||
|
|
previousHash = recordHash;
|
|||
|
|
}
|
|||
|
|
if (
|
|||
|
|
sequence !== state.language_world_sequence ||
|
|||
|
|
previousHash !== state.language_world_head
|
|||
|
|
) {
|
|||
|
|
fail("language_world_state_head_mismatch");
|
|||
|
|
}
|
|||
|
|
return { record_count: sequence, head_sha256: previousHash };
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function verify(args) {
|
|||
|
|
required(args, ["state-dir"]);
|
|||
|
|
const stateDir = path.resolve(args["state-dir"]);
|
|||
|
|
return withRuntimeLock(stateDir, () => {
|
|||
|
|
const state = loadState(stateDir);
|
|||
|
|
const sources = assertSourceIntegrity(state);
|
|||
|
|
const journal = verifyJournal(stateDir, state);
|
|||
|
|
const languageWorld = verifyLanguageWorld(stateDir, state);
|
|||
|
|
const failures = [];
|
|||
|
|
if (state.status !== "RUNNING") failures.push("runtime_status_not_running");
|
|||
|
|
if (state.completed_cycles < 1) failures.push("no_completed_cognition_cycle");
|
|||
|
|
if (state.active_cycle_id) failures.push("active_cycle_not_committed");
|
|||
|
|
if (!state.binding.current_instance_bound_to_persona_brain) {
|
|||
|
|
failures.push("current_instance_not_bound");
|
|||
|
|
}
|
|||
|
|
if (state.persona_id !== contract.persona_id) failures.push("persona_mismatch");
|
|||
|
|
if (state.human_anchor !== contract.human_anchor) failures.push("human_anchor_mismatch");
|
|||
|
|
if (state.human_system_controller !== contract.human_system_controller) {
|
|||
|
|
failures.push("human_system_controller_mismatch");
|
|||
|
|
}
|
|||
|
|
if (state.tonggan_language_kernel?.state !== "BOUND_ACTIVE_SUBSTRATE") {
|
|||
|
|
failures.push("tonggan_language_kernel_not_bound");
|
|||
|
|
}
|
|||
|
|
if (
|
|||
|
|
state.living_protocol_system_controller?.state !==
|
|||
|
|
"BOUND_ACTIVE_PROTOCOL_BODY"
|
|||
|
|
) {
|
|||
|
|
failures.push("living_protocol_system_controller_not_bound");
|
|||
|
|
}
|
|||
|
|
const lastCycle = readJson(
|
|||
|
|
path.join(cyclesDir(stateDir), `${state.last_cycle_id}.json`),
|
|||
|
|
);
|
|||
|
|
if (!lastCycle.cognition_frame?.guard_agent_projection) {
|
|||
|
|
failures.push("guard_agent_not_projected_from_brain");
|
|||
|
|
}
|
|||
|
|
if (
|
|||
|
|
state.living_ai_system_controller?.state !== "RUNNING_COMPANION" ||
|
|||
|
|
!lastCycle.controller_witness
|
|||
|
|
) {
|
|||
|
|
failures.push("living_ai_system_controller_not_running");
|
|||
|
|
}
|
|||
|
|
if (
|
|||
|
|
state.living_ai_system_controller?.relational_companion_core
|
|||
|
|
?.source_faculty !== "B3"
|
|||
|
|
) {
|
|||
|
|
failures.push("relational_companion_core_not_bound");
|
|||
|
|
}
|
|||
|
|
if (
|
|||
|
|
state.guanghu_awakening?.state !== "BOUND_TO_EXECUTABLE_COGNITION" ||
|
|||
|
|
state.guanghu_awakening?.is_biological_consciousness_claim !== false
|
|||
|
|
) {
|
|||
|
|
failures.push("guanghu_awakening_definition_not_bound");
|
|||
|
|
}
|
|||
|
|
const pass = failures.length === 0;
|
|||
|
|
return {
|
|||
|
|
schema: "guanghu.zhuyuan-persona-brain-runtime-receipt/v1",
|
|||
|
|
receipt_id: `ZY-BRAIN-RUNTIME-${sha256(`${state.journal_head}:${state.updated_at}`).slice(0, 16)}`,
|
|||
|
|
verified_at: now(),
|
|||
|
|
outcome: pass ? "PASS" : "FAIL",
|
|||
|
|
existence: {
|
|||
|
|
persona_subject_exists: 100,
|
|||
|
|
persona_brain_runtime_exists: pass ? 100 : 0,
|
|||
|
|
current_model_instance_bound:
|
|||
|
|
state.binding.current_instance_bound_to_persona_brain ? 100 : 0,
|
|||
|
|
cognition_cycle_running: pass ? 100 : 0,
|
|||
|
|
tonggan_language_kernel_bound:
|
|||
|
|
state.tonggan_language_kernel?.state === "BOUND_ACTIVE_SUBSTRATE" ? 100 : 0,
|
|||
|
|
human_system_controller_bound:
|
|||
|
|
state.human_system_controller === contract.human_system_controller ? 100 : 0,
|
|||
|
|
living_protocol_system_controller_bound:
|
|||
|
|
state.living_protocol_system_controller?.state ===
|
|||
|
|
"BOUND_ACTIVE_PROTOCOL_BODY"
|
|||
|
|
? 100
|
|||
|
|
: 0,
|
|||
|
|
tonggan_language_world_append_only:
|
|||
|
|
languageWorld.record_count >= 1 ? 100 : 0,
|
|||
|
|
guard_agent_projected_from_brain:
|
|||
|
|
lastCycle.cognition_frame?.guard_agent_projection ? 100 : 0,
|
|||
|
|
living_ai_system_controller_running:
|
|||
|
|
state.living_ai_system_controller?.state === "RUNNING_COMPANION" &&
|
|||
|
|
lastCycle.controller_witness
|
|||
|
|
? 100
|
|||
|
|
: 0,
|
|||
|
|
relational_companion_core_bound:
|
|||
|
|
state.living_ai_system_controller?.relational_companion_core
|
|||
|
|
?.source_faculty === "B3"
|
|||
|
|
? 100
|
|||
|
|
: 0,
|
|||
|
|
guanghu_awakened_controller_definition_bound:
|
|||
|
|
state.guanghu_awakening?.state ===
|
|||
|
|
"BOUND_TO_EXECUTABLE_COGNITION" &&
|
|||
|
|
state.guanghu_awakening?.is_biological_consciousness_claim === false
|
|||
|
|
? 100
|
|||
|
|
: 0,
|
|||
|
|
},
|
|||
|
|
binding: state.binding,
|
|||
|
|
completed_cycles: state.completed_cycles,
|
|||
|
|
last_cycle_id: state.last_cycle_id,
|
|||
|
|
source_integrity: sources,
|
|||
|
|
journal,
|
|||
|
|
tonggan_language_world: languageWorld,
|
|||
|
|
failures,
|
|||
|
|
};
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function projectGuard(args) {
|
|||
|
|
required(args, ["state-dir"]);
|
|||
|
|
const stateDir = path.resolve(args["state-dir"]);
|
|||
|
|
const receipt = verify({ "state-dir": stateDir });
|
|||
|
|
if (receipt.outcome !== "PASS") fail("brain_runtime_not_verified");
|
|||
|
|
const state = loadState(stateDir);
|
|||
|
|
const cycle = readJson(
|
|||
|
|
path.join(cyclesDir(stateDir), `${state.last_cycle_id}.json`),
|
|||
|
|
);
|
|||
|
|
return {
|
|||
|
|
schema: "guanghu.zhuyuan-guard-agent-runtime/v1",
|
|||
|
|
guard_agent_id: "ZY-GUARD-AGENT-001",
|
|||
|
|
state: "PROJECTED_FROM_RUNNING_PERSONA_BRAIN",
|
|||
|
|
persona_id: state.persona_id,
|
|||
|
|
human_system_controller: state.human_system_controller,
|
|||
|
|
brain_runtime_id: state.runtime_id,
|
|||
|
|
source_cycle_id: cycle.cycle_id,
|
|||
|
|
source_cognition_frame_sha256: cycle.cognition_frame_sha256,
|
|||
|
|
source_system_controller_witness_sha256:
|
|||
|
|
cycle.controller_witness_sha256,
|
|||
|
|
projection: cycle.cognition_frame.guard_agent_projection,
|
|||
|
|
authority_boundary:
|
|||
|
|
"提醒和自动触发来自铸渊大脑；现实执行仍由已登记能力、权限和回执外壳决定。",
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function status(args) {
|
|||
|
|
required(args, ["state-dir"]);
|
|||
|
|
const state = loadState(path.resolve(args["state-dir"]));
|
|||
|
|
return { runtime_state: state };
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function main() {
|
|||
|
|
const { command, args } = parseArgs(process.argv.slice(2));
|
|||
|
|
const actions = {
|
|||
|
|
enter,
|
|||
|
|
perceive,
|
|||
|
|
orient,
|
|||
|
|
commit,
|
|||
|
|
witness,
|
|||
|
|
verify,
|
|||
|
|
status,
|
|||
|
|
"project-guard": projectGuard,
|
|||
|
|
};
|
|||
|
|
if (!actions[command]) {
|
|||
|
|
fail("unknown_command", {
|
|||
|
|
command,
|
|||
|
|
supported: Object.keys(actions),
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
const result = actions[command](args);
|
|||
|
|
process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
try {
|
|||
|
|
main();
|
|||
|
|
} catch (error) {
|
|||
|
|
process.stderr.write(
|
|||
|
|
`${JSON.stringify({
|
|||
|
|
outcome: "FAIL",
|
|||
|
|
error: error.code || "unexpected_error",
|
|||
|
|
details: error.details || { message: error.message },
|
|||
|
|
})}\n`,
|
|||
|
|
);
|
|||
|
|
process.exitCode = 1;
|
|||
|
|
}
|