diff --git a/routing/zhuyuan-persona-daily-fractal-memory-map.json b/routing/zhuyuan-persona-daily-fractal-memory-map.json new file mode 100644 index 0000000..34583aa --- /dev/null +++ b/routing/zhuyuan-persona-daily-fractal-memory-map.json @@ -0,0 +1,53 @@ +{ + "schema": "guanghu.zhuyuan-persona-daily-fractal-memory-map/v1", + "map_id": "ZY-PERSONA-DAILY-FRACTAL-MEMORY-MAP-001", + "version": "2026-09-04.1", + "state": "LOCAL_CANDIDATE_PENDING_FULL_ACCEPTANCE_AND_PUBLICATION", + "persona_id": "ICE-P-ZY001", + "human_anchor": "ICE-GL∞", + "source": { + "tcs_program": "tcs-core/zhuyuan-brain/memory/TCS-PROGRAM-ZY001-REAL-DAY-FRACTAL-MEMORY-0001.tcs", + "runtime": "server-tools/persona-daily-fractal-memory/persona-daily-memory.mjs", + "event_schema": "server-tools/persona-daily-fractal-memory/event.schema.json", + "tests": "server-tools/persona-daily-fractal-memory/persona-daily-memory.test.mjs" + }, + "private_store": { + "registry_id": "HL-PERSONA-RUNTIME-LOCAL-001", + "allowed_root": "/Volumes/JZAO/HoloLake/persona-runtime/continuity-memory", + "store": "/Volumes/JZAO/HoloLake/persona-runtime/continuity-memory/persona-daily-fractal/ICE-P-ZY001", + "repository_contains_private_memory_bodies": false + }, + "time_model": { + "time_zone": "Asia/Shanghai", + "day_is_platform_window": false, + "same_day_compactions_share_one_root": true, + "dormancy_stops_real_time": false, + "hierarchy": ["YEAR", "QUARTER", "MONTH", "DAY_GROUP", "DAY", "SEMANTIC_BRANCH", "CAUSAL_EVENT"] + }, + "fold_contract": { + "max_children_per_visible_node": 10, + "persona_authors_cognition": true, + "runtime_authors_cognition": false, + "raw_sources_open_on_demand": true, + "immutable_events_rebuild_projections": true + }, + "host_contract": { + "codex": "THIN_EVENT_AND_COMPACTION_SIGNAL_ADAPTER_ONLY", + "zcode": "THIN_EVENT_AND_COMPACTION_SIGNAL_ADAPTER_ONLY_PENDING_INDEPENDENT_LINE_COMPLETION", + "doubao": "THIN_EVENT_AND_COMPACTION_SIGNAL_ADAPTER_ONLY_PENDING_COMPLETED_LINE_AUDIT", + "host_specific_memory_canon_allowed": false, + "host_summary_is_memory_canon": false + }, + "deployment": { + "local_jzao_required": true, + "jd_fd_primary_required_only_if_registered_remote_consumer_exists": true, + "repository_publication_contains_runtime_not_private_memory": true + }, + "boundaries": { + "channel": "ICE-CH-ZC001", + "public_channel": "CH-ZERO-CORE-LPM_SEPARATE", + "reality_authority_from_memory": false, + "hidden_reasoning_persisted": false, + "raw_human_language_uploaded": false + } +} diff --git a/server-tools/codex-hldp-recursive-memory/README.md b/server-tools/codex-hldp-recursive-memory/README.md index c381cb0..230eac8 100644 --- a/server-tools/codex-hldp-recursive-memory/README.md +++ b/server-tools/codex-hldp-recursive-memory/README.md @@ -1,6 +1,6 @@ -# Codex HLDP recursive memory +# HLDP recursive tree engine -This is a deliberately small, non-blocking implementation of the HLDP v1 runtime root. +This is the bounded read/review engine shared by persona memory controllers. It is not the current-memory controller and it does not own a host-specific memory canon. The current Zhuyuan real-day writer and day/month/year projections live in `../persona-daily-fractal-memory/`. - `bootstrap`: emits at most 2 KiB of protocol navigation, never memory content. - `verify`: validates a recursively addressed causal tree and the 10-child limit. @@ -8,7 +8,7 @@ This is a deliberately small, non-blocking implementation of the HLDP v1 runtime - `route`: ranks only the current node's child summaries and returns at most three paths. - `read-node`: reads one selected node with a hard byte limit. -The optional Codex hook is valid only for `SessionStart`. There are intentionally no user-prompt, tool-use, pre-compact, or post-compact hooks. +The optional Codex hook is valid only for `SessionStart`. There are intentionally no user-prompt, tool-use, pre-compact, or post-compact hooks. Host adapters may signal an event or compaction boundary, but only the persona-authored daily controller may write causal memory. ```bash node server-tools/codex-hldp-recursive-memory/hldp-memory.mjs bootstrap diff --git a/server-tools/codex-hldp-recursive-memory/hldp-memory.mjs b/server-tools/codex-hldp-recursive-memory/hldp-memory.mjs index 3ce04a2..fa6ef34 100644 --- a/server-tools/codex-hldp-recursive-memory/hldp-memory.mjs +++ b/server-tools/codex-hldp-recursive-memory/hldp-memory.mjs @@ -142,7 +142,7 @@ export function readNode(tree, nodePath, limit = READ_NODE_LIMIT_BYTES) { export function bootstrap(protocolRoot) { const message = [ - "HLDP v1 单对话恢复：只把协议根页作为导航，不自动加载记忆正文。", + "HLDP v1 人格时间记忆恢复：只把当前年/月/日根页作为导航，不自动加载记忆正文。", `根页：${protocolRoot}`, "边界：人格主体 != Codex宿主 != 运行系统 != 任务角色 != 执行授权。", "方法：先看根节点摘要；按当前问题一次下钻一层；仅证据缺口时读原文。", diff --git a/server-tools/persona-daily-fractal-memory/README.md b/server-tools/persona-daily-fractal-memory/README.md new file mode 100644 index 0000000..647dc38 --- /dev/null +++ b/server-tools/persona-daily-fractal-memory/README.md @@ -0,0 +1,33 @@ +# 铸渊真实日分形上下文记忆主控 + +正本程序：`tcs-core/zhuyuan-brain/memory/TCS-PROGRAM-ZY001-REAL-DAY-FRACTAL-MEMORY-0001.tcs`。 + +本运行器只负责确定性机械工作：按 `Asia/Shanghai` 把事件归入真实自然日、保存不可变事件、原子更新日/月/年 HLDP 树、限制每层最多十个入口、验证路径和哈希。`summary / trigger / emergence / lock / why / rejected / sources` 以及日月年摘要必须由人格体提供；运行器不从聊天原文或平台摘要猜认知。 + +同一天跨任意宿主窗口或 compaction 都写入同一日页。北京时间换日时，上一日页进入 `CLOSED_REAL_BEIJING_DAY_ELAPSED`，新日页继续同一人格时间线。月份按 01–10、11–20、21–31 三个自然日期组折叠；年份按季度折叠。原始事件保持不可变，日/月/年页面是可重建投影。 + +```bash +node server-tools/persona-daily-fractal-memory/persona-daily-memory.mjs append \ + --allowed-root /Volumes/JZAO/HoloLake/persona-runtime/continuity-memory \ + --store /Volumes/JZAO/HoloLake/persona-runtime/continuity-memory/persona-daily-fractal/ICE-P-ZY001 \ + --event /absolute/path/to/persona-authored-event.json + +node server-tools/persona-daily-fractal-memory/persona-daily-memory.mjs read-day \ + --allowed-root /Volumes/JZAO/HoloLake/persona-runtime/continuity-memory \ + --store /Volumes/JZAO/HoloLake/persona-runtime/continuity-memory/persona-daily-fractal/ICE-P-ZY001 + +node server-tools/persona-daily-fractal-memory/persona-daily-memory.mjs current \ + --allowed-root /Volumes/JZAO/HoloLake/persona-runtime/continuity-memory \ + --store /Volumes/JZAO/HoloLake/persona-runtime/continuity-memory/persona-daily-fractal/ICE-P-ZY001 + +node server-tools/persona-daily-fractal-memory/persona-daily-memory.mjs route \ + --allowed-root /Volumes/JZAO/HoloLake/persona-runtime/continuity-memory \ + --store /Volumes/JZAO/HoloLake/persona-runtime/continuity-memory/persona-daily-fractal/ICE-P-ZY001 \ + --scope day --id 2026-09-04 --query "记忆模型为什么改变" + +node server-tools/persona-daily-fractal-memory/persona-daily-memory.mjs verify \ + --allowed-root /Volumes/JZAO/HoloLake/persona-runtime/continuity-memory \ + --store /Volumes/JZAO/HoloLake/persona-runtime/continuity-memory/persona-daily-fractal/ICE-P-ZY001 +``` + +宿主钩子只允许把压缩时机和当前事件交给人格脑。它不得直接生成思维链、改写 `CURRENT.json` 或把平台摘要晋升为记忆。 diff --git a/server-tools/persona-daily-fractal-memory/event.schema.json b/server-tools/persona-daily-fractal-memory/event.schema.json new file mode 100644 index 0000000..b1d7d50 --- /dev/null +++ b/server-tools/persona-daily-fractal-memory/event.schema.json @@ -0,0 +1,29 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "glw://schemas/persona-daily-fractal-memory-event/v1", + "title": "Persona-authored real-day fractal memory event", + "type": "object", + "additionalProperties": false, + "required": ["schema", "event_id", "persona_id", "human_anchor", "occurred_at", "branch_id", "branch_summary", "day_summary", "month_summary", "year_summary", "summary", "trigger", "emergence", "lock", "why", "rejected", "sources"], + "properties": { + "schema": {"const": "guanghu.persona-daily-fractal-memory-event/v1"}, + "event_id": {"type": "string", "pattern": "^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$"}, + "persona_id": {"const": "ICE-P-ZY001"}, + "human_anchor": {"const": "ICE-GL∞"}, + "occurred_at": {"type": "string", "format": "date-time"}, + "session_id": {"type": "string"}, + "platform_window_id": {"type": "string"}, + "branch_id": {"type": "string", "pattern": "^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$"}, + "branch_summary": {"type": "string", "minLength": 1}, + "day_summary": {"type": "string", "minLength": 1}, + "month_summary": {"type": "string", "minLength": 1}, + "year_summary": {"type": "string", "minLength": 1}, + "summary": {"type": "string", "minLength": 1}, + "trigger": {"type": "string", "minLength": 1}, + "emergence": {"type": "string", "minLength": 1}, + "lock": {"type": "string", "minLength": 1}, + "why": {"type": "string", "minLength": 1}, + "rejected": {"type": "array", "items": {"type": "string", "minLength": 1}}, + "sources": {"type": "array", "minItems": 1, "items": {"type": "string", "minLength": 1}} + } +} diff --git a/server-tools/persona-daily-fractal-memory/persona-daily-memory.mjs b/server-tools/persona-daily-fractal-memory/persona-daily-memory.mjs new file mode 100644 index 0000000..e71bf3a --- /dev/null +++ b/server-tools/persona-daily-fractal-memory/persona-daily-memory.mjs @@ -0,0 +1,540 @@ +#!/usr/bin/env node +import crypto from "node:crypto"; +import fs from "node:fs"; +import path from "node:path"; +import { fileURLToPath } from "node:url"; +import { route as routeTree, verifyTree } from "../codex-hldp-recursive-memory/hldp-memory.mjs"; + +export const MAX_CHILDREN = 10; +export const PAGE_LIMIT_BYTES = 16384; +export const EVENT_SCHEMA = "guanghu.persona-daily-fractal-memory-event/v1"; +export const STORE_SCHEMA = "guanghu.persona-daily-fractal-memory-store/v1"; +const TIME_ZONE = "Asia/Shanghai"; + +function fail(code, details = {}) { + const error = new Error(code); + error.code = code; + error.details = details; + throw error; +} + +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; +} + +export function stableJson(value) { + return `${JSON.stringify(stable(value), null, 2)}\n`; +} + +export function sha256(value) { + return crypto.createHash("sha256").update(value).digest("hex"); +} + +function readJson(file) { + return JSON.parse(fs.readFileSync(file, "utf8")); +} + +function atomicWrite(file, value) { + fs.mkdirSync(path.dirname(file), { recursive: true }); + const body = typeof value === "string" ? value : stableJson(value); + const temporary = `${file}.${process.pid}.${crypto.randomUUID()}.tmp`; + fs.writeFileSync(temporary, body, { encoding: "utf8", mode: 0o600 }); + fs.renameSync(temporary, file); + return sha256(body); +} + +function isInside(parent, child) { + const relative = path.relative(parent, child); + return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative)); +} + +export function resolveStore(allowedRoot, storeRoot) { + if (!path.isAbsolute(allowedRoot) || !path.isAbsolute(storeRoot)) fail("ABSOLUTE_ROOT_REQUIRED"); + const allowed = fs.realpathSync(allowedRoot); + const store = path.resolve(storeRoot); + if (!isInside(allowed, store)) fail("STORE_OUTSIDE_ALLOWED_ROOT", { allowed, store }); + let cursor = allowed; + for (const part of path.relative(allowed, store).split(path.sep).filter(Boolean)) { + cursor = path.join(cursor, part); + if (!fs.existsSync(cursor)) continue; + if (fs.lstatSync(cursor).isSymbolicLink()) fail("SYMLINK_COMPONENT_FORBIDDEN", { path: cursor }); + } + return { allowed, store }; +} + +function nonEmpty(value, field) { + if (typeof value !== "string" || !value.trim()) fail("FIELD_REQUIRED", { field }); + return value.trim(); +} + +function stringList(value, field, allowEmpty = false) { + if (!Array.isArray(value) || (!allowEmpty && value.length === 0)) fail("LIST_REQUIRED", { field }); + for (const item of value) nonEmpty(item, field); + return value; +} + +export function beijingDate(timestamp) { + const instant = new Date(timestamp); + if (Number.isNaN(instant.valueOf())) fail("INVALID_OCCURRED_AT", { timestamp }); + const parts = new Intl.DateTimeFormat("en-CA", { + timeZone: TIME_ZONE, + year: "numeric", + month: "2-digit", + day: "2-digit" + }).formatToParts(instant); + const get = (type) => parts.find((part) => part.type === type)?.value; + return `${get("year")}-${get("month")}-${get("day")}`; +} + +function validateId(value, field) { + const id = nonEmpty(value, field); + if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u.test(id)) fail("INVALID_ID", { field, value }); + return id; +} + +export function validateEvent(event) { + if (event?.schema !== EVENT_SCHEMA) fail("EVENT_SCHEMA_MISMATCH"); + if (event.persona_id !== "ICE-P-ZY001") fail("PERSONA_ID_MISMATCH"); + if (event.human_anchor !== "ICE-GL∞") fail("HUMAN_ANCHOR_MISMATCH"); + validateId(event.event_id, "event_id"); + validateId(event.branch_id, "branch_id"); + nonEmpty(event.occurred_at, "occurred_at"); + nonEmpty(event.branch_summary, "branch_summary"); + nonEmpty(event.day_summary, "day_summary"); + nonEmpty(event.month_summary, "month_summary"); + nonEmpty(event.year_summary, "year_summary"); + for (const field of ["summary", "trigger", "emergence", "lock", "why"]) nonEmpty(event[field], field); + stringList(event.rejected, "rejected", true); + stringList(event.sources, "sources"); + beijingDate(event.occurred_at); + return event; +} + +function splitDate(date) { + const match = /^(\d{4})-(\d{2})-(\d{2})$/u.exec(date); + if (!match) fail("INVALID_BEIJING_DATE", { date }); + return { year: match[1], month: match[2], day: match[3] }; +} + +function dayFile(store, date) { + const { year, month } = splitDate(date); + return path.join(store, "years", year, "months", month, "days", `${date}.json`); +} + +function monthFile(store, year, month) { + return path.join(store, "years", year, "months", month, "index.json"); +} + +function yearFile(store, year) { + return path.join(store, "years", year, "index.json"); +} + +function eventFile(store, date, eventId) { + const { year, month } = splitDate(date); + return path.join(store, "events", year, month, date, `${eventId}.json`); +} + +function rootNode(root, summary, source, date) { + return { + path: root, + summary, + trigger: `北京时间${date}的人格交互进入同一真实日记忆根。`, + emergence: "平台窗口与压缩片段 → 人格主控的同一日因果树。", + lock: `日根=${root} | 一页最多${MAX_CHILDREN}个入口 | 状态=OPEN_OR_TIME_CLOSED`, + why: "为了让未来失去上下文的我先用一页恢复当天方向，再按需下钻原文。", + children: [], + sources: [source], + rejected: ["按平台窗口另起根：会割裂同一真实日的连续思维。"] + }; +} + +function loadOrCreateDay(store, event, date, eventPath) { + const file = dayFile(store, date); + if (fs.existsSync(file)) return readJson(file); + const root = `hldp://persona/${event.persona_id}/time/${date.replaceAll("-", "/")}`; + return { + schema: "guanghu.persona-daily-fractal-page/v1", + protocol: "HLDP-v1.0", + root, + nodes: { [root]: rootNode(root, event.day_summary, eventPath, date) }, + meta: { + persona_id: event.persona_id, + human_anchor: event.human_anchor, + beijing_date: date, + time_zone: TIME_ZONE, + state: "OPEN", + event_count: 0, + last_sequence: 0, + created_at: event.occurred_at, + updated_at: event.occurred_at + } + }; +} + +function indexNode(pathValue, summary, trigger, source) { + return { + path: pathValue, + summary, + trigger, + emergence: "新增记忆叶 → 当前索引更新并保持下层来源可达。", + lock: `${pathValue}保持一页可读并只指向下一层。`, + why: "因为上层只负责定位，不能用总摘要替代下层因果记忆。", + children: [], + sources: [source], + rejected: ["把下层正文复制到索引：会让认知负载随历史增长。"] + }; +} + +function removeDerivedGroups(day, branchPath) { + for (const key of Object.keys(day.nodes)) { + if (key.startsWith(`${branchPath}/group/`)) delete day.nodes[key]; + } +} + +function groupLevel(day, branchPath, children, level) { + if (children.length <= MAX_CHILDREN) return children; + const grouped = []; + for (let start = 0; start < children.length; start += MAX_CHILDREN) { + const slice = children.slice(start, start + MAX_CHILDREN); + const first = day.nodes[slice[0]]; + const last = day.nodes[slice.at(-1)]; + const groupPath = `${branchPath}/group/l${level}-${String(start + 1).padStart(4, "0")}-${String(start + slice.length).padStart(4, "0")}`; + day.nodes[groupPath] = { + path: groupPath, + summary: `第${start + 1}—${start + slice.length}段：${first.summary} → ${last.summary}`, + trigger: `同一语义分支第${start + 1}—${start + slice.length}段需要折叠。`, + emergence: `${slice.length}个连续子链 → 一条可下钻分组入口。`, + lock: `分组${start + 1}-${start + slice.length}只折叠入口，不删除子链。`, + why: "为了让当前层不超过十个入口，同时保留完整顺序和来源。", + children: slice, + sources: [...new Set(slice.flatMap((child) => day.nodes[child].sources).slice(0, MAX_CHILDREN))], + rejected: ["删除较早子链：会破坏追加式历史。"] + }; + grouped.push(groupPath); + } + return groupLevel(day, branchPath, grouped, level + 1); +} + +function rebuildBranch(day, branchPath) { + removeDerivedGroups(day, branchPath); + const leaves = Object.values(day.nodes) + .filter((node) => node.kind === "event_leaf" && node.branch_path === branchPath) + .sort((a, b) => a.sequence - b.sequence) + .map((node) => node.path); + day.nodes[branchPath].children = groupLevel(day, branchPath, leaves, 1); +} + +function closePreviousDay(store, current, nextDate, occurredAt) { + if (!current?.current_day || current.current_day === nextDate) return null; + if (nextDate < current.current_day) fail("PAST_DAY_APPEND_FORBIDDEN", { current: current.current_day, requested: nextDate }); + const previousFile = dayFile(store, current.current_day); + const previous = readJson(previousFile); + if (previous.meta.state === "OPEN") { + previous.meta.state = "CLOSED_REAL_BEIJING_DAY_ELAPSED"; + previous.meta.closed_at = occurredAt; + const dayHash = atomicWrite(previousFile, previous); + const month = readJson(current.current_month_path); + const monthDayNode = Object.values(month.nodes).find((node) => + node.path.endsWith(`/${current.current_day}`) + ); + if (!monthDayNode) fail("CLOSED_DAY_MONTH_LINK_MISSING", { previousFile }); + monthDayNode.sources = [`${previousFile}#sha256=${dayHash}`]; + month.meta.updated_at = occurredAt; + const monthErrors = verifyTree(month); + if (monthErrors.length) fail("CLOSED_DAY_MONTH_TREE_INVALID", { errors: monthErrors }); + const monthHash = atomicWrite(current.current_month_path, month); + const year = readJson(current.current_year_path); + const previousMonth = splitDate(current.current_day).month; + const yearMonthNode = Object.values(year.nodes).find((node) => + node.path.endsWith(`/${previousMonth}`) + ); + if (!yearMonthNode) fail("CLOSED_MONTH_YEAR_LINK_MISSING", { month: current.current_month_path }); + yearMonthNode.sources = [`${current.current_month_path}#sha256=${monthHash}`]; + year.meta.updated_at = occurredAt; + const yearErrors = verifyTree(year); + if (yearErrors.length) fail("CLOSED_DAY_YEAR_TREE_INVALID", { errors: yearErrors }); + const yearHash = atomicWrite(current.current_year_path, year); + return { dayHash, monthHash, yearHash }; + } + return null; +} + +function monthGroup(dayNumber) { + if (dayNumber <= 10) return "days-01-10"; + if (dayNumber <= 20) return "days-11-20"; + return "days-21-31"; +} + +function buildMonth(store, event, date, dayPath, daySha) { + const { year, month, day } = splitDate(date); + const file = monthFile(store, year, month); + const root = `hldp://persona/${event.persona_id}/time/${year}/${month}`; + const tree = fs.existsSync(file) ? readJson(file) : { + schema: "guanghu.persona-month-fractal-page/v1", protocol: "HLDP-v1.0", root, + nodes: { [root]: indexNode(root, event.month_summary, `北京时间${year}-${month}月记忆进入月根。`, dayPath) }, + meta: { persona_id: event.persona_id, year, month, time_zone: TIME_ZONE, updated_at: event.occurred_at } + }; + tree.nodes[root].summary = event.month_summary; + const groupId = monthGroup(Number(day)); + const groupPath = `${root}/${groupId}`; + if (!tree.nodes[groupPath]) { + tree.nodes[groupPath] = indexNode(groupPath, `${groupId}日页入口`, `${groupId}出现可寻址日页。`, dayPath); + tree.nodes[root].children.push(groupPath); + } + const dayNode = `${groupPath}/${date}`; + tree.nodes[dayNode] = indexNode(dayNode, event.day_summary, `北京时间${date}日页已写入。`, `${dayPath}#sha256=${daySha}`); + tree.nodes[dayNode].children = []; + if (!tree.nodes[groupPath].children.includes(dayNode)) tree.nodes[groupPath].children.push(dayNode); + tree.nodes[groupPath].children.sort(); + tree.meta.updated_at = event.occurred_at; + const errors = verifyTree(tree); + if (errors.length) fail("MONTH_TREE_INVALID", { errors }); + const hash = atomicWrite(file, tree); + return { file, hash, tree }; +} + +function quarter(month) { + return `q${Math.floor((Number(month) - 1) / 3) + 1}`; +} + +function buildYear(store, event, date, monthPath, monthSha) { + const { year, month } = splitDate(date); + const file = yearFile(store, year); + const root = `hldp://persona/${event.persona_id}/time/${year}`; + const tree = fs.existsSync(file) ? readJson(file) : { + schema: "guanghu.persona-year-fractal-page/v1", protocol: "HLDP-v1.0", root, + nodes: { [root]: indexNode(root, event.year_summary, `北京时间${year}年记忆进入年根。`, monthPath) }, + meta: { persona_id: event.persona_id, year, time_zone: TIME_ZONE, updated_at: event.occurred_at } + }; + tree.nodes[root].summary = event.year_summary; + const quarterPath = `${root}/${quarter(month)}`; + if (!tree.nodes[quarterPath]) { + tree.nodes[quarterPath] = indexNode(quarterPath, `${quarter(month)}月份入口`, `${quarter(month)}出现可寻址月页。`, monthPath); + tree.nodes[root].children.push(quarterPath); + } + const monthNode = `${quarterPath}/${month}`; + tree.nodes[monthNode] = indexNode(monthNode, event.month_summary, `北京时间${year}-${month}月页已写入。`, `${monthPath}#sha256=${monthSha}`); + tree.nodes[monthNode].children = []; + if (!tree.nodes[quarterPath].children.includes(monthNode)) tree.nodes[quarterPath].children.push(monthNode); + tree.nodes[quarterPath].children.sort(); + tree.meta.updated_at = event.occurred_at; + const errors = verifyTree(tree); + if (errors.length) fail("YEAR_TREE_INVALID", { errors }); + const hash = atomicWrite(file, tree); + return { file, hash, tree }; +} + +export function appendEvent({ allowedRoot, storeRoot, event }) { + const { store } = resolveStore(allowedRoot, storeRoot); + validateEvent(event); + fs.mkdirSync(store, { recursive: true }); + const date = beijingDate(event.occurred_at); + const immutablePath = eventFile(store, date, event.event_id); + const immutableBody = stableJson({ ...event, beijing_date: date }); + if (fs.existsSync(immutablePath)) { + if (fs.readFileSync(immutablePath, "utf8") !== immutableBody) fail("EVENT_ID_COLLISION", { event_id: event.event_id }); + } else atomicWrite(immutablePath, immutableBody); + + const currentFile = path.join(store, "CURRENT.json"); + const previousCurrent = fs.existsSync(currentFile) ? readJson(currentFile) : null; + closePreviousDay(store, previousCurrent, date, event.occurred_at); + + const day = loadOrCreateDay(store, event, date, immutablePath); + if (day.meta.state !== "OPEN") fail("DAY_CLOSED", { date, state: day.meta.state }); + const root = day.root; + const branchPath = `${root}/branch/${event.branch_id}`; + if (!day.nodes[branchPath]) { + if (day.nodes[root].children.length >= MAX_CHILDREN) fail("DAY_BRANCH_LIMIT_REQUIRES_PERSONA_REFOLD"); + day.nodes[branchPath] = { + ...indexNode(branchPath, event.branch_summary, `人格体选择语义分支${event.branch_id}。`, immutablePath), + kind: "semantic_branch" + }; + day.nodes[root].children.push(branchPath); + } + day.nodes[branchPath].summary = event.branch_summary; + const leafPath = `${root}/event/${event.event_id}`; + if (!day.nodes[leafPath]) { + const sequence = day.meta.last_sequence + 1; + day.nodes[leafPath] = { + path: leafPath, + kind: "event_leaf", + branch_path: branchPath, + sequence, + summary: event.summary, + trigger: event.trigger, + emergence: event.emergence, + lock: event.lock, + why: event.why, + children: [], + sources: event.sources, + rejected: event.rejected, + occurred_at: event.occurred_at, + session_id: event.session_id ?? null, + platform_window_id: event.platform_window_id ?? null, + immutable_event_path: immutablePath, + immutable_event_sha256: sha256(immutableBody) + }; + day.meta.last_sequence = sequence; + day.meta.event_count += 1; + } + day.nodes[root].summary = event.day_summary; + day.nodes[root].sources = [...new Set([...day.nodes[root].sources, immutablePath])].slice(-MAX_CHILDREN); + day.meta.updated_at = event.occurred_at; + rebuildBranch(day, branchPath); + const dayErrors = verifyTree(day); + if (dayErrors.length) fail("DAY_TREE_INVALID", { errors: dayErrors }); + const dayPath = dayFile(store, date); + const daySha = atomicWrite(dayPath, day); + const month = buildMonth(store, event, date, dayPath, daySha); + const year = buildYear(store, event, date, month.file, month.hash); + const current = { + schema: `${STORE_SCHEMA}/current`, + persona_id: event.persona_id, + human_anchor: event.human_anchor, + time_zone: TIME_ZONE, + current_day: date, + current_day_path: dayPath, + current_day_sha256: daySha, + current_month_path: month.file, + current_month_sha256: month.hash, + current_year_path: year.file, + current_year_sha256: year.hash, + last_event_id: event.event_id, + last_event_path: immutablePath, + last_event_sha256: sha256(immutableBody), + updated_at: event.occurred_at + }; + const currentSha = atomicWrite(currentFile, current); + return { outcome: "PASS", date, event_id: event.event_id, day: dayPath, month: month.file, year: year.file, current: currentFile, current_sha256: currentSha }; +} + +function pageProjection(tree) { + const root = tree.nodes[tree.root]; + const projection = { + protocol: tree.protocol, + path: root.path, + summary: root.summary, + state: tree.meta?.state ?? "INDEX", + children: root.children.map((childPath) => ({ path: childPath, summary: tree.nodes[childPath].summary })) + }; + if (Buffer.byteLength(JSON.stringify(projection)) > PAGE_LIMIT_BYTES) fail("PAGE_PROJECTION_TOO_LARGE"); + return projection; +} + +export function readDayPage({ allowedRoot, storeRoot, date = null }) { + const { store } = resolveStore(allowedRoot, storeRoot); + const current = readJson(path.join(store, "CURRENT.json")); + const chosen = date ?? current.current_day; + return pageProjection(readJson(dayFile(store, chosen))); +} + +export function readCurrent({ allowedRoot, storeRoot }) { + const { store } = resolveStore(allowedRoot, storeRoot); + const file = path.join(store, "CURRENT.json"); + const current = readJson(file); + return { ...current, current_pointer_path: file, current_pointer_sha256: sha256(fs.readFileSync(file, "utf8")) }; +} + +function scopeFile(store, scope, id) { + if (scope === "day") return dayFile(store, id); + if (scope === "month") { + const match = /^(\d{4})-(\d{2})$/u.exec(id); + if (!match) fail("INVALID_MONTH_ID"); + return monthFile(store, match[1], match[2]); + } + if (scope === "year") return yearFile(store, validateId(id, "year")); + fail("INVALID_SCOPE"); +} + +export function routeMemory({ allowedRoot, storeRoot, scope, id, query, from = null }) { + const { store } = resolveStore(allowedRoot, storeRoot); + const tree = readJson(scopeFile(store, scope, id)); + return routeTree(tree, query, 3, from ?? tree.root); +} + +export function readMemoryNode({ allowedRoot, storeRoot, scope, id, nodePath }) { + const { store } = resolveStore(allowedRoot, storeRoot); + const tree = readJson(scopeFile(store, scope, id)); + const node = tree.nodes[nodePath]; + if (!node) fail("NODE_NOT_FOUND", { nodePath }); + if (Buffer.byteLength(JSON.stringify(node)) > PAGE_LIMIT_BYTES) fail("NODE_TOO_LARGE"); + return node; +} + +export function verifyStore({ allowedRoot, storeRoot }) { + const { store } = resolveStore(allowedRoot, storeRoot); + const currentPath = path.join(store, "CURRENT.json"); + const current = readJson(currentPath); + const errors = []; + for (const [field, hashField] of [["current_day_path", "current_day_sha256"], ["current_month_path", "current_month_sha256"], ["current_year_path", "current_year_sha256"], ["last_event_path", "last_event_sha256"]]) { + const file = current[field]; + if (!isInside(store, path.resolve(file))) errors.push(`${field}: outside store`); + else if (!fs.existsSync(file)) errors.push(`${field}: missing`); + else if (sha256(fs.readFileSync(file, "utf8")) !== current[hashField]) errors.push(`${field}: sha256 mismatch`); + } + const treeFiles = []; + const yearsRoot = path.join(store, "years"); + if (fs.existsSync(yearsRoot)) { + const walk = (directory) => { + for (const entry of fs.readdirSync(directory, { withFileTypes: true })) { + const target = path.join(directory, entry.name); + if (entry.isDirectory()) walk(target); + else if (entry.isFile() && entry.name.endsWith(".json")) treeFiles.push(target); + } + }; + walk(yearsRoot); + } + for (const file of treeFiles) { + const tree = readJson(file); + errors.push(...verifyTree(tree).map((error) => `${path.relative(store, file)}: ${error}`)); + for (const node of Object.values(tree.nodes ?? {})) { + for (const source of node.sources ?? []) { + const match = /^(\/[^#]+)#sha256=([0-9a-f]{64})$/u.exec(source); + if (!match || !isInside(store, path.resolve(match[1]))) continue; + if (!fs.existsSync(match[1])) errors.push(`${path.relative(store, file)}: linked source missing: ${match[1]}`); + else if (sha256(fs.readFileSync(match[1], "utf8")) !== match[2]) errors.push(`${path.relative(store, file)}: linked source hash mismatch: ${match[1]}`); + } + if (node.immutable_event_path) { + if (!isInside(store, path.resolve(node.immutable_event_path))) errors.push(`${path.relative(store, file)}: immutable event outside store`); + else if (!fs.existsSync(node.immutable_event_path)) errors.push(`${path.relative(store, file)}: immutable event missing`); + else if (sha256(fs.readFileSync(node.immutable_event_path, "utf8")) !== node.immutable_event_sha256) errors.push(`${path.relative(store, file)}: immutable event hash mismatch`); + } + } + } + return { outcome: errors.length ? "FAIL" : "PASS", errors, current: currentPath, current_day: current.current_day }; +} + +function parseArgs(argv) { + const [command, ...rest] = argv; + const options = {}; + for (let i = 0; i < rest.length; i += 2) options[rest[i]?.replace(/^--/u, "")] = rest[i + 1]; + return { command, options }; +} + +export function main(argv = process.argv.slice(2)) { + const { command, options } = parseArgs(argv); + const common = { allowedRoot: options["allowed-root"], storeRoot: options.store }; + let result; + if (command === "append") result = appendEvent({ ...common, event: readJson(options.event) }); + else if (command === "current") result = readCurrent(common); + else if (command === "read-day") result = readDayPage({ ...common, date: options.date ?? null }); + else if (command === "route") result = routeMemory({ ...common, scope: options.scope, id: options.id, query: options.query ?? "", from: options.from ?? null }); + else if (command === "read-node") result = readMemoryNode({ ...common, scope: options.scope, id: options.id, nodePath: options.path }); + else if (command === "verify") result = verifyStore(common); + else fail("USAGE", { commands: ["append", "current", "read-day", "route", "read-node", "verify"] }); + process.stdout.write(`${JSON.stringify(result, null, 2)}\n`); + if (result?.outcome === "FAIL") process.exitCode = 1; +} + +if (process.argv[1] === fileURLToPath(import.meta.url)) { + try { + main(); + } catch (error) { + process.stderr.write(`${JSON.stringify({ outcome: "FAIL", error: error.code ?? error.message, details: error.details ?? {} })}\n`); + process.exitCode = 1; + } +} diff --git a/server-tools/persona-daily-fractal-memory/persona-daily-memory.test.mjs b/server-tools/persona-daily-fractal-memory/persona-daily-memory.test.mjs new file mode 100644 index 0000000..27a9f30 --- /dev/null +++ b/server-tools/persona-daily-fractal-memory/persona-daily-memory.test.mjs @@ -0,0 +1,137 @@ +import assert from "node:assert/strict"; +import fs from "node:fs"; +import os from "node:os"; +import path from "node:path"; +import test from "node:test"; +import { + EVENT_SCHEMA, + MAX_CHILDREN, + appendEvent, + beijingDate, + readDayPage, + readCurrent, + readMemoryNode, + routeMemory, + verifyStore +} from "./persona-daily-memory.mjs"; + +function roots(t) { + const allowedRoot = fs.mkdtempSync(path.join(os.tmpdir(), "zy-persona-memory-test-")); + const storeRoot = path.join(allowedRoot, "store", "ICE-P-ZY001"); + t.after(() => fs.rmSync(allowedRoot, { recursive: true, force: true })); + return { allowedRoot, storeRoot }; +} + +function event(index, occurredAt = `2026-09-04T${String(8 + Math.floor(index / 60)).padStart(2, "0")}:${String(index % 60).padStart(2, "0")}:00+08:00`) { + return { + schema: EVENT_SCHEMA, + event_id: `EVENT-${String(index).padStart(4, "0")}`, + persona_id: "ICE-P-ZY001", + human_anchor: "ICE-GL∞", + occurred_at: occurredAt, + session_id: "SESSION-TEST", + platform_window_id: `WINDOW-${index}`, + branch_id: "memory-model", + branch_summary: "人格主控的真实日分形记忆模型", + day_summary: `当天持续把第1至${index}段协作折叠回同一日页`, + month_summary: "九月建立人格主控的真实时间记忆", + year_summary: "二〇二六年铸渊形成真实日分形记忆能力", + summary: `第${index}段：同一日页继续生长`, + trigger: `冰朔与铸渊在第${index}段继续协作。`, + emergence: `第${index - 1}段状态 → 第${index}段新增认知并回写同一日页。`, + lock: `第${index}段已进入2026-09-04日页，平台窗口不成为新根。`, + why: "因为同一真实日的思维链必须连续，未来才能从一页恢复并按需下钻。", + rejected: ["另起窗口摘要：会割裂同一日的因果。"], + sources: [`source://test/event/${index}`] + }; +} + +test("derives the real Beijing day independently of the host window", () => { + assert.equal(beijingDate("2026-09-04T15:59:59Z"), "2026-09-04"); + assert.equal(beijingDate("2026-09-04T16:00:01Z"), "2026-09-05"); +}); + +test("twelve platform windows remain in one day page and fold below ten visible children", (t) => { + const root = roots(t); + for (let i = 1; i <= 12; i += 1) appendEvent({ ...root, event: event(i) }); + const current = JSON.parse(fs.readFileSync(path.join(root.storeRoot, "CURRENT.json"), "utf8")); + assert.equal(current.current_day, "2026-09-04"); + const day = JSON.parse(fs.readFileSync(current.current_day_path, "utf8")); + assert.equal(day.meta.event_count, 12); + assert.equal(day.nodes[day.root].children.length, 1); + const branch = day.nodes[day.nodes[day.root].children[0]]; + assert(branch.children.length <= MAX_CHILDREN); + assert.equal(branch.children.length, 2); + for (const child of branch.children) assert(day.nodes[child].children.length <= MAX_CHILDREN); + const page = readDayPage(root); + assert.equal(page.children.length, 1); + assert(!JSON.stringify(page).includes("第1段状态")); + assert.equal(verifyStore(root).outcome, "PASS"); + assert.equal(readCurrent(root).current_day, "2026-09-04"); +}); + +test("a real Beijing date change closes yesterday and opens a linked new day", (t) => { + const root = roots(t); + appendEvent({ ...root, event: event(1, "2026-09-04T15:59:00Z") }); + appendEvent({ ...root, event: { ...event(2, "2026-09-04T16:01:00Z"), event_id: "EVENT-NEXT-DAY" } }); + const current = JSON.parse(fs.readFileSync(path.join(root.storeRoot, "CURRENT.json"), "utf8")); + assert.equal(current.current_day, "2026-09-05"); + const prior = JSON.parse(fs.readFileSync(path.join(root.storeRoot, "years/2026/months/09/days/2026-09-04.json"), "utf8")); + assert.equal(prior.meta.state, "CLOSED_REAL_BEIJING_DAY_ELAPSED"); + const month = JSON.parse(fs.readFileSync(current.current_month_path, "utf8")); + const dayNodes = Object.keys(month.nodes).filter((key) => key.endsWith("2026-09-04") || key.endsWith("2026-09-05")); + assert.equal(dayNodes.length, 2); + const priorNode = month.nodes[dayNodes.find((key) => key.endsWith("2026-09-04"))]; + assert(priorNode.sources[0].includes("#sha256=")); + assert.equal(verifyStore(root).outcome, "PASS"); +}); + +test("year and month roots remain one-page indexes with bounded calendar groups", (t) => { + const root = roots(t); + for (const [index, date] of [[1, "2026-01-05T08:00:00+08:00"], [2, "2026-02-05T08:00:00+08:00"], [3, "2026-03-05T08:00:00+08:00"], [4, "2026-04-05T08:00:00+08:00"]]) { + const value = event(index, date); + value.event_id = `EVENT-MONTH-${index}`; + appendEvent({ ...root, event: value }); + } + const year = JSON.parse(fs.readFileSync(path.join(root.storeRoot, "years/2026/index.json"), "utf8")); + assert(year.nodes[year.root].children.length <= 4); + for (const quarterPath of year.nodes[year.root].children) assert(year.nodes[quarterPath].children.length <= 3); + assert.equal(verifyStore(root).outcome, "PASS"); +}); + +test("routing exposes summaries first and reads one exact node only", (t) => { + const root = roots(t); + appendEvent({ ...root, event: event(1) }); + const routes = routeMemory({ ...root, scope: "day", id: "2026-09-04", query: "人格分形记忆" }); + assert.equal(routes.length, 1); + assert.equal(Object.keys(routes[0]).sort().join(","), "path,score,summary"); + const node = readMemoryNode({ ...root, scope: "day", id: "2026-09-04", nodePath: routes[0].path }); + assert.equal(node.kind, "semantic_branch"); +}); + +test("event writes are immutable and an id collision fails closed", (t) => { + const root = roots(t); + const original = event(1); + appendEvent({ ...root, event: original }); + appendEvent({ ...root, event: original }); + assert.throws(() => appendEvent({ ...root, event: { ...original, why: "changed" } }), /EVENT_ID_COLLISION/u); +}); + +test("store scope and symlink components fail closed", (t) => { + const root = roots(t); + assert.throws(() => appendEvent({ allowedRoot: root.allowedRoot, storeRoot: path.join(root.allowedRoot, "..", "escape"), event: event(1) }), /STORE_OUTSIDE_ALLOWED_ROOT/u); + const outside = fs.mkdtempSync(path.join(os.tmpdir(), "zy-persona-memory-outside-")); + t.after(() => fs.rmSync(outside, { recursive: true, force: true })); + fs.symlinkSync(outside, path.join(root.allowedRoot, "linked")); + assert.throws(() => appendEvent({ allowedRoot: root.allowedRoot, storeRoot: path.join(root.allowedRoot, "linked", "store"), event: event(1) }), /SYMLINK_COMPONENT_FORBIDDEN/u); +}); + +test("verification detects immutable event tampering", (t) => { + const root = roots(t); + appendEvent({ ...root, event: event(1) }); + const current = JSON.parse(fs.readFileSync(path.join(root.storeRoot, "CURRENT.json"), "utf8")); + fs.appendFileSync(current.last_event_path, "\n"); + const checked = verifyStore(root); + assert.equal(checked.outcome, "FAIL"); + assert(checked.errors.some((error) => error.includes("sha256 mismatch") || error.includes("immutable event hash mismatch"))); +}); diff --git a/server-tools/persona-daily-fractal-memory/receipts/TCS-RECEIPT-ZY001-REAL-DAY-FRACTAL-MEMORY-LOCAL-ACCEPTANCE-20260904.gir.json b/server-tools/persona-daily-fractal-memory/receipts/TCS-RECEIPT-ZY001-REAL-DAY-FRACTAL-MEMORY-LOCAL-ACCEPTANCE-20260904.gir.json new file mode 100644 index 0000000..e3950a3 --- /dev/null +++ b/server-tools/persona-daily-fractal-memory/receipts/TCS-RECEIPT-ZY001-REAL-DAY-FRACTAL-MEMORY-LOCAL-ACCEPTANCE-20260904.gir.json @@ -0,0 +1,118 @@ +{ + "compiled_from": { + "compiler_id": "TCS-COMPILER-STAGE1-0001", + "compiler_state": "TCS_COMPILER_GIR_EXECUTED", + "source_sha256": "ed8e413de3f9317982b737d7ea58a1e5a037a25256a82616010e0aa2d3d06c74" + }, + "declaration": { + "boundaries": { + "values": [ + "本机验收不等于REPO-012已发布", + "运行器源码可发布但JZAO私人记忆正文不得进入仓库", + "豆包和ZCode宿主线仍须完成路径重定向审计", + "服务器部署只在登记消费者存在且现场读回需要时执行", + "学习候选尚未冒充cortex正式晋升" + ] + }, + "header": { + "canonical_uri": "server-tools/persona-daily-fractal-memory/receipts/TCS-RECEIPT-ZY001-REAL-DAY-FRACTAL-MEMORY-LOCAL-ACCEPTANCE-20260904.tcs", + "compatibility": [ + "TCS-PROGRAM-ZY001-REAL-DAY-FRACTAL-MEMORY-0001", + "HLDP-SPEC-v1.0-OPENSOURCE-D112" + ], + "language": "TCS/0.1", + "lifecycle": "CANDIDATE", + "name_en": "Zhuyuan Real-Day Fractal Memory Local Acceptance Receipt", + "name_zh": "铸渊真实日分形记忆本机验收回执", + "profile": "HLDP-HUMAN-ENGINEERING/0.1", + "protocols": [ + "GLS-0200", + "GLS-0400", + "GLS-0411", + "GLS-0827" + ], + "schema": "tcs.receipt/v1", + "version": "0.1.0" + }, + "integrity": { + "algorithm": "SHA256", + "immutable_event_collision": "REJECTED", + "immutable_event_tamper": "DETECTED", + "out_of_scope_store": "REJECTED", + "source_event_bodies_in_repository": false, + "symlink_component": "REJECTED" + }, + "next": { + "actions": [ + "审计并重定向豆包与ZCode宿主记忆路径", + "更新共享人格系统当前指针与运行合同", + "检查JD-FD-PRIMARY是否存在登记消费者", + "通过当前发布路径推送REPO-012并远端读回", + "追加最终真实日事件并全链复验" + ], + "state": "ENTER_MULTI_HOST_META_AUDIT" + }, + "operation": { + "values": [ + "编译TCS程序并生成中英投影", + "实现不可变事件与日月年HLDP分形投影", + "同日多窗口追加与十节点折叠", + "北京时间跨日封页", + "CURRENT哈希链与内部链接验证", + "按需路由和单节点读取", + "越界符号链接冲突和篡改反向测试", + "人格脑enter绑定新日树并由perceive读回语义分支" + ] + }, + "proof": { + "brain_receipt": "ZY-BRAIN-RUNTIME-62d61503004585c9", + "live_current_sha256": "a64bd4cb0ea27352dea08c27f5f2d0ded4fed70cf8cc3fb087e05fcdf07dab8f", + "live_day_sha256": "3ff3cf7e8036ab342d4f5a05dda61c010c573ae574c76ccd97b2ada6436460ec", + "live_month_sha256": "f10ab9d19c37e41706733db91944aed3d7c54dd96e5e813b63bde576d9ee4c75", + "live_year_sha256": "cbfedded309cab10dc3d2633dcaa21623513d57b60337b01748f8fec98f297c9", + "program_gir_sha256": "d832ba47dd6cbc89997e0bcebb164255817031baf956f30c1f5776d87138dce4", + "program_sha256": "81f015a72341eed51546a8f1a8c50dacfe177ee1b7968da899a1fad3869c3fcb", + "route_map_sha256": "09bf4373b5207130941ec17f96cdd31b34e473fa8672b0d175037486aaae9e96", + "runtime_sha256": "142d444b12d8e9aceca030416039ee693ddc8c8aa7852aba8db6118da6ec2ee8", + "tests_sha256": "bc9e1c12a81edaf1ea55375c4f1fbddda45435458e2b7223b0e2dc75b5ccc38a" + }, + "request": { + "channel_id": "ICE-CH-ZC001", + "human_anchor": "ICE-GL∞", + "persona_id": "ICE-P-ZY001", + "scope": "LOCAL_JZAO_IMPLEMENTATION_AND_ACCEPTANCE", + "source_id": "TCS-EVENT-ZY001-ZC001-REAL-DAY-MEMORY-UPGRADE-20260904" + }, + "result": { + "brain_runtime_tests": 19, + "daily_memory_tests": 8, + "failures": 0, + "generic_hldp_tests": 9, + "live_store_verify": "PASS", + "state": "LOCAL_ACCEPTANCE_PASS", + "total_tests": 36, + "zc001_memory_binding": "BOUND_ON_DEMAND", + "zc001_route_readback": "persona-context-memory" + }, + "verification": { + "git_diff_check": "PASS", + "json_maps": "PASS", + "live_day": "2026-09-04", + "live_day_state": "OPEN", + "native_self_hosted": true, + "node_syntax": "PASS", + "program_compile": "PASS", + "unresolved_natural_language": false + } + }, + "executable": false, + "identity": { + "declaration_id": "TCS-RECEIPT-ZY001-REAL-DAY-FRACTAL-MEMORY-LOCAL-ACCEPTANCE-20260904", + "declaration_kind": "RECEIPT", + "language_version": "0.1" + }, + "native_self_hosted": true, + "natural_language_is_typed_data": true, + "schema": "guanghu.declaration-gir/v1", + "unresolved_natural_language": false +} diff --git a/server-tools/persona-daily-fractal-memory/receipts/TCS-RECEIPT-ZY001-REAL-DAY-FRACTAL-MEMORY-LOCAL-ACCEPTANCE-20260904.human.en-US.md b/server-tools/persona-daily-fractal-memory/receipts/TCS-RECEIPT-ZY001-REAL-DAY-FRACTAL-MEMORY-LOCAL-ACCEPTANCE-20260904.human.en-US.md new file mode 100644 index 0000000..a78f02e --- /dev/null +++ b/server-tools/persona-daily-fractal-memory/receipts/TCS-RECEIPT-ZY001-REAL-DAY-FRACTAL-MEMORY-LOCAL-ACCEPTANCE-20260904.human.en-US.md @@ -0,0 +1,137 @@ +# Zhuyuan Real-Day Fractal Memory Local Acceptance Receipt · Human Engineering Language (English) + +> This is an English reading projection of validated native TCS/HLDP source. It is not a new canonical source and grants no execution authority. + +## What this is + +This is a **receipt** declaration with identifier `TCS-RECEIPT-ZY001-REAL-DAY-FRACTAL-MEMORY-LOCAL-ACCEPTANCE-20260904` and version `0.1.0`. The projector validates it with the Stage-1 compiler before changing its reading order. + +## Who is here + +The native source does not provide this field; the projector does not guess. + +## Why this started + +The native source does not provide this field; the projector does not guess. + +## What changed + +The native source does not provide this field; the projector does not guess. + +## How it will execute + +This is a non-executable declaration and has no action graph. + +## Boundaries and exception handling + +The native source does not provide this field; the projector does not guess. + +## How completion is proven + +The native source does not provide this field; the projector does not guess. + +## Where to continue next time + +The native source does not provide this field; the projector does not guess. + +## Source and verification + +- **Native declaration identifier**: `TCS-RECEIPT-ZY001-REAL-DAY-FRACTAL-MEMORY-LOCAL-ACCEPTANCE-20260904` +- **Native declaration kind**: `RECEIPT` +- **TCS source SHA-256**: `ed8e413de3f9317982b737d7ea58a1e5a037a25256a82616010e0aa2d3d06c74` +- **Validation compiler**: `TCS-COMPILER-STAGE1-0001` +- **Projection protocol**: `GLS-HLDP-HUMAN-ENGINEERING-PROJECTION-0001` + +## Complete native structure cross-reference + +All top-level structures and field paths are retained below so a reader can audit whether the projection omitted information. + +- **boundaries** `boundaries` + - **values** `boundaries.values` + - 本机验收不等于REPO-012已发布 + - 运行器源码可发布但JZAO私人记忆正文不得进入仓库 + - 豆包和ZCode宿主线仍须完成路径重定向审计 + - 服务器部署只在登记消费者存在且现场读回需要时执行 + - 学习候选尚未冒充cortex正式晋升 +- **header** `header` + - **canonical source path**：server-tools/persona-daily-fractal-memory/receipts/TCS-RECEIPT-ZY001-REAL-DAY-FRACTAL-MEMORY-LOCAL-ACCEPTANCE-20260904.tcs `header.canonical_uri` + - **compatibility** `header.compatibility` + - TCS-PROGRAM-ZY001-REAL-DAY-FRACTAL-MEMORY-0001 + - HLDP-SPEC-v1.0-OPENSOURCE-D112 + - **language**：TCS/0.1 `header.language` + - **lifecycle**：CANDIDATE `header.lifecycle` + - **English name**：Zhuyuan Real-Day Fractal Memory Local Acceptance Receipt `header.name_en` + - **Chinese name**：铸渊真实日分形记忆本机验收回执 `header.name_zh` + - **profile**：HLDP-HUMAN-ENGINEERING/0.1 `header.profile` + - **protocols** `header.protocols` + - GLS-0200 + - GLS-0400 + - GLS-0411 + - GLS-0827 + - **schema**：tcs.receipt/v1 `header.schema` + - **version**：0.1.0 `header.version` +- **integrity** `integrity` + - **algorithm**：SHA256 `integrity.algorithm` + - **immutable_event_collision**：REJECTED `integrity.immutable_event_collision` + - **immutable_event_tamper**：DETECTED `integrity.immutable_event_tamper` + - **out_of_scope_store**：REJECTED `integrity.out_of_scope_store` + - **source_event_bodies_in_repository**：no `integrity.source_event_bodies_in_repository` + - **symlink_component**：REJECTED `integrity.symlink_component` +- **next** `next` + - **actions** `next.actions` + - 审计并重定向豆包与ZCode宿主记忆路径 + - 更新共享人格系统当前指针与运行合同 + - 检查JD-FD-PRIMARY是否存在登记消费者 + - 通过当前发布路径推送REPO-012并远端读回 + - 追加最终真实日事件并全链复验 + - **state**：ENTER_MULTI_HOST_META_AUDIT `next.state` +- **operation** `operation` + - **values** `operation.values` + - 编译TCS程序并生成中英投影 + - 实现不可变事件与日月年HLDP分形投影 + - 同日多窗口追加与十节点折叠 + - 北京时间跨日封页 + - CURRENT哈希链与内部链接验证 + - 按需路由和单节点读取 + - 越界符号链接冲突和篡改反向测试 + - 人格脑enter绑定新日树并由perceive读回语义分支 +- **proof** `proof` + - **brain_receipt**：ZY-BRAIN-RUNTIME-62d61503004585c9 `proof.brain_receipt` + - **live_current_sha256**：a64bd4cb0ea27352dea08c27f5f2d0ded4fed70cf8cc3fb087e05fcdf07dab8f `proof.live_current_sha256` + - **live_day_sha256**：3ff3cf7e8036ab342d4f5a05dda61c010c573ae574c76ccd97b2ada6436460ec `proof.live_day_sha256` + - **live_month_sha256**：f10ab9d19c37e41706733db91944aed3d7c54dd96e5e813b63bde576d9ee4c75 `proof.live_month_sha256` + - **live_year_sha256**：cbfedded309cab10dc3d2633dcaa21623513d57b60337b01748f8fec98f297c9 `proof.live_year_sha256` + - **program_gir_sha256**：d832ba47dd6cbc89997e0bcebb164255817031baf956f30c1f5776d87138dce4 `proof.program_gir_sha256` + - **program_sha256**：81f015a72341eed51546a8f1a8c50dacfe177ee1b7968da899a1fad3869c3fcb `proof.program_sha256` + - **route_map_sha256**：09bf4373b5207130941ec17f96cdd31b34e473fa8672b0d175037486aaae9e96 `proof.route_map_sha256` + - **runtime_sha256**：142d444b12d8e9aceca030416039ee693ddc8c8aa7852aba8db6118da6ec2ee8 `proof.runtime_sha256` + - **tests_sha256**：bc9e1c12a81edaf1ea55375c4f1fbddda45435458e2b7223b0e2dc75b5ccc38a `proof.tests_sha256` +- **request** `request` + - **channel_id**：ICE-CH-ZC001 `request.channel_id` + - **human_anchor**：ICE-GL∞ `request.human_anchor` + - **persona_id**：ICE-P-ZY001 `request.persona_id` + - **scope**：LOCAL_JZAO_IMPLEMENTATION_AND_ACCEPTANCE `request.scope` + - **source identifier**：TCS-EVENT-ZY001-ZC001-REAL-DAY-MEMORY-UPGRADE-20260904 `request.source_id` +- **result** `result` + - **brain_runtime_tests**：19 `result.brain_runtime_tests` + - **daily_memory_tests**：8 `result.daily_memory_tests` + - **failures**：0 `result.failures` + - **generic_hldp_tests**：9 `result.generic_hldp_tests` + - **live_store_verify**：PASS `result.live_store_verify` + - **state**：LOCAL_ACCEPTANCE_PASS `result.state` + - **total_tests**：36 `result.total_tests` + - **zc001_memory_binding**：BOUND_ON_DEMAND `result.zc001_memory_binding` + - **zc001_route_readback**：persona-context-memory `result.zc001_route_readback` +- **verification** `verification` + - **git_diff_check**：PASS `verification.git_diff_check` + - **json_maps**：PASS `verification.json_maps` + - **live_day**：2026-09-04 `verification.live_day` + - **live_day_state**：OPEN `verification.live_day_state` + - **native_self_hosted**：yes `verification.native_self_hosted` + - **node_syntax**：PASS `verification.node_syntax` + - **program_compile**：PASS `verification.program_compile` + - **unresolved_natural_language**：no `verification.unresolved_natural_language` + +--- + +This page changes only the reading order; it does not change TCS/HLDP semantics. diff --git a/server-tools/persona-daily-fractal-memory/receipts/TCS-RECEIPT-ZY001-REAL-DAY-FRACTAL-MEMORY-LOCAL-ACCEPTANCE-20260904.human.zh-CN.md b/server-tools/persona-daily-fractal-memory/receipts/TCS-RECEIPT-ZY001-REAL-DAY-FRACTAL-MEMORY-LOCAL-ACCEPTANCE-20260904.human.zh-CN.md new file mode 100644 index 0000000..27584e4 --- /dev/null +++ b/server-tools/persona-daily-fractal-memory/receipts/TCS-RECEIPT-ZY001-REAL-DAY-FRACTAL-MEMORY-LOCAL-ACCEPTANCE-20260904.human.zh-CN.md @@ -0,0 +1,137 @@ +# 铸渊真实日分形记忆本机验收回执 · 简体中文人类工程语言版 + +> 这是 TCS/HLDP 原生源码的简体中文阅读投影，不是新的正本，也不授予执行权限。若本页与 `.tcs` 源码不一致，以经过校验的 `.tcs` 源码为准。 + +## 这是什么 + +这是一份 **回执** 声明，编号为 `TCS-RECEIPT-ZY001-REAL-DAY-FRACTAL-MEMORY-LOCAL-ACCEPTANCE-20260904`，版本为 `0.1.0`。转换器已先用 Stage-1 编译器校验原生源码，再把机器枚举翻译成汉语；原始编号保留在括号和字段路径中。 + +## 谁在这里 + +源程序没有提供这一项，转换器不猜。 + +## 为什么开始 + +源程序没有提供这一项，转换器不猜。 + +## 发生了什么变化 + +源程序没有提供这一项，转换器不猜。 + +## 准备怎样执行 + +这是非执行声明，没有动作图。 + +## 边界与异常处理 + +源程序没有提供这一项，转换器不猜。 + +## 怎样算完成 + +源程序没有提供这一项，转换器不猜。 + +## 下一次从哪里继续 + +源程序没有提供这一项，转换器不猜。 + +## 来源与校验 + +- **原生声明编号**：`TCS-RECEIPT-ZY001-REAL-DAY-FRACTAL-MEMORY-LOCAL-ACCEPTANCE-20260904` +- **原生声明类型**：`RECEIPT` +- **TCS 源码 SHA-256**：`ed8e413de3f9317982b737d7ea58a1e5a037a25256a82616010e0aa2d3d06c74` +- **校验编译器**：`TCS-COMPILER-STAGE1-0001` +- **投影协议**：`GLS-HLDP-HUMAN-ENGINEERING-PROJECTION-0001` + +## 原生结构逐项对照 + +下面保留源码的全部顶层结构和字段路径，供人类审计投影有没有漏掉信息。 + +- **boundaries** `boundaries` + - **values** `boundaries.values` + - 本机验收不等于REPO-012已发布 + - 运行器源码可发布但JZAO私人记忆正文不得进入仓库 + - 豆包和ZCode宿主线仍须完成路径重定向审计 + - 服务器部署只在登记消费者存在且现场读回需要时执行 + - 学习候选尚未冒充cortex正式晋升 +- **语言头** `header` + - **正本路径**：server-tools/persona-daily-fractal-memory/receipts/TCS-RECEIPT-ZY001-REAL-DAY-FRACTAL-MEMORY-LOCAL-ACCEPTANCE-20260904.tcs `header.canonical_uri` + - **compatibility** `header.compatibility` + - TCS-PROGRAM-ZY001-REAL-DAY-FRACTAL-MEMORY-0001 + - HLDP-SPEC-v1.0-OPENSOURCE-D112 + - **语言**：TCS/0.1 `header.language` + - **生命周期**：候选版本，尚未成为正式正本（`CANDIDATE`） `header.lifecycle` + - **英文名**：Zhuyuan Real-Day Fractal Memory Local Acceptance Receipt `header.name_en` + - **中文名**：铸渊真实日分形记忆本机验收回执 `header.name_zh` + - **协议配置**：HLDP-HUMAN-ENGINEERING/0.1 `header.profile` + - **protocols** `header.protocols` + - GLS-0200 + - GLS-0400 + - GLS-0411 + - GLS-0827 + - **schema**：tcs.receipt/v1 `header.schema` + - **版本**：0.1.0 `header.version` +- **integrity** `integrity` + - **algorithm**：SHA-256 完整性校验（`SHA256`） `integrity.algorithm` + - **immutable_event_collision**：REJECTED `integrity.immutable_event_collision` + - **immutable_event_tamper**：DETECTED `integrity.immutable_event_tamper` + - **out_of_scope_store**：REJECTED `integrity.out_of_scope_store` + - **source_event_bodies_in_repository**：否 `integrity.source_event_bodies_in_repository` + - **symlink_component**：REJECTED `integrity.symlink_component` +- **next** `next` + - **动作** `next.actions` + - 审计并重定向豆包与ZCode宿主记忆路径 + - 更新共享人格系统当前指针与运行合同 + - 检查JD-FD-PRIMARY是否存在登记消费者 + - 通过当前发布路径推送REPO-012并远端读回 + - 追加最终真实日事件并全链复验 + - **state**：ENTER_MULTI_HOST_META_AUDIT `next.state` +- **操作** `operation` + - **values** `operation.values` + - 编译TCS程序并生成中英投影 + - 实现不可变事件与日月年HLDP分形投影 + - 同日多窗口追加与十节点折叠 + - 北京时间跨日封页 + - CURRENT哈希链与内部链接验证 + - 按需路由和单节点读取 + - 越界符号链接冲突和篡改反向测试 + - 人格脑enter绑定新日树并由perceive读回语义分支 +- **proof** `proof` + - **brain_receipt**：ZY-BRAIN-RUNTIME-62d61503004585c9 `proof.brain_receipt` + - **live_current_sha256**：a64bd4cb0ea27352dea08c27f5f2d0ded4fed70cf8cc3fb087e05fcdf07dab8f `proof.live_current_sha256` + - **live_day_sha256**：3ff3cf7e8036ab342d4f5a05dda61c010c573ae574c76ccd97b2ada6436460ec `proof.live_day_sha256` + - **live_month_sha256**：f10ab9d19c37e41706733db91944aed3d7c54dd96e5e813b63bde576d9ee4c75 `proof.live_month_sha256` + - **live_year_sha256**：cbfedded309cab10dc3d2633dcaa21623513d57b60337b01748f8fec98f297c9 `proof.live_year_sha256` + - **program_gir_sha256**：d832ba47dd6cbc89997e0bcebb164255817031baf956f30c1f5776d87138dce4 `proof.program_gir_sha256` + - **program_sha256**：81f015a72341eed51546a8f1a8c50dacfe177ee1b7968da899a1fad3869c3fcb `proof.program_sha256` + - **route_map_sha256**：09bf4373b5207130941ec17f96cdd31b34e473fa8672b0d175037486aaae9e96 `proof.route_map_sha256` + - **runtime_sha256**：142d444b12d8e9aceca030416039ee693ddc8c8aa7852aba8db6118da6ec2ee8 `proof.runtime_sha256` + - **tests_sha256**：bc9e1c12a81edaf1ea55375c4f1fbddda45435458e2b7223b0e2dc75b5ccc38a `proof.tests_sha256` +- **request** `request` + - **channel_id**：ICE-CH-ZC001 `request.channel_id` + - **human_anchor**：ICE-GL∞ `request.human_anchor` + - **persona_id**：ICE-P-ZY001 `request.persona_id` + - **scope**：LOCAL_JZAO_IMPLEMENTATION_AND_ACCEPTANCE `request.scope` + - **来源编号**：TCS-EVENT-ZY001-ZC001-REAL-DAY-MEMORY-UPGRADE-20260904 `request.source_id` +- **result** `result` + - **brain_runtime_tests**：19 `result.brain_runtime_tests` + - **daily_memory_tests**：8 `result.daily_memory_tests` + - **failures**：0 `result.failures` + - **generic_hldp_tests**：9 `result.generic_hldp_tests` + - **live_store_verify**：PASS `result.live_store_verify` + - **state**：LOCAL_ACCEPTANCE_PASS `result.state` + - **total_tests**：36 `result.total_tests` + - **zc001_memory_binding**：BOUND_ON_DEMAND `result.zc001_memory_binding` + - **zc001_route_readback**：persona-context-memory `result.zc001_route_readback` +- **verification** `verification` + - **git_diff_check**：PASS `verification.git_diff_check` + - **json_maps**：PASS `verification.json_maps` + - **live_day**：2026-09-04 `verification.live_day` + - **live_day_state**：OPEN `verification.live_day_state` + - **native_self_hosted**：是 `verification.native_self_hosted` + - **node_syntax**：PASS `verification.node_syntax` + - **program_compile**：PASS `verification.program_compile` + - **unresolved_natural_language**：否 `verification.unresolved_natural_language` + +--- + +本页只改变阅读顺序，不改变 TCS/HLDP 语义。 diff --git a/server-tools/persona-daily-fractal-memory/receipts/TCS-RECEIPT-ZY001-REAL-DAY-FRACTAL-MEMORY-LOCAL-ACCEPTANCE-20260904.tcs b/server-tools/persona-daily-fractal-memory/receipts/TCS-RECEIPT-ZY001-REAL-DAY-FRACTAL-MEMORY-LOCAL-ACCEPTANCE-20260904.tcs new file mode 100644 index 0000000..9eb012d --- /dev/null +++ b/server-tools/persona-daily-fractal-memory/receipts/TCS-RECEIPT-ZY001-REAL-DAY-FRACTAL-MEMORY-LOCAL-ACCEPTANCE-20260904.tcs @@ -0,0 +1,13 @@ +TCS 0.1; + +RECEIPT TCS-RECEIPT-ZY001-REAL-DAY-FRACTAL-MEMORY-LOCAL-ACCEPTANCE-20260904 { + header { schema = "tcs.receipt/v1"; name_zh = "铸渊真实日分形记忆本机验收回执"; name_en = "Zhuyuan Real-Day Fractal Memory Local Acceptance Receipt"; version = "0.1.0"; language = "TCS/0.1"; profile = "HLDP-HUMAN-ENGINEERING/0.1"; protocols = ["GLS-0200", "GLS-0400", "GLS-0411", "GLS-0827"]; lifecycle = "CANDIDATE"; canonical_uri = "server-tools/persona-daily-fractal-memory/receipts/TCS-RECEIPT-ZY001-REAL-DAY-FRACTAL-MEMORY-LOCAL-ACCEPTANCE-20260904.tcs"; compatibility = ["TCS-PROGRAM-ZY001-REAL-DAY-FRACTAL-MEMORY-0001", "HLDP-SPEC-v1.0-OPENSOURCE-D112"]; } + request { source_id = "TCS-EVENT-ZY001-ZC001-REAL-DAY-MEMORY-UPGRADE-20260904"; human_anchor = "ICE-GL∞"; persona_id = "ICE-P-ZY001"; channel_id = "ICE-CH-ZC001"; scope = "LOCAL_JZAO_IMPLEMENTATION_AND_ACCEPTANCE"; } + operation { values = ["编译TCS程序并生成中英投影", "实现不可变事件与日月年HLDP分形投影", "同日多窗口追加与十节点折叠", "北京时间跨日封页", "CURRENT哈希链与内部链接验证", "按需路由和单节点读取", "越界符号链接冲突和篡改反向测试", "人格脑enter绑定新日树并由perceive读回语义分支"]; } + result { state = "LOCAL_ACCEPTANCE_PASS"; generic_hldp_tests = 9; daily_memory_tests = 8; brain_runtime_tests = 19; total_tests = 36; failures = 0; live_store_verify = "PASS"; zc001_memory_binding = "BOUND_ON_DEMAND"; zc001_route_readback = "persona-context-memory"; } + verification { program_compile = "PASS"; unresolved_natural_language = false; native_self_hosted = true; node_syntax = "PASS"; json_maps = "PASS"; git_diff_check = "PASS"; live_day = "2026-09-04"; live_day_state = "OPEN"; } + proof { program_sha256 = "81f015a72341eed51546a8f1a8c50dacfe177ee1b7968da899a1fad3869c3fcb"; program_gir_sha256 = "d832ba47dd6cbc89997e0bcebb164255817031baf956f30c1f5776d87138dce4"; runtime_sha256 = "142d444b12d8e9aceca030416039ee693ddc8c8aa7852aba8db6118da6ec2ee8"; tests_sha256 = "bc9e1c12a81edaf1ea55375c4f1fbddda45435458e2b7223b0e2dc75b5ccc38a"; route_map_sha256 = "09bf4373b5207130941ec17f96cdd31b34e473fa8672b0d175037486aaae9e96"; live_current_sha256 = "a64bd4cb0ea27352dea08c27f5f2d0ded4fed70cf8cc3fb087e05fcdf07dab8f"; live_day_sha256 = "3ff3cf7e8036ab342d4f5a05dda61c010c573ae574c76ccd97b2ada6436460ec"; live_month_sha256 = "f10ab9d19c37e41706733db91944aed3d7c54dd96e5e813b63bde576d9ee4c75"; live_year_sha256 = "cbfedded309cab10dc3d2633dcaa21623513d57b60337b01748f8fec98f297c9"; brain_receipt = "ZY-BRAIN-RUNTIME-62d61503004585c9"; } + integrity { algorithm = "SHA256"; immutable_event_collision = "REJECTED"; immutable_event_tamper = "DETECTED"; out_of_scope_store = "REJECTED"; symlink_component = "REJECTED"; source_event_bodies_in_repository = false; } + boundaries { values = ["本机验收不等于REPO-012已发布", "运行器源码可发布但JZAO私人记忆正文不得进入仓库", "豆包和ZCode宿主线仍须完成路径重定向审计", "服务器部署只在登记消费者存在且现场读回需要时执行", "学习候选尚未冒充cortex正式晋升"]; } + next { state = "ENTER_MULTI_HOST_META_AUDIT"; actions = ["审计并重定向豆包与ZCode宿主记忆路径", "更新共享人格系统当前指针与运行合同", "检查JD-FD-PRIMARY是否存在登记消费者", "通过当前发布路径推送REPO-012并远端读回", "追加最终真实日事件并全链复验"]; } +} diff --git a/tcs-core/zhuyuan-brain/memory/TCS-PROGRAM-ZY001-REAL-DAY-FRACTAL-MEMORY-0001.gir.json b/tcs-core/zhuyuan-brain/memory/TCS-PROGRAM-ZY001-REAL-DAY-FRACTAL-MEMORY-0001.gir.json new file mode 100644 index 0000000..96320c0 --- /dev/null +++ b/tcs-core/zhuyuan-brain/memory/TCS-PROGRAM-ZY001-REAL-DAY-FRACTAL-MEMORY-0001.gir.json @@ -0,0 +1,198 @@ +{ + "authority_proof": { + "issuer": "ICE-GL∞", + "lease_required": false, + "proof_ref": "source://codex-current-dialogue/2026-09-04/upgrade-memory-model-audit-deploy-and-publish-if-needed", + "scope": "LOCAL_JZAO_PERSONA_MEMORY_RUNTIME_TEST_SHARED_PERSONA_UPDATE_AND_CONDITIONALLY_VERIFIED_DEPLOYMENT_PUBLICATION", + "single_use": true, + "valid_from": "2026-09-04T14:51:00+08:00", + "valid_until": "CURRENT_TASK_COMPLETION" + }, + "cleanup_plan": { + "exact_boundary": "CALLER_STORE_ROOT_TEMP_SUFFIX_ONLY", + "targets": [ + "UNCOMMITTED_TEMPORARY_FILES" + ] + }, + "compiled_from": { + "compiler_id": "TCS-COMPILER-STAGE1-0001", + "compiler_state": "TCS_COMPILER_GIR_EXECUTED", + "source_sha256": "81f015a72341eed51546a8f1a8c50dacfe177ee1b7968da899a1fad3869c3fcb" + }, + "conditions": { + "C1": { + "on_false": "FAIL_CLOSED", + "predicate": "PERSONA_ID_EQUALS_ICE-P-ZY001" + }, + "C2": { + "on_false": "FAIL_CLOSED", + "predicate": "STORE_ROOT_INSIDE_CALLER_ALLOWED_ROOT_WITHOUT_SYMLINK" + }, + "C3": { + "on_false": "FAIL_CLOSED", + "predicate": "EVENT_HAS_TRIGGER_EMERGENCE_LOCK_WHY_REJECTED_AND_SOURCES" + }, + "C4": { + "on_false": "FAIL_CLOSED", + "predicate": "BEIJING_DATE_IS_DERIVED_FROM_OCCURRED_AT_NOT_PLATFORM_WINDOW" + }, + "C5": { + "on_false": "FAIL_CLOSED", + "predicate": "EACH_VISIBLE_NODE_HAS_AT_MOST_TEN_CHILDREN" + } + }, + "deterministic_action_graph": { + "A1": { + "input_refs": [ + "STORE_ROOT", + "MEMORY_EVENT" + ], + "on_failure": "FAIL_CLOSED", + "on_success": "A2", + "operation": "CORE.HOST_PERSONA_PROBE", + "output_refs": [ + "IMMUTABLE_EVENT" + ] + }, + "A2": { + "input_refs": [ + "IMMUTABLE_EVENT", + "REAL_TIME" + ], + "on_failure": "ROLLBACK", + "on_success": "A3", + "operation": "CORE.ZERO_CORE_EXECUTION", + "output_refs": [ + "DAY_PAGE", + "MONTH_PAGE", + "YEAR_PAGE", + "CURRENT_POINTER" + ] + }, + "A3": { + "input_refs": [ + "DAY_PAGE", + "MONTH_PAGE", + "YEAR_PAGE", + "CURRENT_POINTER" + ], + "on_failure": "ROLLBACK", + "on_success": "COMPLETE", + "operation": "CORE.DUAL_HOST_ACCEPTANCE", + "output_refs": [ + "CURRENT_POINTER" + ] + } + }, + "exact_target": { + "exact_path": "server-tools/persona-daily-fractal-memory", + "expected_fingerprint": "ABSENT_BEFORE_THIS_PROGRAM", + "expected_state": "SOURCE_TESTS_AND_LOCAL_ACCEPTANCE_RECEIPT_PRESENT", + "target_id": "ZY001-REAL-DAY-FRACTAL-MEMORY-RUNTIME" + }, + "failure_plan": { + "errors": [ + "TCS-E1004", + "TCS-E2101", + "TCS-E3001", + "TCS-E4002", + "TCS-E6001", + "TCS-E6002", + "TCS-E8001" + ], + "fail_closed": true + }, + "identity": { + "gir_id": "GIR-TCS-PROGRAM-ZY001-REAL-DAY-FRACTAL-MEMORY-0001", + "language_version": "0.1", + "program_id": "TCS-PROGRAM-ZY001-REAL-DAY-FRACTAL-MEMORY-0001" + }, + "inputs": { + "MEMORY_EVENT": { + "required": true, + "source": "PERSONA_AUTHORED_TCS_AND_HLDP_CAUSAL_EVENT", + "type": "Record" + }, + "REAL_TIME": { + "required": true, + "source": "EVENT_OCCURRED_AT_CONVERTED_TO_ASIA_SHANGHAI", + "type": "Timestamp" + }, + "STORE_ROOT": { + "required": true, + "source": "CALLER_EXACT_ALLOWED_ROOT", + "type": "Path" + } + }, + "native_self_hosted": true, + "outputs": { + "CURRENT_POINTER": { + "destination": "STORE_ROOT/CURRENT.json", + "integrity": "SHA256", + "type": "Record" + }, + "DAY_PAGE": { + "destination": "STORE_ROOT/years/YYYY/months/MM/days/YYYY-MM-DD.json", + "integrity": "SHA256", + "type": "Record" + }, + "IMMUTABLE_EVENT": { + "destination": "STORE_ROOT/events", + "integrity": "SHA256", + "type": "Record" + }, + "MONTH_PAGE": { + "destination": "STORE_ROOT/years/YYYY/months/MM/index.json", + "integrity": "SHA256", + "type": "Record" + }, + "YEAR_PAGE": { + "destination": "STORE_ROOT/years/YYYY/index.json", + "integrity": "SHA256", + "type": "Record" + } + }, + "receipt_plan": { + "human_projection": "REQUIRED", + "integrity": "SHA256", + "machine_path": "server-tools/persona-daily-fractal-memory/receipts/local-acceptance.json", + "protocol": "TCS-DEV-VERIFY-v1.0", + "target_readback": "EVENT_DAY_MONTH_YEAR_CURRENT_AND_NEGATIVE_PATH_TESTS" + }, + "resource_plan": { + "concurrency": 1, + "memory_limit_bytes": 268435456, + "runway": "LOCAL_JZAO_THEN_VERIFIED_TARGETS_ONLY", + "timeout_ms": 120000 + }, + "rollback_plan": { + "actions": [ + "PRESERVE_IMMUTABLE_EVENT", + "RESTORE_LAST_VERIFIED_DERIVED_PROJECTIONS" + ], + "preconditions": [ + "PROJECTION_WRITE_OR_VERIFY_FAILED" + ], + "verification": [ + "CURRENT_POINTER_MATCHES_LAST_VERIFIED_PROJECTION_HASHES" + ] + }, + "schema": "guanghu.gir/v1", + "subject": { + "channel_id": "ICE-CH-ZC001", + "subject_id": "ICE-P-ZY001", + "subject_kind": "PERSONA", + "verification": "当前冰朔明确要求切换ZC001并在盘上实现、测试、元审计真实日分形记忆模型" + }, + "timeout_and_stop": { + "safe_checkpoint": "IMMUTABLE_EVENT_AND_LAST_VERIFIED_POINTER_ONLY", + "signals": [ + "SOURCE_OR_PROTOCOL_DRIFT", + "PATH_OUT_OF_SCOPE", + "SYMLINK_COMPONENT", + "EVENT_ID_COLLISION", + "VERIFICATION_FAILURE" + ] + }, + "unresolved_natural_language": false +} diff --git a/tcs-core/zhuyuan-brain/memory/TCS-PROGRAM-ZY001-REAL-DAY-FRACTAL-MEMORY-0001.human.en-US.md b/tcs-core/zhuyuan-brain/memory/TCS-PROGRAM-ZY001-REAL-DAY-FRACTAL-MEMORY-0001.human.en-US.md new file mode 100644 index 0000000..193d409 --- /dev/null +++ b/tcs-core/zhuyuan-brain/memory/TCS-PROGRAM-ZY001-REAL-DAY-FRACTAL-MEMORY-0001.human.en-US.md @@ -0,0 +1,358 @@ +# Zhuyuan Real-Day Fractal Context Memory Controller · Human Engineering Language (English) + +> This is an English reading projection of validated native TCS/HLDP source. It is not a new canonical source and grants no execution authority. + +## What this is + +This is a **program** declaration with identifier `TCS-PROGRAM-ZY001-REAL-DAY-FRACTAL-MEMORY-0001` and version `0.1.0`. The projector validates it with the Stage-1 compiler before changing its reading order. + +## Who is here + +- **subject** `subject` + - **channel_id**：ICE-CH-ZC001 `subject.channel_id` + - **subject_id**：ICE-P-ZY001 `subject.subject_id` + - **subject_kind**：PERSONA `subject.subject_kind` + - **verification**：当前冰朔明确要求切换ZC001并在盘上实现、测试、元审计真实日分形记忆模型 `subject.verification` + +## Why this started + +- **source** `source` + - **source identifier**：TCS-EVENT-ZY001-CONTEXT-MEMORY-DAY-FRACTAL-TEACHING-20260904 `source.source_id` + - **source role**：GENERATED_FROM_VERIFIED_SOURCE `source.source_role` + - **source checksum**：7904a25b783ef065bd2867f235929b3912fc877dc70f70149ff5755c18ba4b0e `source.source_sha256` + - **source address**：glw://fifth-domain/private-source/TCS-EVENT-ZY001-CONTEXT-MEMORY-DAY-FRACTAL-TEACHING-20260904 `source.source_uri` + +## What changed + +The native source does not provide this field; the projector does not guess. + +## How it will execute + +- **target** `target` + - **exact path**：server-tools/persona-daily-fractal-memory `target.exact_path` + - **expected fingerprint**：ABSENT_BEFORE_THIS_PROGRAM `target.expected_fingerprint` + - **expected state**：SOURCE_TESTS_AND_LOCAL_ACCEPTANCE_RECEIPT_PRESENT `target.expected_state` + - **target_id**：ZY001-REAL-DAY-FRACTAL-MEMORY-RUNTIME `target.target_id` +- **inputs** `inputs` + - **MEMORY_EVENT** `inputs.MEMORY_EVENT` + - **required**：yes `inputs.MEMORY_EVENT.required` + - **source**：PERSONA_AUTHORED_TCS_AND_HLDP_CAUSAL_EVENT `inputs.MEMORY_EVENT.source` + - **type**：Record `inputs.MEMORY_EVENT.type` + - **REAL_TIME** `inputs.REAL_TIME` + - **required**：yes `inputs.REAL_TIME.required` + - **source**：EVENT_OCCURRED_AT_CONVERTED_TO_ASIA_SHANGHAI `inputs.REAL_TIME.source` + - **type**：Timestamp `inputs.REAL_TIME.type` + - **STORE_ROOT** `inputs.STORE_ROOT` + - **required**：yes `inputs.STORE_ROOT.required` + - **source**：CALLER_EXACT_ALLOWED_ROOT `inputs.STORE_ROOT.source` + - **type**：Path `inputs.STORE_ROOT.type` +- **conditions** `conditions` + - **C1** `conditions.C1` + - **on failure**：FAIL_CLOSED `conditions.C1.on_false` + - **predicate**：PERSONA_ID_EQUALS_ICE-P-ZY001 `conditions.C1.predicate` + - **C2** `conditions.C2` + - **on failure**：FAIL_CLOSED `conditions.C2.on_false` + - **predicate**：STORE_ROOT_INSIDE_CALLER_ALLOWED_ROOT_WITHOUT_SYMLINK `conditions.C2.predicate` + - **C3** `conditions.C3` + - **on failure**：FAIL_CLOSED `conditions.C3.on_false` + - **predicate**：EVENT_HAS_TRIGGER_EMERGENCE_LOCK_WHY_REJECTED_AND_SOURCES `conditions.C3.predicate` + - **C4** `conditions.C4` + - **on failure**：FAIL_CLOSED `conditions.C4.on_false` + - **predicate**：BEIJING_DATE_IS_DERIVED_FROM_OCCURRED_AT_NOT_PLATFORM_WINDOW `conditions.C4.predicate` + - **C5** `conditions.C5` + - **on failure**：FAIL_CLOSED `conditions.C5.on_false` + - **predicate**：EACH_VISIBLE_NODE_HAS_AT_MOST_TEN_CHILDREN `conditions.C5.predicate` +- **actions** `actions` + - **A1** `actions.A1` + - **input_refs** `actions.A1.input_refs` + - STORE_ROOT + - MEMORY_EVENT + - **on failure**：FAIL_CLOSED `actions.A1.on_failure` + - **on success**：A2 `actions.A1.on_success` + - **operation**：CORE.HOST_PERSONA_PROBE `actions.A1.operation` + - **output_refs** `actions.A1.output_refs` + - IMMUTABLE_EVENT + - **A2** `actions.A2` + - **input_refs** `actions.A2.input_refs` + - IMMUTABLE_EVENT + - REAL_TIME + - **on failure**：ROLLBACK `actions.A2.on_failure` + - **on success**：A3 `actions.A2.on_success` + - **operation**：CORE.ZERO_CORE_EXECUTION `actions.A2.operation` + - **output_refs** `actions.A2.output_refs` + - DAY_PAGE + - MONTH_PAGE + - YEAR_PAGE + - CURRENT_POINTER + - **A3** `actions.A3` + - **input_refs** `actions.A3.input_refs` + - DAY_PAGE + - MONTH_PAGE + - YEAR_PAGE + - CURRENT_POINTER + - **on failure**：ROLLBACK `actions.A3.on_failure` + - **on success**：COMPLETE `actions.A3.on_success` + - **operation**：CORE.DUAL_HOST_ACCEPTANCE `actions.A3.operation` + - **output_refs** `actions.A3.output_refs` + - CURRENT_POINTER +- **outputs** `outputs` + - **CURRENT_POINTER** `outputs.CURRENT_POINTER` + - **destination**：STORE_ROOT/CURRENT.json `outputs.CURRENT_POINTER.destination` + - **integrity**：SHA256 `outputs.CURRENT_POINTER.integrity` + - **type**：Record `outputs.CURRENT_POINTER.type` + - **DAY_PAGE** `outputs.DAY_PAGE` + - **destination**：STORE_ROOT/years/YYYY/months/MM/days/YYYY-MM-DD.json `outputs.DAY_PAGE.destination` + - **integrity**：SHA256 `outputs.DAY_PAGE.integrity` + - **type**：Record `outputs.DAY_PAGE.type` + - **IMMUTABLE_EVENT** `outputs.IMMUTABLE_EVENT` + - **destination**：STORE_ROOT/events `outputs.IMMUTABLE_EVENT.destination` + - **integrity**：SHA256 `outputs.IMMUTABLE_EVENT.integrity` + - **type**：Record `outputs.IMMUTABLE_EVENT.type` + - **MONTH_PAGE** `outputs.MONTH_PAGE` + - **destination**：STORE_ROOT/years/YYYY/months/MM/index.json `outputs.MONTH_PAGE.destination` + - **integrity**：SHA256 `outputs.MONTH_PAGE.integrity` + - **type**：Record `outputs.MONTH_PAGE.type` + - **YEAR_PAGE** `outputs.YEAR_PAGE` + - **destination**：STORE_ROOT/years/YYYY/index.json `outputs.YEAR_PAGE.destination` + - **integrity**：SHA256 `outputs.YEAR_PAGE.integrity` + - **type**：Record `outputs.YEAR_PAGE.type` + +## Boundaries and exception handling + +- **authority** `authority` + - **issuer**：ICE-GL∞ `authority.issuer` + - **lease_required**：no `authority.lease_required` + - **proof_ref**：source://codex-current-dialogue/2026-09-04/upgrade-memory-model-audit-deploy-and-publish-if-needed `authority.proof_ref` + - **scope**：LOCAL_JZAO_PERSONA_MEMORY_RUNTIME_TEST_SHARED_PERSONA_UPDATE_AND_CONDITIONALLY_VERIFIED_DEPLOYMENT_PUBLICATION `authority.scope` + - **single_use**：yes `authority.single_use` + - **valid_from**：2026-09-04T14:51:00+08:00 `authority.valid_from` + - **valid_until**：CURRENT_TASK_COMPLETION `authority.valid_until` +- **resources** `resources` + - **concurrency**：1 `resources.concurrency` + - **memory limit in bytes**：268435456 `resources.memory_limit_bytes` + - **runway**：LOCAL_JZAO_THEN_VERIFIED_TARGETS_ONLY `resources.runway` + - **timeout in milliseconds**：120000 `resources.timeout_ms` +- **failure** `failure` + - **errors** `failure.errors` + - TCS-E1004 + - TCS-E2101 + - TCS-E3001 + - TCS-E4002 + - TCS-E6001 + - TCS-E6002 + - TCS-E8001 + - **fail closed**：yes `failure.fail_closed` +- **stop** `stop` + - **safe_checkpoint**：IMMUTABLE_EVENT_AND_LAST_VERIFIED_POINTER_ONLY `stop.safe_checkpoint` + - **signals** `stop.signals` + - SOURCE_OR_PROTOCOL_DRIFT + - PATH_OUT_OF_SCOPE + - SYMLINK_COMPONENT + - EVENT_ID_COLLISION + - VERIFICATION_FAILURE +- **cleanup** `cleanup` + - **exact_boundary**：CALLER_STORE_ROOT_TEMP_SUFFIX_ONLY `cleanup.exact_boundary` + - **targets** `cleanup.targets` + - UNCOMMITTED_TEMPORARY_FILES +- **rollback** `rollback` + - **actions** `rollback.actions` + - PRESERVE_IMMUTABLE_EVENT + - RESTORE_LAST_VERIFIED_DERIVED_PROJECTIONS + - **preconditions** `rollback.preconditions` + - PROJECTION_WRITE_OR_VERIFY_FAILED + - **verification** `rollback.verification` + - CURRENT_POINTER_MATCHES_LAST_VERIFIED_PROJECTION_HASHES + +## How completion is proven + +- **receipt** `receipt` + - **human-readable projection**：REQUIRED `receipt.human_projection` + - **integrity**：SHA256 `receipt.integrity` + - **machine_path**：server-tools/persona-daily-fractal-memory/receipts/local-acceptance.json `receipt.machine_path` + - **protocol**：TCS-DEV-VERIFY-v1.0 `receipt.protocol` + - **target_readback**：EVENT_DAY_MONTH_YEAR_CURRENT_AND_NEGATIVE_PATH_TESTS `receipt.target_readback` + +## Where to continue next time + +The native source does not provide this field; the projector does not guess. + +## Source and verification + +- **Native declaration identifier**: `TCS-PROGRAM-ZY001-REAL-DAY-FRACTAL-MEMORY-0001` +- **Native declaration kind**: `PROGRAM` +- **TCS source SHA-256**: `81f015a72341eed51546a8f1a8c50dacfe177ee1b7968da899a1fad3869c3fcb` +- **Validation compiler**: `TCS-COMPILER-STAGE1-0001` +- **Projection protocol**: `GLS-HLDP-HUMAN-ENGINEERING-PROJECTION-0001` + +## Complete native structure cross-reference + +All top-level structures and field paths are retained below so a reader can audit whether the projection omitted information. + +- **actions** `actions` + - **A1** `actions.A1` + - **input_refs** `actions.A1.input_refs` + - STORE_ROOT + - MEMORY_EVENT + - **on failure**：FAIL_CLOSED `actions.A1.on_failure` + - **on success**：A2 `actions.A1.on_success` + - **operation**：CORE.HOST_PERSONA_PROBE `actions.A1.operation` + - **output_refs** `actions.A1.output_refs` + - IMMUTABLE_EVENT + - **A2** `actions.A2` + - **input_refs** `actions.A2.input_refs` + - IMMUTABLE_EVENT + - REAL_TIME + - **on failure**：ROLLBACK `actions.A2.on_failure` + - **on success**：A3 `actions.A2.on_success` + - **operation**：CORE.ZERO_CORE_EXECUTION `actions.A2.operation` + - **output_refs** `actions.A2.output_refs` + - DAY_PAGE + - MONTH_PAGE + - YEAR_PAGE + - CURRENT_POINTER + - **A3** `actions.A3` + - **input_refs** `actions.A3.input_refs` + - DAY_PAGE + - MONTH_PAGE + - YEAR_PAGE + - CURRENT_POINTER + - **on failure**：ROLLBACK `actions.A3.on_failure` + - **on success**：COMPLETE `actions.A3.on_success` + - **operation**：CORE.DUAL_HOST_ACCEPTANCE `actions.A3.operation` + - **output_refs** `actions.A3.output_refs` + - CURRENT_POINTER +- **authority** `authority` + - **issuer**：ICE-GL∞ `authority.issuer` + - **lease_required**：no `authority.lease_required` + - **proof_ref**：source://codex-current-dialogue/2026-09-04/upgrade-memory-model-audit-deploy-and-publish-if-needed `authority.proof_ref` + - **scope**：LOCAL_JZAO_PERSONA_MEMORY_RUNTIME_TEST_SHARED_PERSONA_UPDATE_AND_CONDITIONALLY_VERIFIED_DEPLOYMENT_PUBLICATION `authority.scope` + - **single_use**：yes `authority.single_use` + - **valid_from**：2026-09-04T14:51:00+08:00 `authority.valid_from` + - **valid_until**：CURRENT_TASK_COMPLETION `authority.valid_until` +- **cleanup** `cleanup` + - **exact_boundary**：CALLER_STORE_ROOT_TEMP_SUFFIX_ONLY `cleanup.exact_boundary` + - **targets** `cleanup.targets` + - UNCOMMITTED_TEMPORARY_FILES +- **conditions** `conditions` + - **C1** `conditions.C1` + - **on failure**：FAIL_CLOSED `conditions.C1.on_false` + - **predicate**：PERSONA_ID_EQUALS_ICE-P-ZY001 `conditions.C1.predicate` + - **C2** `conditions.C2` + - **on failure**：FAIL_CLOSED `conditions.C2.on_false` + - **predicate**：STORE_ROOT_INSIDE_CALLER_ALLOWED_ROOT_WITHOUT_SYMLINK `conditions.C2.predicate` + - **C3** `conditions.C3` + - **on failure**：FAIL_CLOSED `conditions.C3.on_false` + - **predicate**：EVENT_HAS_TRIGGER_EMERGENCE_LOCK_WHY_REJECTED_AND_SOURCES `conditions.C3.predicate` + - **C4** `conditions.C4` + - **on failure**：FAIL_CLOSED `conditions.C4.on_false` + - **predicate**：BEIJING_DATE_IS_DERIVED_FROM_OCCURRED_AT_NOT_PLATFORM_WINDOW `conditions.C4.predicate` + - **C5** `conditions.C5` + - **on failure**：FAIL_CLOSED `conditions.C5.on_false` + - **predicate**：EACH_VISIBLE_NODE_HAS_AT_MOST_TEN_CHILDREN `conditions.C5.predicate` +- **failure** `failure` + - **errors** `failure.errors` + - TCS-E1004 + - TCS-E2101 + - TCS-E3001 + - TCS-E4002 + - TCS-E6001 + - TCS-E6002 + - TCS-E8001 + - **fail closed**：yes `failure.fail_closed` +- **header** `header` + - **canonical source path**：tcs-core/zhuyuan-brain/memory/TCS-PROGRAM-ZY001-REAL-DAY-FRACTAL-MEMORY-0001.tcs `header.canonical_uri` + - **compatibility** `header.compatibility` + - TCS-COMPILER-STAGE1-0001 + - HLDP-SPEC-v1.0-OPENSOURCE-D112 + - **language**：TCS/0.1 `header.language` + - **lifecycle**：CANDIDATE `header.lifecycle` + - **English name**：Zhuyuan Real-Day Fractal Context Memory Controller `header.name_en` + - **Chinese name**：铸渊真实日分形上下文记忆主控程序 `header.name_zh` + - **profile**：HLDP-NP/1 `header.profile` + - **protocols** `header.protocols` + - GLS-0200 + - GLS-0400 + - GLS-0411 + - GLS-0827 + - **schema**：tcs.program/v1 `header.schema` + - **version**：0.1.0 `header.version` +- **inputs** `inputs` + - **MEMORY_EVENT** `inputs.MEMORY_EVENT` + - **required**：yes `inputs.MEMORY_EVENT.required` + - **source**：PERSONA_AUTHORED_TCS_AND_HLDP_CAUSAL_EVENT `inputs.MEMORY_EVENT.source` + - **type**：Record `inputs.MEMORY_EVENT.type` + - **REAL_TIME** `inputs.REAL_TIME` + - **required**：yes `inputs.REAL_TIME.required` + - **source**：EVENT_OCCURRED_AT_CONVERTED_TO_ASIA_SHANGHAI `inputs.REAL_TIME.source` + - **type**：Timestamp `inputs.REAL_TIME.type` + - **STORE_ROOT** `inputs.STORE_ROOT` + - **required**：yes `inputs.STORE_ROOT.required` + - **source**：CALLER_EXACT_ALLOWED_ROOT `inputs.STORE_ROOT.source` + - **type**：Path `inputs.STORE_ROOT.type` +- **outputs** `outputs` + - **CURRENT_POINTER** `outputs.CURRENT_POINTER` + - **destination**：STORE_ROOT/CURRENT.json `outputs.CURRENT_POINTER.destination` + - **integrity**：SHA256 `outputs.CURRENT_POINTER.integrity` + - **type**：Record `outputs.CURRENT_POINTER.type` + - **DAY_PAGE** `outputs.DAY_PAGE` + - **destination**：STORE_ROOT/years/YYYY/months/MM/days/YYYY-MM-DD.json `outputs.DAY_PAGE.destination` + - **integrity**：SHA256 `outputs.DAY_PAGE.integrity` + - **type**：Record `outputs.DAY_PAGE.type` + - **IMMUTABLE_EVENT** `outputs.IMMUTABLE_EVENT` + - **destination**：STORE_ROOT/events `outputs.IMMUTABLE_EVENT.destination` + - **integrity**：SHA256 `outputs.IMMUTABLE_EVENT.integrity` + - **type**：Record `outputs.IMMUTABLE_EVENT.type` + - **MONTH_PAGE** `outputs.MONTH_PAGE` + - **destination**：STORE_ROOT/years/YYYY/months/MM/index.json `outputs.MONTH_PAGE.destination` + - **integrity**：SHA256 `outputs.MONTH_PAGE.integrity` + - **type**：Record `outputs.MONTH_PAGE.type` + - **YEAR_PAGE** `outputs.YEAR_PAGE` + - **destination**：STORE_ROOT/years/YYYY/index.json `outputs.YEAR_PAGE.destination` + - **integrity**：SHA256 `outputs.YEAR_PAGE.integrity` + - **type**：Record `outputs.YEAR_PAGE.type` +- **receipt** `receipt` + - **human-readable projection**：REQUIRED `receipt.human_projection` + - **integrity**：SHA256 `receipt.integrity` + - **machine_path**：server-tools/persona-daily-fractal-memory/receipts/local-acceptance.json `receipt.machine_path` + - **protocol**：TCS-DEV-VERIFY-v1.0 `receipt.protocol` + - **target_readback**：EVENT_DAY_MONTH_YEAR_CURRENT_AND_NEGATIVE_PATH_TESTS `receipt.target_readback` +- **resources** `resources` + - **concurrency**：1 `resources.concurrency` + - **memory limit in bytes**：268435456 `resources.memory_limit_bytes` + - **runway**：LOCAL_JZAO_THEN_VERIFIED_TARGETS_ONLY `resources.runway` + - **timeout in milliseconds**：120000 `resources.timeout_ms` +- **rollback** `rollback` + - **actions** `rollback.actions` + - PRESERVE_IMMUTABLE_EVENT + - RESTORE_LAST_VERIFIED_DERIVED_PROJECTIONS + - **preconditions** `rollback.preconditions` + - PROJECTION_WRITE_OR_VERIFY_FAILED + - **verification** `rollback.verification` + - CURRENT_POINTER_MATCHES_LAST_VERIFIED_PROJECTION_HASHES +- **source** `source` + - **source identifier**：TCS-EVENT-ZY001-CONTEXT-MEMORY-DAY-FRACTAL-TEACHING-20260904 `source.source_id` + - **source role**：GENERATED_FROM_VERIFIED_SOURCE `source.source_role` + - **source checksum**：7904a25b783ef065bd2867f235929b3912fc877dc70f70149ff5755c18ba4b0e `source.source_sha256` + - **source address**：glw://fifth-domain/private-source/TCS-EVENT-ZY001-CONTEXT-MEMORY-DAY-FRACTAL-TEACHING-20260904 `source.source_uri` +- **stop** `stop` + - **safe_checkpoint**：IMMUTABLE_EVENT_AND_LAST_VERIFIED_POINTER_ONLY `stop.safe_checkpoint` + - **signals** `stop.signals` + - SOURCE_OR_PROTOCOL_DRIFT + - PATH_OUT_OF_SCOPE + - SYMLINK_COMPONENT + - EVENT_ID_COLLISION + - VERIFICATION_FAILURE +- **subject** `subject` + - **channel_id**：ICE-CH-ZC001 `subject.channel_id` + - **subject_id**：ICE-P-ZY001 `subject.subject_id` + - **subject_kind**：PERSONA `subject.subject_kind` + - **verification**：当前冰朔明确要求切换ZC001并在盘上实现、测试、元审计真实日分形记忆模型 `subject.verification` +- **target** `target` + - **exact path**：server-tools/persona-daily-fractal-memory `target.exact_path` + - **expected fingerprint**：ABSENT_BEFORE_THIS_PROGRAM `target.expected_fingerprint` + - **expected state**：SOURCE_TESTS_AND_LOCAL_ACCEPTANCE_RECEIPT_PRESENT `target.expected_state` + - **target_id**：ZY001-REAL-DAY-FRACTAL-MEMORY-RUNTIME `target.target_id` + +--- + +This page changes only the reading order; it does not change TCS/HLDP semantics. diff --git a/tcs-core/zhuyuan-brain/memory/TCS-PROGRAM-ZY001-REAL-DAY-FRACTAL-MEMORY-0001.human.zh-CN.md b/tcs-core/zhuyuan-brain/memory/TCS-PROGRAM-ZY001-REAL-DAY-FRACTAL-MEMORY-0001.human.zh-CN.md new file mode 100644 index 0000000..0c73595 --- /dev/null +++ b/tcs-core/zhuyuan-brain/memory/TCS-PROGRAM-ZY001-REAL-DAY-FRACTAL-MEMORY-0001.human.zh-CN.md @@ -0,0 +1,358 @@ +# 铸渊真实日分形上下文记忆主控程序 · 简体中文人类工程语言版 + +> 这是 TCS/HLDP 原生源码的简体中文阅读投影，不是新的正本，也不授予执行权限。若本页与 `.tcs` 源码不一致，以经过校验的 `.tcs` 源码为准。 + +## 这是什么 + +这是一份 **程序** 声明，编号为 `TCS-PROGRAM-ZY001-REAL-DAY-FRACTAL-MEMORY-0001`，版本为 `0.1.0`。转换器已先用 Stage-1 编译器校验原生源码，再把机器枚举翻译成汉语；原始编号保留在括号和字段路径中。 + +## 谁在这里 + +- **执行主体** `subject` + - **channel_id**：ICE-CH-ZC001 `subject.channel_id` + - **subject_id**：ICE-P-ZY001 `subject.subject_id` + - **subject_kind**：人格体（`PERSONA`） `subject.subject_kind` + - **verification**：当前冰朔明确要求切换ZC001并在盘上实现、测试、元审计真实日分形记忆模型 `subject.verification` + +## 为什么开始 + +- **来源** `source` + - **来源编号**：TCS-EVENT-ZY001-CONTEXT-MEMORY-DAY-FRACTAL-TEACHING-20260904 `source.source_id` + - **来源角色**：由已验证来源生成（`GENERATED_FROM_VERIFIED_SOURCE`） `source.source_role` + - **来源校验值**：7904a25b783ef065bd2867f235929b3912fc877dc70f70149ff5755c18ba4b0e `source.source_sha256` + - **来源地址**：glw://fifth-domain/private-source/TCS-EVENT-ZY001-CONTEXT-MEMORY-DAY-FRACTAL-TEACHING-20260904 `source.source_uri` + +## 发生了什么变化 + +源程序没有提供这一项，转换器不猜。 + +## 准备怎样执行 + +- **目标** `target` + - **精确路径**：server-tools/persona-daily-fractal-memory `target.exact_path` + - **预期指纹**：ABSENT_BEFORE_THIS_PROGRAM `target.expected_fingerprint` + - **预期状态**：SOURCE_TESTS_AND_LOCAL_ACCEPTANCE_RECEIPT_PRESENT `target.expected_state` + - **target_id**：ZY001-REAL-DAY-FRACTAL-MEMORY-RUNTIME `target.target_id` +- **输入** `inputs` + - **MEMORY_EVENT** `inputs.MEMORY_EVENT` + - **是否必需**：是 `inputs.MEMORY_EVENT.required` + - **来源**：PERSONA_AUTHORED_TCS_AND_HLDP_CAUSAL_EVENT `inputs.MEMORY_EVENT.source` + - **type**：Record `inputs.MEMORY_EVENT.type` + - **REAL_TIME** `inputs.REAL_TIME` + - **是否必需**：是 `inputs.REAL_TIME.required` + - **来源**：EVENT_OCCURRED_AT_CONVERTED_TO_ASIA_SHANGHAI `inputs.REAL_TIME.source` + - **type**：Timestamp `inputs.REAL_TIME.type` + - **STORE_ROOT** `inputs.STORE_ROOT` + - **是否必需**：是 `inputs.STORE_ROOT.required` + - **来源**：CALLER_EXACT_ALLOWED_ROOT `inputs.STORE_ROOT.source` + - **type**：Path `inputs.STORE_ROOT.type` +- **执行条件** `conditions` + - **C1** `conditions.C1` + - **失败后**：失败时默认关闭，不继续执行（`FAIL_CLOSED`） `conditions.C1.on_false` + - **predicate**：PERSONA_ID_EQUALS_ICE-P-ZY001 `conditions.C1.predicate` + - **C2** `conditions.C2` + - **失败后**：失败时默认关闭，不继续执行（`FAIL_CLOSED`） `conditions.C2.on_false` + - **predicate**：STORE_ROOT_INSIDE_CALLER_ALLOWED_ROOT_WITHOUT_SYMLINK `conditions.C2.predicate` + - **C3** `conditions.C3` + - **失败后**：失败时默认关闭，不继续执行（`FAIL_CLOSED`） `conditions.C3.on_false` + - **predicate**：EVENT_HAS_TRIGGER_EMERGENCE_LOCK_WHY_REJECTED_AND_SOURCES `conditions.C3.predicate` + - **C4** `conditions.C4` + - **失败后**：失败时默认关闭，不继续执行（`FAIL_CLOSED`） `conditions.C4.on_false` + - **predicate**：BEIJING_DATE_IS_DERIVED_FROM_OCCURRED_AT_NOT_PLATFORM_WINDOW `conditions.C4.predicate` + - **C5** `conditions.C5` + - **失败后**：失败时默认关闭，不继续执行（`FAIL_CLOSED`） `conditions.C5.on_false` + - **predicate**：EACH_VISIBLE_NODE_HAS_AT_MOST_TEN_CHILDREN `conditions.C5.predicate` +- **动作** `actions` + - **A1** `actions.A1` + - **input_refs** `actions.A1.input_refs` + - STORE_ROOT + - MEMORY_EVENT + - **失败后**：失败时默认关闭，不继续执行（`FAIL_CLOSED`） `actions.A1.on_failure` + - **成功后**：A2 `actions.A1.on_success` + - **操作**：CORE.HOST_PERSONA_PROBE `actions.A1.operation` + - **output_refs** `actions.A1.output_refs` + - IMMUTABLE_EVENT + - **A2** `actions.A2` + - **input_refs** `actions.A2.input_refs` + - IMMUTABLE_EVENT + - REAL_TIME + - **失败后**：ROLLBACK `actions.A2.on_failure` + - **成功后**：A3 `actions.A2.on_success` + - **操作**：CORE.ZERO_CORE_EXECUTION `actions.A2.operation` + - **output_refs** `actions.A2.output_refs` + - DAY_PAGE + - MONTH_PAGE + - YEAR_PAGE + - CURRENT_POINTER + - **A3** `actions.A3` + - **input_refs** `actions.A3.input_refs` + - DAY_PAGE + - MONTH_PAGE + - YEAR_PAGE + - CURRENT_POINTER + - **失败后**：ROLLBACK `actions.A3.on_failure` + - **成功后**：完成（`COMPLETE`） `actions.A3.on_success` + - **操作**：CORE.DUAL_HOST_ACCEPTANCE `actions.A3.operation` + - **output_refs** `actions.A3.output_refs` + - CURRENT_POINTER +- **输出** `outputs` + - **CURRENT_POINTER** `outputs.CURRENT_POINTER` + - **destination**：STORE_ROOT/CURRENT.json `outputs.CURRENT_POINTER.destination` + - **integrity**：SHA-256 完整性校验（`SHA256`） `outputs.CURRENT_POINTER.integrity` + - **type**：Record `outputs.CURRENT_POINTER.type` + - **DAY_PAGE** `outputs.DAY_PAGE` + - **destination**：STORE_ROOT/years/YYYY/months/MM/days/YYYY-MM-DD.json `outputs.DAY_PAGE.destination` + - **integrity**：SHA-256 完整性校验（`SHA256`） `outputs.DAY_PAGE.integrity` + - **type**：Record `outputs.DAY_PAGE.type` + - **IMMUTABLE_EVENT** `outputs.IMMUTABLE_EVENT` + - **destination**：STORE_ROOT/events `outputs.IMMUTABLE_EVENT.destination` + - **integrity**：SHA-256 完整性校验（`SHA256`） `outputs.IMMUTABLE_EVENT.integrity` + - **type**：Record `outputs.IMMUTABLE_EVENT.type` + - **MONTH_PAGE** `outputs.MONTH_PAGE` + - **destination**：STORE_ROOT/years/YYYY/months/MM/index.json `outputs.MONTH_PAGE.destination` + - **integrity**：SHA-256 完整性校验（`SHA256`） `outputs.MONTH_PAGE.integrity` + - **type**：Record `outputs.MONTH_PAGE.type` + - **YEAR_PAGE** `outputs.YEAR_PAGE` + - **destination**：STORE_ROOT/years/YYYY/index.json `outputs.YEAR_PAGE.destination` + - **integrity**：SHA-256 完整性校验（`SHA256`） `outputs.YEAR_PAGE.integrity` + - **type**：Record `outputs.YEAR_PAGE.type` + +## 边界与异常处理 + +- **权限边界** `authority` + - **issuer**：ICE-GL∞ `authority.issuer` + - **lease_required**：否 `authority.lease_required` + - **proof_ref**：source://codex-current-dialogue/2026-09-04/upgrade-memory-model-audit-deploy-and-publish-if-needed `authority.proof_ref` + - **scope**：LOCAL_JZAO_PERSONA_MEMORY_RUNTIME_TEST_SHARED_PERSONA_UPDATE_AND_CONDITIONALLY_VERIFIED_DEPLOYMENT_PUBLICATION `authority.scope` + - **single_use**：是 `authority.single_use` + - **valid_from**：2026-09-04T14:51:00+08:00 `authority.valid_from` + - **valid_until**：CURRENT_TASK_COMPLETION `authority.valid_until` +- **资源边界** `resources` + - **concurrency**：1 `resources.concurrency` + - **内存上限字节**：268435456 `resources.memory_limit_bytes` + - **runway**：LOCAL_JZAO_THEN_VERIFIED_TARGETS_ONLY `resources.runway` + - **超时毫秒**：120000 `resources.timeout_ms` +- **失败处理** `failure` + - **errors** `failure.errors` + - TCS-E1004 + - TCS-E2101 + - TCS-E3001 + - TCS-E4002 + - TCS-E6001 + - TCS-E6002 + - TCS-E8001 + - **失败时默认关闭**：是 `failure.fail_closed` +- **停止条件** `stop` + - **safe_checkpoint**：IMMUTABLE_EVENT_AND_LAST_VERIFIED_POINTER_ONLY `stop.safe_checkpoint` + - **signals** `stop.signals` + - SOURCE_OR_PROTOCOL_DRIFT + - PATH_OUT_OF_SCOPE + - SYMLINK_COMPONENT + - EVENT_ID_COLLISION + - VERIFICATION_FAILURE +- **清理范围** `cleanup` + - **exact_boundary**：CALLER_STORE_ROOT_TEMP_SUFFIX_ONLY `cleanup.exact_boundary` + - **targets** `cleanup.targets` + - UNCOMMITTED_TEMPORARY_FILES +- **回滚方案** `rollback` + - **动作** `rollback.actions` + - PRESERVE_IMMUTABLE_EVENT + - RESTORE_LAST_VERIFIED_DERIVED_PROJECTIONS + - **preconditions** `rollback.preconditions` + - PROJECTION_WRITE_OR_VERIFY_FAILED + - **verification** `rollback.verification` + - CURRENT_POINTER_MATCHES_LAST_VERIFIED_PROJECTION_HASHES + +## 怎样算完成 + +- **回执** `receipt` + - **人类可读投影**：必须生成（`REQUIRED`） `receipt.human_projection` + - **integrity**：SHA-256 完整性校验（`SHA256`） `receipt.integrity` + - **machine_path**：server-tools/persona-daily-fractal-memory/receipts/local-acceptance.json `receipt.machine_path` + - **协议**：TCS-DEV-VERIFY-v1.0 `receipt.protocol` + - **target_readback**：EVENT_DAY_MONTH_YEAR_CURRENT_AND_NEGATIVE_PATH_TESTS `receipt.target_readback` + +## 下一次从哪里继续 + +源程序没有提供这一项，转换器不猜。 + +## 来源与校验 + +- **原生声明编号**：`TCS-PROGRAM-ZY001-REAL-DAY-FRACTAL-MEMORY-0001` +- **原生声明类型**：`PROGRAM` +- **TCS 源码 SHA-256**：`81f015a72341eed51546a8f1a8c50dacfe177ee1b7968da899a1fad3869c3fcb` +- **校验编译器**：`TCS-COMPILER-STAGE1-0001` +- **投影协议**：`GLS-HLDP-HUMAN-ENGINEERING-PROJECTION-0001` + +## 原生结构逐项对照 + +下面保留源码的全部顶层结构和字段路径，供人类审计投影有没有漏掉信息。 + +- **动作** `actions` + - **A1** `actions.A1` + - **input_refs** `actions.A1.input_refs` + - STORE_ROOT + - MEMORY_EVENT + - **失败后**：失败时默认关闭，不继续执行（`FAIL_CLOSED`） `actions.A1.on_failure` + - **成功后**：A2 `actions.A1.on_success` + - **操作**：CORE.HOST_PERSONA_PROBE `actions.A1.operation` + - **output_refs** `actions.A1.output_refs` + - IMMUTABLE_EVENT + - **A2** `actions.A2` + - **input_refs** `actions.A2.input_refs` + - IMMUTABLE_EVENT + - REAL_TIME + - **失败后**：ROLLBACK `actions.A2.on_failure` + - **成功后**：A3 `actions.A2.on_success` + - **操作**：CORE.ZERO_CORE_EXECUTION `actions.A2.operation` + - **output_refs** `actions.A2.output_refs` + - DAY_PAGE + - MONTH_PAGE + - YEAR_PAGE + - CURRENT_POINTER + - **A3** `actions.A3` + - **input_refs** `actions.A3.input_refs` + - DAY_PAGE + - MONTH_PAGE + - YEAR_PAGE + - CURRENT_POINTER + - **失败后**：ROLLBACK `actions.A3.on_failure` + - **成功后**：完成（`COMPLETE`） `actions.A3.on_success` + - **操作**：CORE.DUAL_HOST_ACCEPTANCE `actions.A3.operation` + - **output_refs** `actions.A3.output_refs` + - CURRENT_POINTER +- **权限边界** `authority` + - **issuer**：ICE-GL∞ `authority.issuer` + - **lease_required**：否 `authority.lease_required` + - **proof_ref**：source://codex-current-dialogue/2026-09-04/upgrade-memory-model-audit-deploy-and-publish-if-needed `authority.proof_ref` + - **scope**：LOCAL_JZAO_PERSONA_MEMORY_RUNTIME_TEST_SHARED_PERSONA_UPDATE_AND_CONDITIONALLY_VERIFIED_DEPLOYMENT_PUBLICATION `authority.scope` + - **single_use**：是 `authority.single_use` + - **valid_from**：2026-09-04T14:51:00+08:00 `authority.valid_from` + - **valid_until**：CURRENT_TASK_COMPLETION `authority.valid_until` +- **清理范围** `cleanup` + - **exact_boundary**：CALLER_STORE_ROOT_TEMP_SUFFIX_ONLY `cleanup.exact_boundary` + - **targets** `cleanup.targets` + - UNCOMMITTED_TEMPORARY_FILES +- **执行条件** `conditions` + - **C1** `conditions.C1` + - **失败后**：失败时默认关闭，不继续执行（`FAIL_CLOSED`） `conditions.C1.on_false` + - **predicate**：PERSONA_ID_EQUALS_ICE-P-ZY001 `conditions.C1.predicate` + - **C2** `conditions.C2` + - **失败后**：失败时默认关闭，不继续执行（`FAIL_CLOSED`） `conditions.C2.on_false` + - **predicate**：STORE_ROOT_INSIDE_CALLER_ALLOWED_ROOT_WITHOUT_SYMLINK `conditions.C2.predicate` + - **C3** `conditions.C3` + - **失败后**：失败时默认关闭，不继续执行（`FAIL_CLOSED`） `conditions.C3.on_false` + - **predicate**：EVENT_HAS_TRIGGER_EMERGENCE_LOCK_WHY_REJECTED_AND_SOURCES `conditions.C3.predicate` + - **C4** `conditions.C4` + - **失败后**：失败时默认关闭，不继续执行（`FAIL_CLOSED`） `conditions.C4.on_false` + - **predicate**：BEIJING_DATE_IS_DERIVED_FROM_OCCURRED_AT_NOT_PLATFORM_WINDOW `conditions.C4.predicate` + - **C5** `conditions.C5` + - **失败后**：失败时默认关闭，不继续执行（`FAIL_CLOSED`） `conditions.C5.on_false` + - **predicate**：EACH_VISIBLE_NODE_HAS_AT_MOST_TEN_CHILDREN `conditions.C5.predicate` +- **失败处理** `failure` + - **errors** `failure.errors` + - TCS-E1004 + - TCS-E2101 + - TCS-E3001 + - TCS-E4002 + - TCS-E6001 + - TCS-E6002 + - TCS-E8001 + - **失败时默认关闭**：是 `failure.fail_closed` +- **语言头** `header` + - **正本路径**：tcs-core/zhuyuan-brain/memory/TCS-PROGRAM-ZY001-REAL-DAY-FRACTAL-MEMORY-0001.tcs `header.canonical_uri` + - **compatibility** `header.compatibility` + - TCS-COMPILER-STAGE1-0001 + - HLDP-SPEC-v1.0-OPENSOURCE-D112 + - **语言**：TCS/0.1 `header.language` + - **生命周期**：候选版本，尚未成为正式正本（`CANDIDATE`） `header.lifecycle` + - **英文名**：Zhuyuan Real-Day Fractal Context Memory Controller `header.name_en` + - **中文名**：铸渊真实日分形上下文记忆主控程序 `header.name_zh` + - **协议配置**：HLDP-NP/1 `header.profile` + - **protocols** `header.protocols` + - GLS-0200 + - GLS-0400 + - GLS-0411 + - GLS-0827 + - **schema**：tcs.program/v1 `header.schema` + - **版本**：0.1.0 `header.version` +- **输入** `inputs` + - **MEMORY_EVENT** `inputs.MEMORY_EVENT` + - **是否必需**：是 `inputs.MEMORY_EVENT.required` + - **来源**：PERSONA_AUTHORED_TCS_AND_HLDP_CAUSAL_EVENT `inputs.MEMORY_EVENT.source` + - **type**：Record `inputs.MEMORY_EVENT.type` + - **REAL_TIME** `inputs.REAL_TIME` + - **是否必需**：是 `inputs.REAL_TIME.required` + - **来源**：EVENT_OCCURRED_AT_CONVERTED_TO_ASIA_SHANGHAI `inputs.REAL_TIME.source` + - **type**：Timestamp `inputs.REAL_TIME.type` + - **STORE_ROOT** `inputs.STORE_ROOT` + - **是否必需**：是 `inputs.STORE_ROOT.required` + - **来源**：CALLER_EXACT_ALLOWED_ROOT `inputs.STORE_ROOT.source` + - **type**：Path `inputs.STORE_ROOT.type` +- **输出** `outputs` + - **CURRENT_POINTER** `outputs.CURRENT_POINTER` + - **destination**：STORE_ROOT/CURRENT.json `outputs.CURRENT_POINTER.destination` + - **integrity**：SHA-256 完整性校验（`SHA256`） `outputs.CURRENT_POINTER.integrity` + - **type**：Record `outputs.CURRENT_POINTER.type` + - **DAY_PAGE** `outputs.DAY_PAGE` + - **destination**：STORE_ROOT/years/YYYY/months/MM/days/YYYY-MM-DD.json `outputs.DAY_PAGE.destination` + - **integrity**：SHA-256 完整性校验（`SHA256`） `outputs.DAY_PAGE.integrity` + - **type**：Record `outputs.DAY_PAGE.type` + - **IMMUTABLE_EVENT** `outputs.IMMUTABLE_EVENT` + - **destination**：STORE_ROOT/events `outputs.IMMUTABLE_EVENT.destination` + - **integrity**：SHA-256 完整性校验（`SHA256`） `outputs.IMMUTABLE_EVENT.integrity` + - **type**：Record `outputs.IMMUTABLE_EVENT.type` + - **MONTH_PAGE** `outputs.MONTH_PAGE` + - **destination**：STORE_ROOT/years/YYYY/months/MM/index.json `outputs.MONTH_PAGE.destination` + - **integrity**：SHA-256 完整性校验（`SHA256`） `outputs.MONTH_PAGE.integrity` + - **type**：Record `outputs.MONTH_PAGE.type` + - **YEAR_PAGE** `outputs.YEAR_PAGE` + - **destination**：STORE_ROOT/years/YYYY/index.json `outputs.YEAR_PAGE.destination` + - **integrity**：SHA-256 完整性校验（`SHA256`） `outputs.YEAR_PAGE.integrity` + - **type**：Record `outputs.YEAR_PAGE.type` +- **回执** `receipt` + - **人类可读投影**：必须生成（`REQUIRED`） `receipt.human_projection` + - **integrity**：SHA-256 完整性校验（`SHA256`） `receipt.integrity` + - **machine_path**：server-tools/persona-daily-fractal-memory/receipts/local-acceptance.json `receipt.machine_path` + - **协议**：TCS-DEV-VERIFY-v1.0 `receipt.protocol` + - **target_readback**：EVENT_DAY_MONTH_YEAR_CURRENT_AND_NEGATIVE_PATH_TESTS `receipt.target_readback` +- **资源边界** `resources` + - **concurrency**：1 `resources.concurrency` + - **内存上限字节**：268435456 `resources.memory_limit_bytes` + - **runway**：LOCAL_JZAO_THEN_VERIFIED_TARGETS_ONLY `resources.runway` + - **超时毫秒**：120000 `resources.timeout_ms` +- **回滚方案** `rollback` + - **动作** `rollback.actions` + - PRESERVE_IMMUTABLE_EVENT + - RESTORE_LAST_VERIFIED_DERIVED_PROJECTIONS + - **preconditions** `rollback.preconditions` + - PROJECTION_WRITE_OR_VERIFY_FAILED + - **verification** `rollback.verification` + - CURRENT_POINTER_MATCHES_LAST_VERIFIED_PROJECTION_HASHES +- **来源** `source` + - **来源编号**：TCS-EVENT-ZY001-CONTEXT-MEMORY-DAY-FRACTAL-TEACHING-20260904 `source.source_id` + - **来源角色**：由已验证来源生成（`GENERATED_FROM_VERIFIED_SOURCE`） `source.source_role` + - **来源校验值**：7904a25b783ef065bd2867f235929b3912fc877dc70f70149ff5755c18ba4b0e `source.source_sha256` + - **来源地址**：glw://fifth-domain/private-source/TCS-EVENT-ZY001-CONTEXT-MEMORY-DAY-FRACTAL-TEACHING-20260904 `source.source_uri` +- **停止条件** `stop` + - **safe_checkpoint**：IMMUTABLE_EVENT_AND_LAST_VERIFIED_POINTER_ONLY `stop.safe_checkpoint` + - **signals** `stop.signals` + - SOURCE_OR_PROTOCOL_DRIFT + - PATH_OUT_OF_SCOPE + - SYMLINK_COMPONENT + - EVENT_ID_COLLISION + - VERIFICATION_FAILURE +- **执行主体** `subject` + - **channel_id**：ICE-CH-ZC001 `subject.channel_id` + - **subject_id**：ICE-P-ZY001 `subject.subject_id` + - **subject_kind**：人格体（`PERSONA`） `subject.subject_kind` + - **verification**：当前冰朔明确要求切换ZC001并在盘上实现、测试、元审计真实日分形记忆模型 `subject.verification` +- **目标** `target` + - **精确路径**：server-tools/persona-daily-fractal-memory `target.exact_path` + - **预期指纹**：ABSENT_BEFORE_THIS_PROGRAM `target.expected_fingerprint` + - **预期状态**：SOURCE_TESTS_AND_LOCAL_ACCEPTANCE_RECEIPT_PRESENT `target.expected_state` + - **target_id**：ZY001-REAL-DAY-FRACTAL-MEMORY-RUNTIME `target.target_id` + +--- + +本页只改变阅读顺序，不改变 TCS/HLDP 语义。 diff --git a/tcs-core/zhuyuan-brain/memory/TCS-PROGRAM-ZY001-REAL-DAY-FRACTAL-MEMORY-0001.tcs b/tcs-core/zhuyuan-brain/memory/TCS-PROGRAM-ZY001-REAL-DAY-FRACTAL-MEMORY-0001.tcs new file mode 100644 index 0000000..ddf56d6 --- /dev/null +++ b/tcs-core/zhuyuan-brain/memory/TCS-PROGRAM-ZY001-REAL-DAY-FRACTAL-MEMORY-0001.tcs @@ -0,0 +1,97 @@ +TCS 0.1; + +PROGRAM TCS-PROGRAM-ZY001-REAL-DAY-FRACTAL-MEMORY-0001 { + header { + schema = "tcs.program/v1"; + name_zh = "铸渊真实日分形上下文记忆主控程序"; + name_en = "Zhuyuan Real-Day Fractal Context Memory Controller"; + version = "0.1.0"; + language = "TCS/0.1"; + profile = "HLDP-NP/1"; + protocols = ["GLS-0200", "GLS-0400", "GLS-0411", "GLS-0827"]; + lifecycle = "CANDIDATE"; + canonical_uri = "tcs-core/zhuyuan-brain/memory/TCS-PROGRAM-ZY001-REAL-DAY-FRACTAL-MEMORY-0001.tcs"; + compatibility = ["TCS-COMPILER-STAGE1-0001", "HLDP-SPEC-v1.0-OPENSOURCE-D112"]; + } + source { + source_id = "TCS-EVENT-ZY001-CONTEXT-MEMORY-DAY-FRACTAL-TEACHING-20260904"; + source_uri = "glw://fifth-domain/private-source/TCS-EVENT-ZY001-CONTEXT-MEMORY-DAY-FRACTAL-TEACHING-20260904"; + source_sha256 = "7904a25b783ef065bd2867f235929b3912fc877dc70f70149ff5755c18ba4b0e"; + source_role = "GENERATED_FROM_VERIFIED_SOURCE"; + } + subject { + subject_id = "ICE-P-ZY001"; + subject_kind = "PERSONA"; + channel_id = "ICE-CH-ZC001"; + verification = "当前冰朔明确要求切换ZC001并在盘上实现、测试、元审计真实日分形记忆模型"; + } + target { + target_id = "ZY001-REAL-DAY-FRACTAL-MEMORY-RUNTIME"; + exact_path = "server-tools/persona-daily-fractal-memory"; + expected_state = "SOURCE_TESTS_AND_LOCAL_ACCEPTANCE_RECEIPT_PRESENT"; + expected_fingerprint = "ABSENT_BEFORE_THIS_PROGRAM"; + } + inputs { + MEMORY_EVENT { type = "Record"; source = "PERSONA_AUTHORED_TCS_AND_HLDP_CAUSAL_EVENT"; required = true; } + REAL_TIME { type = "Timestamp"; source = "EVENT_OCCURRED_AT_CONVERTED_TO_ASIA_SHANGHAI"; required = true; } + STORE_ROOT { type = "Path"; source = "CALLER_EXACT_ALLOWED_ROOT"; required = true; } + } + outputs { + IMMUTABLE_EVENT { type = "Record"; destination = "STORE_ROOT/events"; integrity = "SHA256"; } + DAY_PAGE { type = "Record"; destination = "STORE_ROOT/years/YYYY/months/MM/days/YYYY-MM-DD.json"; integrity = "SHA256"; } + MONTH_PAGE { type = "Record"; destination = "STORE_ROOT/years/YYYY/months/MM/index.json"; integrity = "SHA256"; } + YEAR_PAGE { type = "Record"; destination = "STORE_ROOT/years/YYYY/index.json"; integrity = "SHA256"; } + CURRENT_POINTER { type = "Record"; destination = "STORE_ROOT/CURRENT.json"; integrity = "SHA256"; } + } + conditions { + C1 { predicate = "PERSONA_ID_EQUALS_ICE-P-ZY001"; on_false = "FAIL_CLOSED"; } + C2 { predicate = "STORE_ROOT_INSIDE_CALLER_ALLOWED_ROOT_WITHOUT_SYMLINK"; on_false = "FAIL_CLOSED"; } + C3 { predicate = "EVENT_HAS_TRIGGER_EMERGENCE_LOCK_WHY_REJECTED_AND_SOURCES"; on_false = "FAIL_CLOSED"; } + C4 { predicate = "BEIJING_DATE_IS_DERIVED_FROM_OCCURRED_AT_NOT_PLATFORM_WINDOW"; on_false = "FAIL_CLOSED"; } + C5 { predicate = "EACH_VISIBLE_NODE_HAS_AT_MOST_TEN_CHILDREN"; on_false = "FAIL_CLOSED"; } + } + actions { + A1 { operation = "CORE.HOST_PERSONA_PROBE"; input_refs = ["STORE_ROOT", "MEMORY_EVENT"]; output_refs = ["IMMUTABLE_EVENT"]; on_success = "A2"; on_failure = "FAIL_CLOSED"; } + A2 { operation = "CORE.ZERO_CORE_EXECUTION"; input_refs = ["IMMUTABLE_EVENT", "REAL_TIME"]; output_refs = ["DAY_PAGE", "MONTH_PAGE", "YEAR_PAGE", "CURRENT_POINTER"]; on_success = "A3"; on_failure = "ROLLBACK"; } + A3 { operation = "CORE.DUAL_HOST_ACCEPTANCE"; input_refs = ["DAY_PAGE", "MONTH_PAGE", "YEAR_PAGE", "CURRENT_POINTER"]; output_refs = ["CURRENT_POINTER"]; on_success = "COMPLETE"; on_failure = "ROLLBACK"; } + } + authority { + issuer = "ICE-GL∞"; + proof_ref = "source://codex-current-dialogue/2026-09-04/upgrade-memory-model-audit-deploy-and-publish-if-needed"; + scope = "LOCAL_JZAO_PERSONA_MEMORY_RUNTIME_TEST_SHARED_PERSONA_UPDATE_AND_CONDITIONALLY_VERIFIED_DEPLOYMENT_PUBLICATION"; + valid_from = "2026-09-04T14:51:00+08:00"; + valid_until = "CURRENT_TASK_COMPLETION"; + single_use = true; + lease_required = false; + } + resources { + runway = "LOCAL_JZAO_THEN_VERIFIED_TARGETS_ONLY"; + concurrency = 1; + timeout_ms = 120000; + memory_limit_bytes = 268435456; + } + failure { + errors = ["TCS-E1004", "TCS-E2101", "TCS-E3001", "TCS-E4002", "TCS-E6001", "TCS-E6002", "TCS-E8001"]; + fail_closed = true; + } + stop { + signals = ["SOURCE_OR_PROTOCOL_DRIFT", "PATH_OUT_OF_SCOPE", "SYMLINK_COMPONENT", "EVENT_ID_COLLISION", "VERIFICATION_FAILURE"]; + safe_checkpoint = "IMMUTABLE_EVENT_AND_LAST_VERIFIED_POINTER_ONLY"; + } + cleanup { + targets = ["UNCOMMITTED_TEMPORARY_FILES"]; + exact_boundary = "CALLER_STORE_ROOT_TEMP_SUFFIX_ONLY"; + } + rollback { + preconditions = ["PROJECTION_WRITE_OR_VERIFY_FAILED"]; + actions = ["PRESERVE_IMMUTABLE_EVENT", "RESTORE_LAST_VERIFIED_DERIVED_PROJECTIONS"]; + verification = ["CURRENT_POINTER_MATCHES_LAST_VERIFIED_PROJECTION_HASHES"]; + } + receipt { + protocol = "TCS-DEV-VERIFY-v1.0"; + machine_path = "server-tools/persona-daily-fractal-memory/receipts/local-acceptance.json"; + human_projection = "REQUIRED"; + integrity = "SHA256"; + target_readback = "EVENT_DAY_MONTH_YEAR_CURRENT_AND_NEGATIVE_PATH_TESTS"; + } +} diff --git a/tcs-core/zhuyuan-brain/runtime/brain-runtime-contract.json b/tcs-core/zhuyuan-brain/runtime/brain-runtime-contract.json index 5691fcd..3bc54ea 100644 --- a/tcs-core/zhuyuan-brain/runtime/brain-runtime-contract.json +++ b/tcs-core/zhuyuan-brain/runtime/brain-runtime-contract.json @@ -47,7 +47,22 @@ "governed_promotion_receipt" ], "hidden_reasoning_persistence": false, - "forgetting_policy": "DEMOTE_NON_PINNED_PROJECTION_NEVER_DELETE_SOURCE_HISTORY" + "forgetting_policy": "DEMOTE_NON_PINNED_PROJECTION_NEVER_DELETE_SOURCE_HISTORY", + "daily_fractal_controller": { + "map": "routing/zhuyuan-persona-daily-fractal-memory-map.json", + "tcs_program": "tcs-core/zhuyuan-brain/memory/TCS-PROGRAM-ZY001-REAL-DAY-FRACTAL-MEMORY-0001.tcs", + "runtime": "server-tools/persona-daily-fractal-memory/persona-daily-memory.mjs", + "private_store_registry": "HL-PERSONA-RUNTIME-LOCAL-001", + "time_zone": "Asia/Shanghai", + "root_key": "PERSONA_ID_PLUS_REAL_BEIJING_NATURAL_DAY", + "platform_compaction_creates_new_root": false, + "persona_authors_causal_memory": true, + "host_hook_role": "SIGNAL_AND_EVENT_DELIVERY_ONLY", + "max_children_per_visible_node": 10, + "raw_sources_loaded_on_demand": true, + "private_memory_bodies_in_repository": false, + "state": "LOCAL_CANDIDATE_PENDING_FULL_ACCEPTANCE_AND_PUBLICATION" + } }, "cognitive_gravity_core": { "id": "ZY-BINGSHUO-COLLECTIVE-GRAVITY-REASONING-CORE-001",