diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index dcdf5a8..985333d 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -124,5 +124,6 @@ jobs: - run: uv sync --locked --group dev --managed-python - name: Verify real SQLite extension loading run: uv run python -c "import sqlite3, sqlite_vec; db = sqlite3.connect(':memory:'); db.enable_load_extension(True); sqlite_vec.load(db); db.close()" - # Temporary stores, real writer/watcher/locks; no provider calls. - - run: SYNCMILL_TEST_MEMTOMEM_REAL=1 uv run pytest -q tests/test_memory_backend_memtomem_integration.py tests/test_memory_gc_process.py + # Temporary stores and copies of release-written ones, real + # writer/watcher/locks; no provider calls. + - run: SYNCMILL_TEST_MEMTOMEM_REAL=1 uv run pytest -q tests/test_memory_backend_memtomem_integration.py tests/test_memory_gc_process.py tests/test_frozen_memory_real.py diff --git a/CLAUDE.md b/CLAUDE.md index 59b923f..fef47b8 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -77,7 +77,7 @@ uv run syncmill status # check the selected memory backend uv run syncmill serve # read-only MCP gateway over `shared` (stdio; --http/--host/--port) uv run syncmill memory migration plan --from memtomem --to mem0 # source-retaining snapshot; apply/verify/rollback by id SYNCMILL_TEST_MEMORY_MIGRATION_REAL=1 uv run pytest -q tests/test_memory_migration_integration.py # required before changing migration adapters -SYNCMILL_TEST_MEMTOMEM_REAL=1 uv run pytest -q tests/test_memory_backend_memtomem_integration.py # required before changing MemtomemBackend's replicated add flow or the memtomem pin +SYNCMILL_TEST_MEMTOMEM_REAL=1 uv run pytest -q tests/test_memory_backend_memtomem_integration.py tests/test_frozen_memory_real.py # required before changing MemtomemBackend's replicated add flow or the memtomem pin (the second file reads release-written stores) SYNCMILL_TEST_LANGGRAPH_REAL=1 uv run pytest -q tests/test_memory_backend_langgraph_integration.py # required before changing LangGraph SDK pins/API calls uv add # add a dependency (edits pyproject.toml + uv.lock) uv sync --group dev # install dev deps (pytest) @@ -184,7 +184,7 @@ Rules that must hold: - **Write-path invariants — do not change without the real smoke.** Each write invalidates the search result cache; writes go to namespace-suffixed day files `{date}.{ns}.md`; each entry gets an explicit unique heading (`_entry_title`); payloads open with a **bold** label, never `## ` (heading-led content skips the unique title). - **Locking — do not change without the real smoke.** A write takes the namespace lock (`_namespace_lock_path`) before selecting its day file, then holds the resolved file's L2 sidecar (`memory_lock_path`) across mix-check → append → index; `purge_namespace` holds the namespace lock plus every owned source's sidecar, removes sources before rows, and raises when a purge cannot be proven complete. `add_and_share` (#117) holds ONE span over both appends: both namespace locks, then both day files' sidecars, from before the clock is read until the last copy is indexed; its copies share one `index_file` and are matched to their source chunks by `shared-from=`, never by index order. **Ordering rule** (on `_namespace_lock_path`; tested): every namespace lock before any sidecar, never a namespace lock while holding a sidecar, and within each level ascending `str(lock_path)`, deduplicated (`_namespace_lock_order`; sidecars by `memory_lock_path`). An unlocked append lets the watcher index the file first and strand the chunk in the wrong namespace. - **Protected targets.** An unattended append refuses a symlinked day file, a non-`user` tier, a read-only source and an excluded source. `purge_namespace` refuses, before deleting anything, a symlinked source, one in a `read_only_memory_dirs` root, and one in a `project_shared` tier (a `project_local` source may be purged). -- **Pins.** `memtomem>=0.6.8,<0.7` and `mcp>=2.0.0,<3` move together; bump only with `SYNCMILL_TEST_MEMTOMEM_REAL=1 uv run pytest -q tests/test_memory_backend_memtomem_integration.py`. +- **Pins.** `memtomem>=0.6.8,<0.7` and `mcp>=2.0.0,<3` move together; bump only with `SYNCMILL_TEST_MEMTOMEM_REAL=1 uv run pytest -q tests/test_memory_backend_memtomem_integration.py tests/test_frozen_memory_real.py`. ### Interactive collaboration (human drives one agent, syncmill runs the rest) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index b2eea87..838bb08 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -31,7 +31,8 @@ Some changes require an opt-in real smoke before they can be reviewed: ```bash SYNCMILL_TEST_MEMTOMEM_REAL=1 uv run pytest -q \ - tests/test_memory_backend_memtomem_integration.py # the memtomem add flow or pin + tests/test_memory_backend_memtomem_integration.py \ + tests/test_frozen_memory_real.py # the memtomem add flow or pin SYNCMILL_TEST_MEMORY_MIGRATION_REAL=1 uv run pytest -q \ tests/test_memory_migration_integration.py # migration adapters SYNCMILL_TEST_LANGGRAPH_REAL=1 uv run pytest -q \ diff --git a/README.md b/README.md index d3b1ecc..8c0d9c7 100644 --- a/README.md +++ b/README.md @@ -827,8 +827,14 @@ The suite replaces agents and memory with in-memory fakes (see The [2026-09-08 stabilization roadmap](https://github.com/memtomem/syncmill/blob/main/docs/improvement-roadmap-2026-09-08.ko.md) reconciles historical handoffs with current source and documents memory GC recovery. -Opt-in real memory tests use temporary stores: `SYNCMILL_TEST_MEMTOMEM_REAL=1 uv run -pytest -q tests/test_memory_backend_memtomem_integration.py tests/test_memory_gc_process.py`. +Opt-in real memory tests use temporary stores and copies of release-written ones: + +```bash +SYNCMILL_TEST_MEMTOMEM_REAL=1 uv run pytest -q \ + tests/test_memory_backend_memtomem_integration.py \ + tests/test_memory_gc_process.py \ + tests/test_frozen_memory_real.py +``` ## Contributing diff --git a/docs/architecture/persisted-contracts.md b/docs/architecture/persisted-contracts.md index c48bb61..ab75977 100644 --- a/docs/architecture/persisted-contracts.md +++ b/docs/architecture/persisted-contracts.md @@ -56,7 +56,8 @@ A golden over the current writer does not protect these. A reader can stop accep | Workflows | the workflow database (`workflows.db`): rows with `spec_json`, manifest `schema_version` 3 with `calls_used`, events, and from v0.3.0 the lineage columns and `file`/`revision` origins; per workflow `spec.json`, planner output, node bundles (`result.json`, `winner.patch`, `commit.json` v3) and stream logs; workflow-origin run artifacts, approved or not, with `plan.final_agent` from v0.3.0. No release wrote manifest v1 or v2 (both normalize to v3 before the insert); those readers stay covered by `test_workflow_durable.py::test_marked_v1_migration_preserves_exact_count_and_control_fields` and `test_workflow.py::test_a_workflow_whose_call_accounting_is_ambiguous_is_refused` | `workflow list` / `show` (`--prompts`) / `status` / `logs` / `lineage` / `export` / `cancel` / `prune`, a dead release-written lease recovered by `show` and `status`, `WorkflowStore.events` and `read_node_bundle`; for the final artifact `diff`, `runs show`, `apply` (approved, after a prune, approval healed from the database, refused for a workflow that never completed, `no_changes`), the standalone `recover` skip. A final artifact naming another run, and an unreadable store: `test_cli.py::test_apply_refuses_an_artifact_the_named_workflow_did_not_finalize` and `test_apply_guard_fails_closed_when_the_workflow_store_cannot_be_read`. HEAD execution (`WorkflowCoordinator.run`, what the job worker calls): `run` of released planned, created and revised rows (accounting, stored prompts, dependency output); `resume` of released crashes and failures against the stored deadline (expired: fails before dispatch; before it: the completed dependency's bundle is reused and the unfinished node's attempt refunded, a published final artifact is reused and approved without backfilling `final_agent`, an exhausted node dispatches nothing), refused from a final or unstarted state and while the owner lives, with the released execution history and events kept; `workflow revise` (a v0.2.0 parent gains a lineage); the launch's team peek and state check; `apply --verify` narrowing (v0.2.0: the gate's list only, with a notice; also after a prune); control plans enabled refuse a released workflow planned without one. Written later by the same releases (`freeze.py --part 2b`, `bindings-2b.json`): a node bundle saved just before the crash, reclaimed on resume through `read_node_result` / `read_node_bundle` with its usage added once (`_record_usage`), and re-run when its patch, its commit record or its digest disagrees; control-plan workflows, whose released `control-plan.json` is the control preflight's request, whose binding and validation topology refuse a changed configuration, and whose stored limits and node timeouts bound a run with control plans on, off, or Toolgraph off (`_execution_limits`), plus `show`, `read_control_plan`, `conversations show` and `apply` of a completed one; an interrupted apply of a final artifact, classified by `recover` (completed, not applied, manual recovery; `_bound_receipt`) without touching its approval or the workflow row. Not covered: the TUI's `_read_artifact_result`; no reader revalidates a released execution's `control-preflight.json` | `test_frozen_workflows.py` (v0.2.0, v0.3.0) | | Sessions and project | isolated-session documents in every state a release leaves (open, checkpointed, closed, and from injected exits creating, closing, recovery_required) and their checkpoint run artifacts; the project marker `.syncmill/project.json` and the `syncmill.toml` that `init` writes | `session isolated-list` (`IsolatedSessionStore.list`: live, source staleness in the stored fingerprint's version), `IsolatedSessionStore.load` path binding (repository, workspace run root, worktree, derived tmux name) through `attach-isolated` (state, liveness, pane cwd), `checkpoint` (a missing worktree) and `close` (each state, a missing workspace), `tui_collaboration.render_session`; for the checkpoint artifact `runs list` / `show`, `diff`, `conversations show` / `list` / `close`, `continue` (refused), `recover` (skipped), `apply` and `validate_applicable`, `discard`, `prune` (pending kept), the TUI `render_artifact` / `_read_artifact_result`; `project_id` with the marker untracked, tracked or symlinked, `load_project_config` of the released config, `initialize_project` falling back to the marker. Not covered: a successful checkpoint or worktree cleanup (a release-written workspace is not relocatable) | `test_frozen_sessions.py` (v0.1.2, v0.2.0, v0.3.0) | | Board | the board database (`board.db`, with the WAL a killed run leaves): items in every state a release's `board add` / `run` / `update` / `import-review-candidates` leave them (gate evidence passing and failing, the agent's `done` and `review` blocks with handoff and outputs, an agent failure, a killed and a reclaimed claim, a SIGINT and an orchestration crash, manual evidence and sign-off, dependencies including a missing one, imported review candidates), their transitions, decisions including a superseded one, the run ledger, and from v0.2.0 the compaction rollups and counters (partly compacted: a count needs both the live audit and the rollups). No release wrote the lesson columns (`project_id`, `provenance_json`, `source_key`); `test_lessons.py::test_an_old_board_gains_the_lesson_columns` and `::test_a_damaged_provenance_reads_as_not_recorded` cover those readers, and the mixed-project tests there the project filter. Every release writes a claim's ledger row in the claim's transaction, so the ledger backfill's positive branch stays covered by the synthetic tests in `test_board.py`; no release writer produces damaged JSON or a malformed evidence entry either | HEAD's first open (columns and tables added, every released cell kept, a second open a no-op), `Board.get` / `list` / `transitions` (`_row_to_item`, `_load_list`, `_load_evidence`) compared field by field with what the release's own interpreter read from the same database and with the raw cells, `board list` / `show`, `active_decisions` and `_row_to_decision` on every row (retired ones included), `board decisions`, `project_lessons` (empty: no released decision is a lesson), `stats` at fixed clocks including both sides of the aging cutoff, and `board stats` at a fresh and an aged clock; the human path on released rows: `update --state done` counting stored evidence or refused without it, `--sign-off`, `--clear-human-required`, an annotate keeping a released lease, `decide --supersedes` in and out of scope, a re-import skipped, and refused when the stored provenance differs. HEAD operating a released board: `board run` dispatch (FIFO order, skipping human-required items and unmet or missing dependencies, `--goal`, `--id`) with the released handoff, inputs and active decisions in the prompt and the run's outcome added to the released row, an agent's `done` counted only with this run's gate; a released running lease reclaimed exactly at its timeout (the ledger's `reclaimed_at` stamped, on v0.1.2 in the column HEAD added), redispatch counted, `apply_update`, the crash block and `renew_claim` fenced by the released lease; the scratch GC over the released ledger (purged runs never collected, a live lease never, a reclaimed run after one lease timeout of grace, a failed purge scheduled and then cleared in the columns HEAD added); `board compact` of released history (stats unchanged, rollups and counters added to, a cutoff between two claims); the gateway `board_list` / `board_get` / `board_stats`, `dashboard.take_snapshot` and the TUI board tab; a lesson promoted onto a released board leaves the released decisions unbound, and cannot supersede one (scope refused before project). Not covered: a run v0.1.2 reclaimed but never purged (its `reclaimed_at` is NULL, so HEAD collects it with no grace; v0.1.2 had none either, and its own GC purged every such run in the fixtures); `room promote` onto a released board (needs a room; `test_lessons.py` covers the CLI); the memory a released board run wrote (outside `board.db`) | `test_frozen_board.py`, `test_frozen_board_ops.py` (v0.1.2, v0.2.0, v0.3.0) | -| Memory backends | Mem0 and LangGraph stored payloads | the backends' read paths | not yet | +| Memory (memtomem) | the memtomem store a release's CLI writes through its default backend (`mm.db` with the WAL a SIGKILLed board run leaves, the per-namespace day files and their lock sidecars), one store per release holding every scenario: `run` under each strategy (private rows and their `shared` copies with `task:` and `shared-from=` tags and every kind tag), a failed run (no row), Unicode with CRLF, `###` headings, a body split into two chunks, a finished `board run` (its `board-run:` scratch row and the `board-result:` row), `room apply` (`room-result`), and last a `board run` SIGKILLed in its second stage (its scratch row only in the WAL, its lease live on the board). The store is bound to the directory it was written in by `chunks.source_file` and its FTS mirror only; the real-engine tests rebind a copy with the two statements memtomem itself uses and assert every other cell unchanged. `release-read.json` is what the release's own interpreter read from every row | without an engine: the stored rows against the scenario definitions, HEAD's day-file and namespace names, the location binding. With real memtomem (`SYNCMILL_TEST_MEMTOMEM_REAL=1`, CI's `memory-backend-real` job): HEAD's first and second open of a moved copy (rows unchanged, read out of the WAL), `MemtomemBackend.get`, `search` (every namespace) and `count_namespace` compared with the release's read, `search` with each later-phase kind filter, `search_multi`, `status`, `share_chunk` and `add_and_share` beside released rows (a later day and the release's own day), `purge_namespace` of a released scratch namespace, a reindex of the released day files (no row changes), `SyncmillMemory.search_context` (each later-phase filter, the agent namespace, a board-scoped view), `search_shared` / `get_shared` / `shared_stats`, the gateway `shared_*` tools, `syncmill status`, each strategy's recall in a HEAD run (the filters it sends, the released rows they return, each handed to that phase's agents), a HEAD `run` and a room round handed a released result, the store found at the project default location through `configure_project_memory`, and a released lease reclaimed with its scratch namespace purged by the board GC. Not covered: the schema 1 stores of v0.1.2 to v0.1.4 (memtomem 0.3.x, migrated on open; v0.1.2 and v0.1.4 measured as two different layouts, v0.1.3 unmeasured; a follow-up); `memory migration --from memtomem` over these stores (with Mem0 and LangGraph); stores with dense vectors (the frozen stores record `embedding_provider = none`); `sessions` / `session_events` rows (no reader); an external watcher reindexing a released day file; memtomem versions no syncmill release locked | `test_frozen_memory.py`, `test_frozen_memory_real.py` (v0.2.0, v0.3.0) | +| Memory backends (Mem0, LangGraph) | Mem0 and LangGraph stored payloads | the backends' read paths, `memory migration` into memtomem | not yet | | TUI jobs | job documents, `schema_version` 1 and 2 | `JobStore.list_jobs` | not yet | | Run envelope | report run directories as a release's `run` and `board run` leave them with recording on: `envelope.json` (completed, no change, route failure, gate passed and failed, a compete team, a file trace, a Phoenix export error, a trace error, breaker and multiple degradations, a board block, the skeleton a SIGKILL leaves, a SIGINT's finalized crash), `result.json`, `trace.otlp.json`, and a trace-only run with no envelope; v0.1.2 wrote no `.syncmill-run-dir` sentinel. Under `/preflight/`, its own reports root: run dirs with a real preflight block from the release's `run` against a fake `toolgraph` answering with the release's vendored goldens (advisory ok, drift, unresolved, unmapped, error, timeout; strict allow, warn, block, timeout, unresolved, unavailable under both policies, two identities, a generation mismatch, an unmapped participant; from v0.2.0 control-plan allow, findings, error, timeout, both modes), the persistence failures reached by making the release's own writer fail one write (v0.1.2 and v0.2.0+ leave different files), and a SIGKILL after a strict preflight; `preflight.json`, `preflight/eval-NNN.json`, `control-plan.json`, `control-preflight.json`. A few producer replies are synthetic and named in its `index.json` | HEAD's `contracts/run-envelope.schema.json` (and the release's own, frozen beside it), `load_envelope` returning the stored document, `report show` and `report list` compared with what the release's own CLI printed, including the refusal for a run without an envelope, the TUI Reports tab and the dashboard REPORT pane; retention ownership (`_is_run_dir`) through `RunReporter.start` and the Supervisor's trace-only sweep: a sentinel or, for v0.1.2, an envelope with syncmill's `kind` naming its own directory makes a run dir removable, and a v0.1.2 trace-only run dir (neither) is never removed; a custom `trace.dir` is never swept; for the preflight runs, the same schema, loader, `report show` / `report list` and UI checks, and retention removing a released dir whole with its nested `preflight/` directory. Not covered: `trace.otlp.json` semantics (tracegraph's reader); `report list` also lists a foreign directory holding any nonempty JSON-object `envelope.json` (observed, unchanged); no HEAD code reads the preflight files back, so their checks are fixture integrity; `report show` prints `Preflight: ok` for a strict run that enforcement blocked (observed, unchanged) | `test_frozen_envelope.py`, `test_frozen_preflight_envelope.py` (v0.1.2, v0.2.0, v0.3.0) | diff --git a/tests/fixtures/persisted/memory/freeze.py b/tests/fixtures/persisted/memory/freeze.py new file mode 100644 index 0000000..58681ae --- /dev/null +++ b/tests/fixtures/persisted/memory/freeze.py @@ -0,0 +1,720 @@ +"""Produce the frozen memtomem stores under this directory (#271). + +Run once per release. This script itself runs under any Python 3; everything +that touches the store is the release's own code: its CLI writes the rows and +its interpreter (`/.venv`) reads them back, never the current +source. The output directory must not exist; frozen fixtures are never +regenerated, and a run that stops early leaves no output directory. + + git worktree add --detach /tmp/wt-v0.3.0 v0.3.0 + (cd /tmp/wt-v0.3.0 && uv sync --frozen --no-dev) + python tests/fixtures/persisted/memory/freeze.py \\ + --release-root /tmp/wt-v0.3.0 --out tests/fixtures/persisted/memory/v0.3.0 + +The released CLI writes every row through its default backend, memtomem at the +version the release locked: `run` under each strategy, `board run`, and +`room create` / `round` / `select` / `apply`, with fake `codex` and `kimi` +binaries on PATH. One store comes out, with every scenario in it one after +another. The last is a `board run -s pipeline` whose CLI is SIGKILLed while its +second stage works, so the store is copied as that kill left it (its newest +row only in the WAL, which is checked; a live lease on the board) and never +reopened. + +Each fake reply carries a common token and a token of its own scenario. The +stores are written with no embedding provider, so a search finds a row only +through a word, and the tests address the store, or one scenario, by those. + +Generation fails unless every scenario left exactly the rows its definition +names (`_require`), so a release that writes something else cannot silently +narrow the coverage. The store is copied byte for byte as soon as the last +scenario ends. Only then does the release's own interpreter read the store it +wrote, in place, and record what it makes of every row: that is the expected +interpretation the tests hold HEAD's readers to. `index.json` holds the +scenario definitions and a sha256 of every file. +""" + +from __future__ import annotations + +import argparse +import hashlib +import json +import os +import re +import shutil +import signal +import sqlite3 +import subprocess +import sys +import tempfile +import time +from pathlib import Path + +ANCHOR = "frozenmemoryanchor" +TREE = {"calc.py": "def add(a, b):\n return a - b\n"} +PROJECT_ID = "frozen-memory" + +# FAKE_PLAN = {binary: {"token", "edit": [call...], "fail": [...], "hang": [...], +# "replies": {call: text}}}. Calls are numbered per binary and per scenario. A +# reply not listed is " (fake) call : ". +FAKE_AGENT = r''' +import json, os, sys, time +from pathlib import Path +BINARY = os.path.basename(sys.argv[0]) +args = sys.argv[1:] +if args[:2] == ["login", "status"] or args[:1] in (["--version"], ["--help"]): + print(BINARY + " (fake) - logged in"); sys.exit(0) +plan = json.loads(os.environ.get("FAKE_PLAN") or "{}").get(BINARY, {}) +calls = Path(os.environ["FAKE_CALLS"]) +n = 1 +while True: + try: + os.close(os.open(calls / (BINARY + "-" + str(n)), os.O_CREAT | os.O_EXCL | os.O_WRONLY)) + break + except FileExistsError: + n += 1 +step = str(n) +if step in plan.get("hang", []): + marker = Path(os.environ["FAKE_STARTED"]) / BINARY + marker.with_suffix(".tmp").write_text(str(os.getpid())) + os.replace(marker.with_suffix(".tmp"), marker) + time.sleep(120); sys.exit(1) +if step in plan.get("fail", []): + sys.stderr.write(BINARY + " (fake): refused\n"); sys.exit(1) +if step in plan.get("edit", []): + body = "a + b" if BINARY == "codex" else "b + a" + Path("calc.py").write_text("def add(a, b):\n return " + body + "\n", encoding="utf-8") +message = plan.get("replies", {}).get(step) +if message is None: + message = "%s (fake) call %d: %s %s" % (BINARY, n, os.environ["FAKE_ANCHOR"], plan.get("token", "")) +if BINARY == "codex": + events = [ + {"type": "thread.started", "thread_id": "fake-codex-thread"}, + {"type": "item.completed", "item": {"type": "agent_message", "text": message}}, + {"type": "turn.completed", "usage": {"input_tokens": 1, "output_tokens": 1}}, + ] +else: + events = [ + {"role": "assistant", "content": message}, + {"role": "meta", "type": "session.resume_hint", "session_id": "fake-kimi-session", + "content": "To resume this session: kimi -r fake-kimi-session"}, + ] +for event in events: + print(json.dumps(event)) +''' + +# Runs inside the RELEASED interpreter on the store it wrote, in place: what +# the release itself reads from every row. argv: db, memory dir, anchor, and a +# JSON list of the kind tags to search by. +RELEASE_READ = r''' +import inspect, json, sqlite3, sys +from syncmill.config import MemoryConfig +from syncmill.memory import run_async +from syncmill.memory_backend import MemtomemBackend +db, mem, anchor, kinds = sys.argv[1], sys.argv[2], sys.argv[3], json.loads(sys.argv[4]) +conn = sqlite3.connect("file:" + db + "?mode=ro", uri=True) +ids = [r[0] for r in conn.execute("SELECT id FROM chunks ORDER BY rowid")] +namespaces = sorted({r[0] for r in conn.execute("SELECT namespace FROM chunks")}) +conn.close() +backend = MemtomemBackend(MemoryConfig(db_path=db, memory_dir=mem)) +has_filter = "tag_filter" in inspect.signature(backend.search).parameters + + +def plain(row): + return None if row is None else {k: row[k] for k in sorted(row) if k not in ("score", "rank")} + + +read = {"get": {}, "count": {}, "search": {}, "search_by_kind": {}} +try: + for chunk_id in ids: + read["get"][chunk_id] = plain(run_async(backend.get(chunk_id))) + for ns in namespaces: + read["count"][ns] = run_async(backend.count_namespace(ns)) + rows = run_async(backend.search(anchor, namespace=ns, top_k=200)) + read["search"][ns] = sorted(r["id"] for r in rows) + if has_filter: + read["search_by_kind"][ns] = { + kind: sorted( + r["id"] for r in run_async( + backend.search(anchor, namespace=ns, top_k=200, tag_filter=kind) + ) + ) + for kind in kinds + } +finally: + run_async(backend.close()) +print(json.dumps(read, ensure_ascii=False, sort_keys=True)) +''' + +GIT_ENV = { + "GIT_AUTHOR_NAME": "frozen", "GIT_AUTHOR_EMAIL": "frozen@example.invalid", + "GIT_COMMITTER_NAME": "frozen", "GIT_COMMITTER_EMAIL": "frozen@example.invalid", + "GIT_AUTHOR_DATE": "2026-01-01T00:00:00Z", "GIT_COMMITTER_DATE": "2026-01-01T00:00:00Z", +} + +KINDS = [ + "task-result", "room-result", "pipeline-stage", "council-proposal", + "council-critique", "decompose-plan", "decompose-subtask", +] + +UNICODE_REPLY = ( + " " + ANCHOR + " tokunicode 한글 본문 と日本語 🙂\r\nsecond line after CRLF\r\n" + + "가나다라마바사 " * 170 + "tail-after-the-cut " +) +HEADINGS_REPLY = ( + ANCHOR + " tokheadings summary line\n\n" + "### Findings\n\n" + ANCHOR + " tokheadings findings. " + + " ".join(["The add function subtracted its second argument."] * 8) + "\n\n" + "### Next steps\n\n" + ANCHOR + " tokheadings steps. " + + " ".join(["Add a test for negative numbers and for zero."] * 8) +) +LONG_PROMPT = ( + ANCHOR + " toklong fix add in calc.py.\n\n" + + "\n\n".join(f"requirement-{i:03d} keeps the sum of two integers exact" for i in range(60)) +) +LONG_SPLIT = "requirement-037 " +SUBTASKS = [ + f"alpha part of the work {ANCHOR} tokdecompose", + f"beta part of the work {ANCHOR} tokdecompose", +] + + +def default_reply(binary: str, call: int, token: str) -> str: + return f"{binary} (fake) call {call}: {ANCHOR} {token}" + + +def task_body(prompt: str, agent: str, output: str, files: bool) -> str: + """The body v0.2.0 and later give a shared result (memory.share_result).""" + body = ( + f"**Task Result**\n\n**Prompt:** {prompt}\n\n" + f"**Agent:** {agent}\n\n**Output:**\n{output[:1000]}" + ) + return body + ("\n\n**Files changed:** calc.py" if files else "") + + +def board_body(item_id: str, task: str, output: str) -> str: + return ( + f"**Board Item Result**\n\n**Item:** {item_id}\n\n" + f"**Task:** {task}\n\n**Output:**\n{output[:1000]}" + ) + + +def pair(kind: str, agent: str, body: str) -> list[dict]: + """A result shared from an agent's private namespace: the private row and + its copy in `shared`, which carries one more tag naming the private row.""" + tags = sorted([kind, agent, "task:*"]) + return [ + {"namespace": f"agent-runtime:{agent}", "tags": tags, "body": body}, + {"namespace": "shared", "tags": sorted([*tags, "shared-from=*"]), "body": body}, + ] + + +def _sha256(path: Path) -> str: + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def _normal_tags(raw: str) -> list[str]: + out = [] + for tag in json.loads(raw): + if re.fullmatch(r"task:[0-9a-f-]{36}", tag): + tag = "task:*" + elif re.fullmatch(r"shared-from=[0-9a-f-]{36}", tag): + tag = "shared-from=*" + out.append(tag) + return sorted(out) + + +def _query(db: Path, sql: str, params: tuple = (), *, wal: bool = True) -> list[tuple]: + """Run one query on a throwaway copy of a database (its WAL with it, unless + ``wal`` is false), so a database a release wrote is never opened by this + script and a reader always sees what the release committed.""" + with tempfile.TemporaryDirectory() as tmp: + parts = db.parent.glob(db.name + "*") if wal else [db] + for part in parts: + shutil.copy(part, Path(tmp) / part.name) + conn = sqlite3.connect(Path(tmp) / db.name) + try: + return conn.execute(sql, params).fetchall() + finally: + conn.close() + + +def _raw_rows(db: Path) -> dict[str, tuple]: + """The chunk rows of a store as stored: id -> (namespace, tags JSON, + content, source_file).""" + return { + r[0]: tuple(r[1:]) + for r in _query( + db, "SELECT id, namespace, tags, content, source_file FROM chunks ORDER BY rowid" + ) + } + + +def _normal(raw: tuple) -> dict: + """A stored row the way the scenario definitions name one.""" + return {"namespace": raw[0], "tags": _normal_tags(raw[1]), "content": raw[2], + "source": Path(raw[3]).name} + + +def _require(name: str, new: list[dict], expected: list[dict]) -> None: + def key(row: dict) -> tuple: + return (row["namespace"], tuple(row["tags"]), row["body"]) + + got = sorted( + ({"namespace": r["namespace"], "tags": r["tags"], "body": r["content"]} for r in new), + key=key, + ) + want = sorted(expected, key=key) + if got != want: + sys.exit( + f"{name}: the release left other rows than the scenario names\n" + f"--- left\n{json.dumps(got, ensure_ascii=False, indent=1)}\n" + f"--- named\n{json.dumps(want, ensure_ascii=False, indent=1)}" + ) + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--release-root", type=Path, required=True) + parser.add_argument("--out", type=Path, required=True) + args = parser.parse_args() + release = args.release_root.resolve() + # The parent is resolved, not the target: a symlink there must be refused, + # not followed. + out = args.out.absolute().parent.resolve() / args.out.name + + def refuse_existing() -> None: + if out.exists() or out.is_symlink(): + sys.exit(f"{out} exists; frozen fixtures are never regenerated") + + refuse_existing() + python = release / ".venv" / "bin" / "python" + syncmill = release / ".venv" / "bin" / "syncmill" + + def metadata(package: str) -> str: + return subprocess.run( + [str(python), "-c", + f"import importlib.metadata as m; print(m.version('{package}'))"], + check=True, capture_output=True, text=True, + ).stdout.strip() + + version = metadata("syncmill") + if version not in ("0.2.0", "0.3.0"): + sys.exit(f"no scenario definitions for syncmill {version} yet") + with tempfile.TemporaryDirectory() as tmp: + stage = Path(tmp).resolve() / "frozen" + _generate(Path(tmp).resolve(), stage, python, syncmill, version, metadata("memtomem")) + # Publish whole: a hidden sibling first (fixture discovery skips it), + # then one rename into place, the target checked again just before. + # The sibling is removed on any failure, an interrupt included. + out.parent.mkdir(parents=True, exist_ok=True) + partial = Path(tempfile.mkdtemp(dir=out.parent, prefix=f".{out.name}.partial-")) + try: + shutil.copytree(stage, partial / "frozen") + refuse_existing() + (partial / "frozen").rename(out) + finally: + shutil.rmtree(partial) + print(f"frozen {version} into {out}") + + +def _generate(box: Path, out: Path, python: Path, syncmill: Path, + version: str, memtomem: str) -> None: + repo, home, state, fakebin, started = ( + box / n for n in ("repo", "home", "state", "fakebin", "started") + ) + for folder in (repo, home, state, fakebin, started): + folder.mkdir() + for binary in ("codex", "kimi"): + (fakebin / binary).write_text(f"#!{sys.executable}\n" + FAKE_AGENT, encoding="utf-8") + (fakebin / binary).chmod(0o755) + (fakebin / "python").symlink_to(sys.executable) + common_env = { + "HOME": str(home), + "XDG_CONFIG_HOME": str(home / ".config"), + "PATH": os.pathsep.join([str(fakebin), "/usr/bin", "/bin"]), + "TMPDIR": str(box), + "GIT_CONFIG_NOSYSTEM": "1", + "PYTHONDONTWRITEBYTECODE": "1", + "FAKE_STARTED": str(started), + "FAKE_ANCHOR": ANCHOR, + "SYNCMILL_AGENT_PRIORITY": json.dumps(["codex", "kimi-code"]), + "SYNCMILL_CLAUDE__ENABLED": "false", + "SYNCMILL_COUNCIL__ROUNDS": "2", + "SYNCMILL_WORKSPACE__ROOT": str(state / "workspaces"), + "SYNCMILL_BREAKER__STATE_PATH": str(state / "breaker.json"), + "SYNCMILL_TUI__STATE_DIR": str(state / "tui"), + **GIT_ENV, + } + + def init_repo(root: Path) -> None: + def git(*argv: str) -> None: + subprocess.run(["git", *argv], cwd=root, env=common_env, check=True, + capture_output=True) + git("init", "-q", "-b", "main") + for name, text in TREE.items(): + (root / name).write_text(text, encoding="utf-8") + git("add", "-A") + git("commit", "-q", "-m", "frozen tree") + + init_repo(repo) + out.mkdir(parents=True) + index: dict = { + "release": version, + "memtomem": memtomem, + "anchor": ANCHOR, + "generating_root": str(box), + "stores": {}, + "scenarios": {}, + } + counter = [0] + + class Store: + def __init__(self, name: str, root: Path, db: Path, mem: Path, env: dict): + self.name, self.root, self.db, self.mem = name, root, db, mem + self.env = {**common_env, **env} + self.known: dict[str, tuple] = {} + + def sm(self, scenario: str, *argv: str, plan: dict | None = None, + ok: bool = True, cwd: Path = repo) -> str: + calls = state / f"calls-{counter[0]}" + counter[0] += 1 + calls.mkdir() + done = subprocess.run( + [str(syncmill), *argv], cwd=cwd, + env={**self.env, "FAKE_PLAN": json.dumps(plan or {}), + "FAKE_CALLS": str(calls)}, + capture_output=True, text=True, + ) + if ok and done.returncode != 0: + sys.exit(f"{scenario}: {argv}: {done.stdout}{done.stderr}") + if not ok and done.returncode == 0: + sys.exit(f"{scenario}: {argv} was expected to fail: {done.stdout}") + return done.stdout + + def new_rows(self) -> list[dict]: + """The rows added since the last call. Every earlier row must still + be there exactly as stored (ids in its tags and its full source + path included): a scenario only adds.""" + rows = _raw_rows(self.db) if self.db.exists() else {} + changed = { + chunk_id: (row, rows.get(chunk_id)) + for chunk_id, row in self.known.items() if rows.get(chunk_id) != row + } + if changed: + sys.exit(f"an earlier row was changed or removed: " + f"{json.dumps(changed, ensure_ascii=False, indent=1)}") + new = [_normal(row) for chunk_id, row in rows.items() if chunk_id not in self.known] + self.known = rows + return new + + def record(self, scenario: str, expected: list[dict], **facts) -> None: + _require(scenario, self.new_rows(), expected) + index["scenarios"][scenario] = {"store": self.name, "rows": expected, **facts} + + def freeze(self, *, board: bool) -> None: + target = out / self.name + shutil.copytree(self.root, target) + index["stores"][self.name] = { + "db": str((target / self.db.relative_to(self.root)).relative_to(out)), + "mem": str((target / self.mem.relative_to(self.root)).relative_to(out)), + "board": f"{self.name}/board.db" if board else None, + "root": str(self.root), + } + + def explicit_store(name: str) -> Store: + root = state / name + root.mkdir() + return Store(name, root, root / "mm.db", root / "mem", { + "SYNCMILL_PROJECT__ID": PROJECT_ID, + "SYNCMILL_RUNS__ROOT": str(state / f"runs-{name}"), + "SYNCMILL_MEMORY__DB_PATH": str(root / "mm.db"), + "SYNCMILL_MEMORY__MEMORY_DIR": str(root / "mem"), + "SYNCMILL_BOARD__ENABLED": "true", + "SYNCMILL_BOARD__DB_PATH": str(root / "board.db"), + "SYNCMILL_ROOMS__ENABLED": "true", + }) + + def restore_tree() -> None: + subprocess.run(["git", "checkout", "--", "."], cwd=repo, env=common_env, + check=True, capture_output=True) + + main_store = explicit_store("store") + + prompt = f"{ANCHOR} tokroute fix add in calc.py" + plan = {"codex": {"token": "tokroute", "edit": ["1"]}} + main_store.sm("route", "run", prompt, "-a", "codex", plan=plan) + main_store.record( + "route", + pair("task-result", "codex", + task_body(prompt, "codex", default_reply("codex", 1, "tokroute"), True)), + prompt=prompt, token="tokroute", + ) + + prompt = f"{ANCHOR} tokpipeline fix add in calc.py" + plan = {"codex": {"token": "tokpipeline", "edit": ["1"]}, + "kimi": {"token": "tokpipeline", "edit": ["1"]}} + main_store.sm("pipeline", "run", prompt, "-s", "pipeline", plan=plan) + main_store.record( + "pipeline", + # A stage before the last is shared before its changes are collected. + pair("pipeline-stage", "codex", + task_body(prompt, "codex", default_reply("codex", 1, "tokpipeline"), False)) + + pair("task-result", "kimi-code", + task_body(prompt, "kimi-code", default_reply("kimi", 1, "tokpipeline"), True)), + prompt=prompt, token="tokpipeline", + ) + + prompt = f"{ANCHOR} tokcompete fix add in calc.py" + plan = {"codex": {"token": "tokcompete", "edit": ["1"]}, + "kimi": {"token": "tokcompete", "edit": ["1"]}} + main_store.sm("compete", "run", prompt, "-s", "compete", plan=plan) + main_store.record( + "compete", + pair("task-result", "codex", + task_body(prompt, "codex", default_reply("codex", 1, "tokcompete"), True)), + prompt=prompt, token="tokcompete", + ) + + # Two critique rounds (SYNCMILL_COUNCIL__ROUNDS): calls 1 propose, 2 and 3 + # critique, 4 synthesize. Only the synthesis edits the tree. + prompt = f"{ANCHOR} tokcouncil fix add in calc.py" + plan = {"codex": {"token": "tokcouncil", "edit": ["4"]}, + "kimi": {"token": "tokcouncil", "edit": ["4"]}} + main_store.sm("council", "run", prompt, "-s", "council", plan=plan) + expected: list[dict] = [] + for agent, binary in (("codex", "codex"), ("kimi-code", "kimi")): + expected += pair("council-proposal", agent, task_body( + prompt, agent, default_reply(binary, 1, "tokcouncil"), False)) + for call in (2, 3): + expected += pair("council-critique", agent, task_body( + prompt, agent, default_reply(binary, call, "tokcouncil"), False)) + expected += pair("task-result", "codex", task_body( + prompt, "codex", default_reply("codex", 4, "tokcouncil"), True)) + main_store.record("council", expected, prompt=prompt, token="tokcouncil") + + # codex call 1 plans (a JSON array, which is all the plan row keeps), then + # codex takes the first subtask and kimi the second, then both synthesize. + prompt = f"{ANCHOR} tokdecompose fix add in calc.py" + plan = {"codex": {"token": "tokdecompose", "edit": ["3"], + "replies": {"1": json.dumps(SUBTASKS)}}, + "kimi": {"token": "tokdecompose", "edit": ["2"]}} + main_store.sm("decompose", "run", prompt, "-s", "decompose", plan=plan) + main_store.record( + "decompose", + pair("decompose-plan", "codex", task_body( + prompt, "codex", json.dumps(SUBTASKS, ensure_ascii=False), False)) + + pair("decompose-subtask", "codex", task_body( + prompt, "codex", default_reply("codex", 2, "tokdecompose"), False)) + + pair("decompose-subtask", "kimi-code", task_body( + prompt, "kimi-code", default_reply("kimi", 1, "tokdecompose"), False)) + + pair("task-result", "codex", task_body( + prompt, "codex", default_reply("codex", 3, "tokdecompose"), True)), + prompt=prompt, token="tokdecompose", subtasks=SUBTASKS, + ) + + # The agent's reply is cut at 1000 characters after its outer whitespace + # is dropped; memtomem reads the day file in text mode, so the CRLF pair + # inside the reply reaches the row as LF. + prompt = f"{ANCHOR} tokunicode say something long" + plan = {"codex": {"token": "tokunicode", "replies": {"1": UNICODE_REPLY}}} + main_store.sm("unicode", "run", prompt, "-a", "codex", plan=plan) + stored_reply = UNICODE_REPLY.strip()[:1000].replace("\r\n", "\n") + main_store.record( + "unicode", + pair("task-result", "codex", task_body(prompt, "codex", stored_reply, False)), + prompt=prompt, token="tokunicode", reply=UNICODE_REPLY, + ) + + prompt = f"{ANCHOR} tokheadings review calc.py" + plan = {"codex": {"token": "tokheadings", "replies": {"1": HEADINGS_REPLY}}} + main_store.sm("headings", "run", prompt, "-a", "codex", plan=plan) + # memtomem keeps this body in one chunk: the `###` lines stay inside it. + main_store.record( + "headings", + pair("task-result", "codex", task_body(prompt, "codex", HEADINGS_REPLY, False)), + prompt=prompt, token="tokheadings", reply=HEADINGS_REPLY, + ) + + plan = {"codex": {"token": "toklong"}} + main_store.sm("longprompt", "run", LONG_PROMPT, "-a", "codex", plan=plan) + # One private entry, two chunks: memtomem cuts this body at the blank line + # before LONG_SPLIT. Each chunk gets its own copy in `shared`, and each + # copy is an entry of its own there. + body = task_body(LONG_PROMPT, "codex", default_reply("codex", 1, "toklong"), False) + head, tail = body.split("\n\n" + LONG_SPLIT, 1) + main_store.record( + "longprompt", + pair("task-result", "codex", head) + pair("task-result", "codex", LONG_SPLIT + tail), + prompt=LONG_PROMPT, token="toklong", private_chunks_per_entry=2, + ) + + prompt = f"{ANCHOR} tokfailed fix add in calc.py" + plan = {"codex": {"token": "tokfailed", "fail": ["1"]}} + main_store.sm("failed", "run", prompt, "-a", "codex", plan=plan, ok=False) + main_store.record("failed", [], prompt=prompt, token="tokfailed") + + task_text = f"{ANCHOR} tokboard fix add in calc.py" + plan = {"codex": {"token": "tokboard", "edit": ["1"]}} + line = main_store.sm("board-done", "board", "add", task_text, "--goal", "frozen") + item_id = line.split("added item ")[1].split()[0] + main_store.sm("board-done", "board", "run", "--id", item_id, plan=plan) + scratch = [r for r in main_store.new_rows()] + runs = sorted({r["namespace"] for r in scratch if r["namespace"].startswith("board-run:")}) + if len(runs) != 1: + sys.exit(f"board-done: expected one scratch namespace, found {runs}") + reply = default_reply("codex", 1, "tokboard") + board_expected = [ + {"namespace": runs[0], "tags": sorted(["task-result", "codex", "task:*"]), "body": None}, + {"namespace": "shared", "tags": [f"board-result:{item_id}"], + "body": board_body(item_id, task_text, reply)}, + ] + # The scratch row's prompt is the rendered board item, the release's own + # text; only its frame is named here. + found = sorted(scratch, key=lambda r: r["namespace"] != runs[0]) + if ( + len(found) != 2 + or found[0]["tags"] != board_expected[0]["tags"] + or not found[0]["content"].startswith("**Task Result**\n\n**Prompt:** ") + or not found[0]["content"].endswith( + f"**Agent:** codex\n\n**Output:**\n{reply}\n\n**Files changed:** calc.py") + or task_text not in found[0]["content"] + or {"namespace": found[1]["namespace"], "tags": found[1]["tags"], + "body": found[1]["content"]} != board_expected[1] + ): + sys.exit(f"board-done: unexpected rows {json.dumps(found, ensure_ascii=False, indent=1)}") + board_expected[0]["body"] = found[0]["content"] + board_expected[0]["body_is_release_text"] = True + index["scenarios"]["board-done"] = { + "store": "store", "rows": board_expected, "task": task_text, "token": "tokboard", + "item_id": item_id, "run_id": runs[0].split(":", 1)[1], + } + restore_tree() + + prompt = f"{ANCHOR} tokroom fix add in calc.py" + plan = {"codex": {"token": "tokroom", "edit": ["1"]}, + "kimi": {"token": "tokroom", "edit": ["1"]}} + room_id = main_store.sm("room-apply", "room", "create", prompt, + "-a", "codex", "-a", "kimi-code").split()[0] + main_store.sm("room-apply", "room", "round", room_id, plan=plan) + rooms_db = state / "runs-store" / PROJECT_ID / "rooms" / "rooms.sqlite3" + candidates = _query( + rooms_db, + "SELECT id, member_id FROM candidates WHERE room_id = ? AND eligible = 1 " + "ORDER BY member_id", (room_id,), + ) + if not candidates or candidates[0][1] != "codex": + sys.exit(f"room-apply: no eligible codex candidate: {candidates}") + main_store.sm("room-apply", "room", "select", room_id, candidates[0][0]) + main_store.sm("room-apply", "room", "apply", room_id) + main_store.record( + "room-apply", + pair("room-result", "codex", + task_body(prompt, "codex", default_reply("codex", 1, "tokroom"), True)), + prompt=prompt, token="tokroom", room_id=room_id, + ) + restore_tree() + + # ---- last: a board run SIGKILLed during its second stage ---------------- + killed = main_store + task_text = f"{ANCHOR} tokkilled fix add in calc.py" + line = killed.sm("board-killed", "board", "add", task_text, "--goal", "frozen") + item_id = line.split("added item ")[1].split()[0] + for marker in started.iterdir(): + marker.unlink() + calls = state / "calls-killed" + calls.mkdir() + plan = {"codex": {"token": "tokkilled", "edit": ["1"]}, + "kimi": {"token": "tokkilled", "hang": ["1"]}} + proc = subprocess.Popen( + [str(syncmill), "board", "run", "--id", item_id, "-s", "pipeline"], + cwd=repo, env={**killed.env, "FAKE_PLAN": json.dumps(plan), "FAKE_CALLS": str(calls)}, + stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, start_new_session=True, + ) + def kill_group() -> None: + try: + os.killpg(proc.pid, signal.SIGKILL) + except ProcessLookupError: + pass + + deadline = time.monotonic() + 120 + while not (started / "kimi").exists(): + if proc.poll() is not None or time.monotonic() > deadline: + # The whole group, or an agent still holding the output pipe + # would keep the read below from ever returning. + kill_group() + try: + output = proc.communicate(timeout=30)[0] + except subprocess.TimeoutExpired: + output = "(no output: the pipe is still held open)" + sys.exit(f"board-killed: the second stage never started: {output}") + time.sleep(0.05) + agent_pid = int((started / "kimi").read_text()) + kill_group() + proc.wait() + try: + os.kill(agent_pid, signal.SIGKILL) + except ProcessLookupError: + pass + proc.stdout.close() + scratch = killed.new_rows() + runs = sorted({r["namespace"] for r in scratch}) or [""] + reply = default_reply("codex", 1, "tokkilled") + if ( + len(scratch) != 1 + or not runs[0].startswith("board-run:") + or scratch[0]["tags"] != sorted(["pipeline-stage", "codex", "task:*"]) + or not scratch[0]["content"].endswith(f"**Agent:** codex\n\n**Output:**\n{reply}") + ): + sys.exit(f"board-killed: unexpected rows {json.dumps(scratch, ensure_ascii=False, indent=1)}") + # The kill left the stage's row in the WAL only: the main file alone does + # not have it. + in_main = _query(killed.db, "SELECT COUNT(*) FROM chunks WHERE namespace = ?", + (runs[0],), wal=False) + if in_main != [(0,)]: + sys.exit(f"board-killed: the scratch row is already in the main file: {in_main}") + (lease,) = _query( + killed.root / "board.db", + "SELECT state, lease_run_id, claimed_at FROM work_items WHERE id = ?", (item_id,), + ) + if lease[0] != "running" or f"board-run:{lease[1]}" != runs[0]: + sys.exit(f"board-killed: the board holds no live lease for the scratch run: {lease}") + index["scenarios"]["board-killed"] = { + "store": "store", "task": task_text, "token": "tokkilled", "item_id": item_id, + "run_id": lease[1], "claimed_at": lease[2], + "rows": [{"namespace": runs[0], "tags": scratch[0]["tags"], + "body": scratch[0]["content"], "body_is_release_text": True}], + } + restore_tree() + killed.freeze(board=True) + + # ---- what the release reads from the store it wrote, in place ----------- + read = {} + for store in (main_store,): + done = subprocess.run( + [str(python), "-c", RELEASE_READ, str(store.db), str(store.mem), ANCHOR, + json.dumps(KINDS)], + env=store.env, capture_output=True, text=True, + ) + if done.returncode != 0: + sys.exit(f"release read of {store.name}: {done.stdout}{done.stderr}") + read[store.name] = json.loads(done.stdout.strip().splitlines()[-1]) + (out / "release-read.json").write_text( + json.dumps(read, ensure_ascii=False, indent=1, sort_keys=True) + "\n", encoding="utf-8" + ) + + dates = sorted({ + p.name[:10] for p in out.rglob("*.md") if re.match(r"\d{4}-\d{2}-\d{2}\.", p.name) + }) + if len(dates) != 1: + sys.exit(f"the day files span more than one UTC date ({dates}); generate again") + index["date"] = dates[0] + index["files"] = { + str(p.relative_to(out)): _sha256(p) for p in sorted(out.rglob("*")) if p.is_file() + } + (out / "index.json").write_text( + json.dumps(index, ensure_ascii=False, indent=1, sort_keys=True) + "\n", encoding="utf-8" + ) + + +if __name__ == "__main__": + main() diff --git a/tests/fixtures/persisted/memory/v0.2.0/index.json b/tests/fixtures/persisted/memory/v0.2.0/index.json new file mode 100644 index 0000000..72386b2 --- /dev/null +++ b/tests/fixtures/persisted/memory/v0.2.0/index.json @@ -0,0 +1,545 @@ +{ + "anchor": "frozenmemoryanchor", + "date": "2026-11-15", + "files": { + "release-read.json": "cbe993608d232aed8ed61817044cff5fb28bf898070088ed38b196ea7c681973", + "store/board.db": "dc139e92ea8e42ec742684884cad2e423ec817bf710abf1c234a7e2ddfbe7931", + "store/board.db-shm": "3c2f111bea635c0350d29adae4a1bb4f041ad8910fb4e799bb8ab48421fac74b", + "store/board.db-wal": "027124379fe637c156a5b79a3607aa1b31336ece66d6f82b4007dfe8e43bb934", + "store/board.db.gc-lock": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "store/mem/.2026-11-15.agent-runtime.codex.md.lock": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "store/mem/.2026-11-15.agent-runtime.kimi-code.md.lock": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "store/mem/.2026-11-15.board-run.4c504769-9982-4419-beb1-9e45f2fb0295.md.lock": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "store/mem/.2026-11-15.board-run.fb601eff-5dfa-4474-ae36-d3fae997ff6c.md.lock": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "store/mem/.2026-11-15.shared.md.lock": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "store/mem/.syncmill-ns-2cb9e21c9dc66ab8dd6826fd7028e103.lock": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "store/mem/.syncmill-ns-42886aa205c9ff71943aece4ead9911c.lock": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "store/mem/.syncmill-ns-8ee87dbfcad6c9a732741f4837f06008.lock": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "store/mem/.syncmill-ns-a999ffded9900a8750c2f72fe167ec9b.lock": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "store/mem/.syncmill-ns-deea6649f1188da23bf56223e398ae36.lock": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "store/mem/2026-11-15.agent-runtime.codex.md": "303b9e060f3fa5f0e01d9bf89465c1dfea33008ffeda61e16bfd045e261673c0", + "store/mem/2026-11-15.agent-runtime.kimi-code.md": "d1f17cd7bd7f39f8515d7c3915da4f36e299a6b8a477a135cf9cf329a920da9c", + "store/mem/2026-11-15.board-run.4c504769-9982-4419-beb1-9e45f2fb0295.md": "e8f411ed5b8c1a7bf20fb374936b8d062640ccff424781d6904e0e43ff922f70", + "store/mem/2026-11-15.board-run.fb601eff-5dfa-4474-ae36-d3fae997ff6c.md": "955c31bbb7afa338df03f4009b53cf6224abd9aba48acd176a9e70f3692efcb0", + "store/mem/2026-11-15.shared.md": "aaf4032df8367e87977829922e754b629b6f13af6158bd4454d0b100492f6a7a", + "store/mm.db": "3f14e46144bf52dc1502e63ca7e4ab2437b362ea1c9061485c8bd5e4231443c9", + "store/mm.db-shm": "00691f49c116bf42d35f8740af97d81aeb725dd71b9a4d78b91698bbfe0703b8", + "store/mm.db-wal": "4fc9354df1ca2d9c3f6c1c17c55d32ee1e62b0e24b0d4b1e47a1140ee17c4337" + }, + "generating_root": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9", + "memtomem": "0.6.8", + "release": "0.2.0", + "scenarios": { + "board-done": { + "item_id": "b97d9de5-d8dd-40c7-8448-df510e41f5cf", + "rows": [ + { + "body": "**Task Result**\n\n**Prompt:** You are working on a tracked work-board item.\nGoal: frozen\n\nTask: frozenmemoryanchor tokboard fix add in calc.py\n\nWhen you finish, you MAY append ONE fenced block reporting the board update (every field optional):\n```syncmill-board\n{\"state\": \"review\", \"handoff\": \"\", \"outputs\": [\"\"], \"human_required\": false}\n```\nUse \"state\": \"blocked\" with a \"blocked_reason\" if you cannot proceed, or \"human_required\": true if a human must step in. Requesting \"done\" only takes effect if the work is independently verified (a passing quality gate or a human sign-off); otherwise it is recorded as \"review\".\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokboard\n\n**Files changed:** calc.py", + "body_is_release_text": true, + "namespace": "board-run:fb601eff-5dfa-4474-ae36-d3fae997ff6c", + "tags": [ + "codex", + "task-result", + "task:*" + ] + }, + { + "body": "**Board Item Result**\n\n**Item:** b97d9de5-d8dd-40c7-8448-df510e41f5cf\n\n**Task:** frozenmemoryanchor tokboard fix add in calc.py\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokboard", + "namespace": "shared", + "tags": [ + "board-result:b97d9de5-d8dd-40c7-8448-df510e41f5cf" + ] + } + ], + "run_id": "fb601eff-5dfa-4474-ae36-d3fae997ff6c", + "store": "store", + "task": "frozenmemoryanchor tokboard fix add in calc.py", + "token": "tokboard" + }, + "board-killed": { + "claimed_at": 1794753396.36356, + "item_id": "0af974b1-4d90-4e18-8c2e-874b95723876", + "rows": [ + { + "body": "**Task Result**\n\n**Prompt:** You are working on a tracked work-board item.\nGoal: frozen\n\nTask: frozenmemoryanchor tokkilled fix add in calc.py\n\nWhen you finish, you MAY append ONE fenced block reporting the board update (every field optional):\n```syncmill-board\n{\"state\": \"review\", \"handoff\": \"\", \"outputs\": [\"\"], \"human_required\": false}\n```\nUse \"state\": \"blocked\" with a \"blocked_reason\" if you cannot proceed, or \"human_required\": true if a human must step in. Requesting \"done\" only takes effect if the work is independently verified (a passing quality gate or a human sign-off); otherwise it is recorded as \"review\".\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokkilled", + "body_is_release_text": true, + "namespace": "board-run:4c504769-9982-4419-beb1-9e45f2fb0295", + "tags": [ + "codex", + "pipeline-stage", + "task:*" + ] + } + ], + "run_id": "4c504769-9982-4419-beb1-9e45f2fb0295", + "store": "store", + "task": "frozenmemoryanchor tokkilled fix add in calc.py", + "token": "tokkilled" + }, + "compete": { + "prompt": "frozenmemoryanchor tokcompete fix add in calc.py", + "rows": [ + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcompete fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokcompete\n\n**Files changed:** calc.py", + "namespace": "agent-runtime:codex", + "tags": [ + "codex", + "task-result", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcompete fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokcompete\n\n**Files changed:** calc.py", + "namespace": "shared", + "tags": [ + "codex", + "shared-from=*", + "task-result", + "task:*" + ] + } + ], + "store": "store", + "token": "tokcompete" + }, + "council": { + "prompt": "frozenmemoryanchor tokcouncil fix add in calc.py", + "rows": [ + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokcouncil", + "namespace": "agent-runtime:codex", + "tags": [ + "codex", + "council-proposal", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokcouncil", + "namespace": "shared", + "tags": [ + "codex", + "council-proposal", + "shared-from=*", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 2: frozenmemoryanchor tokcouncil", + "namespace": "agent-runtime:codex", + "tags": [ + "codex", + "council-critique", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 2: frozenmemoryanchor tokcouncil", + "namespace": "shared", + "tags": [ + "codex", + "council-critique", + "shared-from=*", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 3: frozenmemoryanchor tokcouncil", + "namespace": "agent-runtime:codex", + "tags": [ + "codex", + "council-critique", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 3: frozenmemoryanchor tokcouncil", + "namespace": "shared", + "tags": [ + "codex", + "council-critique", + "shared-from=*", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** kimi-code\n\n**Output:**\nkimi (fake) call 1: frozenmemoryanchor tokcouncil", + "namespace": "agent-runtime:kimi-code", + "tags": [ + "council-proposal", + "kimi-code", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** kimi-code\n\n**Output:**\nkimi (fake) call 1: frozenmemoryanchor tokcouncil", + "namespace": "shared", + "tags": [ + "council-proposal", + "kimi-code", + "shared-from=*", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** kimi-code\n\n**Output:**\nkimi (fake) call 2: frozenmemoryanchor tokcouncil", + "namespace": "agent-runtime:kimi-code", + "tags": [ + "council-critique", + "kimi-code", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** kimi-code\n\n**Output:**\nkimi (fake) call 2: frozenmemoryanchor tokcouncil", + "namespace": "shared", + "tags": [ + "council-critique", + "kimi-code", + "shared-from=*", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** kimi-code\n\n**Output:**\nkimi (fake) call 3: frozenmemoryanchor tokcouncil", + "namespace": "agent-runtime:kimi-code", + "tags": [ + "council-critique", + "kimi-code", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** kimi-code\n\n**Output:**\nkimi (fake) call 3: frozenmemoryanchor tokcouncil", + "namespace": "shared", + "tags": [ + "council-critique", + "kimi-code", + "shared-from=*", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 4: frozenmemoryanchor tokcouncil\n\n**Files changed:** calc.py", + "namespace": "agent-runtime:codex", + "tags": [ + "codex", + "task-result", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 4: frozenmemoryanchor tokcouncil\n\n**Files changed:** calc.py", + "namespace": "shared", + "tags": [ + "codex", + "shared-from=*", + "task-result", + "task:*" + ] + } + ], + "store": "store", + "token": "tokcouncil" + }, + "decompose": { + "prompt": "frozenmemoryanchor tokdecompose fix add in calc.py", + "rows": [ + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\n[\"alpha part of the work frozenmemoryanchor tokdecompose\", \"beta part of the work frozenmemoryanchor tokdecompose\"]", + "namespace": "agent-runtime:codex", + "tags": [ + "codex", + "decompose-plan", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\n[\"alpha part of the work frozenmemoryanchor tokdecompose\", \"beta part of the work frozenmemoryanchor tokdecompose\"]", + "namespace": "shared", + "tags": [ + "codex", + "decompose-plan", + "shared-from=*", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 2: frozenmemoryanchor tokdecompose", + "namespace": "agent-runtime:codex", + "tags": [ + "codex", + "decompose-subtask", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 2: frozenmemoryanchor tokdecompose", + "namespace": "shared", + "tags": [ + "codex", + "decompose-subtask", + "shared-from=*", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py\n\n**Agent:** kimi-code\n\n**Output:**\nkimi (fake) call 1: frozenmemoryanchor tokdecompose", + "namespace": "agent-runtime:kimi-code", + "tags": [ + "decompose-subtask", + "kimi-code", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py\n\n**Agent:** kimi-code\n\n**Output:**\nkimi (fake) call 1: frozenmemoryanchor tokdecompose", + "namespace": "shared", + "tags": [ + "decompose-subtask", + "kimi-code", + "shared-from=*", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 3: frozenmemoryanchor tokdecompose\n\n**Files changed:** calc.py", + "namespace": "agent-runtime:codex", + "tags": [ + "codex", + "task-result", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 3: frozenmemoryanchor tokdecompose\n\n**Files changed:** calc.py", + "namespace": "shared", + "tags": [ + "codex", + "shared-from=*", + "task-result", + "task:*" + ] + } + ], + "store": "store", + "subtasks": [ + "alpha part of the work frozenmemoryanchor tokdecompose", + "beta part of the work frozenmemoryanchor tokdecompose" + ], + "token": "tokdecompose" + }, + "failed": { + "prompt": "frozenmemoryanchor tokfailed fix add in calc.py", + "rows": [], + "store": "store", + "token": "tokfailed" + }, + "headings": { + "prompt": "frozenmemoryanchor tokheadings review calc.py", + "reply": "frozenmemoryanchor tokheadings summary line\n\n### Findings\n\nfrozenmemoryanchor tokheadings findings. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument.\n\n### Next steps\n\nfrozenmemoryanchor tokheadings steps. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero.", + "rows": [ + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokheadings review calc.py\n\n**Agent:** codex\n\n**Output:**\nfrozenmemoryanchor tokheadings summary line\n\n### Findings\n\nfrozenmemoryanchor tokheadings findings. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument.\n\n### Next steps\n\nfrozenmemoryanchor tokheadings steps. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero.", + "namespace": "agent-runtime:codex", + "tags": [ + "codex", + "task-result", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokheadings review calc.py\n\n**Agent:** codex\n\n**Output:**\nfrozenmemoryanchor tokheadings summary line\n\n### Findings\n\nfrozenmemoryanchor tokheadings findings. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument.\n\n### Next steps\n\nfrozenmemoryanchor tokheadings steps. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero.", + "namespace": "shared", + "tags": [ + "codex", + "shared-from=*", + "task-result", + "task:*" + ] + } + ], + "store": "store", + "token": "tokheadings" + }, + "longprompt": { + "private_chunks_per_entry": 2, + "prompt": "frozenmemoryanchor toklong fix add in calc.py.\n\nrequirement-000 keeps the sum of two integers exact\n\nrequirement-001 keeps the sum of two integers exact\n\nrequirement-002 keeps the sum of two integers exact\n\nrequirement-003 keeps the sum of two integers exact\n\nrequirement-004 keeps the sum of two integers exact\n\nrequirement-005 keeps the sum of two integers exact\n\nrequirement-006 keeps the sum of two integers exact\n\nrequirement-007 keeps the sum of two integers exact\n\nrequirement-008 keeps the sum of two integers exact\n\nrequirement-009 keeps the sum of two integers exact\n\nrequirement-010 keeps the sum of two integers exact\n\nrequirement-011 keeps the sum of two integers exact\n\nrequirement-012 keeps the sum of two integers exact\n\nrequirement-013 keeps the sum of two integers exact\n\nrequirement-014 keeps the sum of two integers exact\n\nrequirement-015 keeps the sum of two integers exact\n\nrequirement-016 keeps the sum of two integers exact\n\nrequirement-017 keeps the sum of two integers exact\n\nrequirement-018 keeps the sum of two integers exact\n\nrequirement-019 keeps the sum of two integers exact\n\nrequirement-020 keeps the sum of two integers exact\n\nrequirement-021 keeps the sum of two integers exact\n\nrequirement-022 keeps the sum of two integers exact\n\nrequirement-023 keeps the sum of two integers exact\n\nrequirement-024 keeps the sum of two integers exact\n\nrequirement-025 keeps the sum of two integers exact\n\nrequirement-026 keeps the sum of two integers exact\n\nrequirement-027 keeps the sum of two integers exact\n\nrequirement-028 keeps the sum of two integers exact\n\nrequirement-029 keeps the sum of two integers exact\n\nrequirement-030 keeps the sum of two integers exact\n\nrequirement-031 keeps the sum of two integers exact\n\nrequirement-032 keeps the sum of two integers exact\n\nrequirement-033 keeps the sum of two integers exact\n\nrequirement-034 keeps the sum of two integers exact\n\nrequirement-035 keeps the sum of two integers exact\n\nrequirement-036 keeps the sum of two integers exact\n\nrequirement-037 keeps the sum of two integers exact\n\nrequirement-038 keeps the sum of two integers exact\n\nrequirement-039 keeps the sum of two integers exact\n\nrequirement-040 keeps the sum of two integers exact\n\nrequirement-041 keeps the sum of two integers exact\n\nrequirement-042 keeps the sum of two integers exact\n\nrequirement-043 keeps the sum of two integers exact\n\nrequirement-044 keeps the sum of two integers exact\n\nrequirement-045 keeps the sum of two integers exact\n\nrequirement-046 keeps the sum of two integers exact\n\nrequirement-047 keeps the sum of two integers exact\n\nrequirement-048 keeps the sum of two integers exact\n\nrequirement-049 keeps the sum of two integers exact\n\nrequirement-050 keeps the sum of two integers exact\n\nrequirement-051 keeps the sum of two integers exact\n\nrequirement-052 keeps the sum of two integers exact\n\nrequirement-053 keeps the sum of two integers exact\n\nrequirement-054 keeps the sum of two integers exact\n\nrequirement-055 keeps the sum of two integers exact\n\nrequirement-056 keeps the sum of two integers exact\n\nrequirement-057 keeps the sum of two integers exact\n\nrequirement-058 keeps the sum of two integers exact\n\nrequirement-059 keeps the sum of two integers exact", + "rows": [ + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor toklong fix add in calc.py.\n\nrequirement-000 keeps the sum of two integers exact\n\nrequirement-001 keeps the sum of two integers exact\n\nrequirement-002 keeps the sum of two integers exact\n\nrequirement-003 keeps the sum of two integers exact\n\nrequirement-004 keeps the sum of two integers exact\n\nrequirement-005 keeps the sum of two integers exact\n\nrequirement-006 keeps the sum of two integers exact\n\nrequirement-007 keeps the sum of two integers exact\n\nrequirement-008 keeps the sum of two integers exact\n\nrequirement-009 keeps the sum of two integers exact\n\nrequirement-010 keeps the sum of two integers exact\n\nrequirement-011 keeps the sum of two integers exact\n\nrequirement-012 keeps the sum of two integers exact\n\nrequirement-013 keeps the sum of two integers exact\n\nrequirement-014 keeps the sum of two integers exact\n\nrequirement-015 keeps the sum of two integers exact\n\nrequirement-016 keeps the sum of two integers exact\n\nrequirement-017 keeps the sum of two integers exact\n\nrequirement-018 keeps the sum of two integers exact\n\nrequirement-019 keeps the sum of two integers exact\n\nrequirement-020 keeps the sum of two integers exact\n\nrequirement-021 keeps the sum of two integers exact\n\nrequirement-022 keeps the sum of two integers exact\n\nrequirement-023 keeps the sum of two integers exact\n\nrequirement-024 keeps the sum of two integers exact\n\nrequirement-025 keeps the sum of two integers exact\n\nrequirement-026 keeps the sum of two integers exact\n\nrequirement-027 keeps the sum of two integers exact\n\nrequirement-028 keeps the sum of two integers exact\n\nrequirement-029 keeps the sum of two integers exact\n\nrequirement-030 keeps the sum of two integers exact\n\nrequirement-031 keeps the sum of two integers exact\n\nrequirement-032 keeps the sum of two integers exact\n\nrequirement-033 keeps the sum of two integers exact\n\nrequirement-034 keeps the sum of two integers exact\n\nrequirement-035 keeps the sum of two integers exact\n\nrequirement-036 keeps the sum of two integers exact", + "namespace": "agent-runtime:codex", + "tags": [ + "codex", + "task-result", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor toklong fix add in calc.py.\n\nrequirement-000 keeps the sum of two integers exact\n\nrequirement-001 keeps the sum of two integers exact\n\nrequirement-002 keeps the sum of two integers exact\n\nrequirement-003 keeps the sum of two integers exact\n\nrequirement-004 keeps the sum of two integers exact\n\nrequirement-005 keeps the sum of two integers exact\n\nrequirement-006 keeps the sum of two integers exact\n\nrequirement-007 keeps the sum of two integers exact\n\nrequirement-008 keeps the sum of two integers exact\n\nrequirement-009 keeps the sum of two integers exact\n\nrequirement-010 keeps the sum of two integers exact\n\nrequirement-011 keeps the sum of two integers exact\n\nrequirement-012 keeps the sum of two integers exact\n\nrequirement-013 keeps the sum of two integers exact\n\nrequirement-014 keeps the sum of two integers exact\n\nrequirement-015 keeps the sum of two integers exact\n\nrequirement-016 keeps the sum of two integers exact\n\nrequirement-017 keeps the sum of two integers exact\n\nrequirement-018 keeps the sum of two integers exact\n\nrequirement-019 keeps the sum of two integers exact\n\nrequirement-020 keeps the sum of two integers exact\n\nrequirement-021 keeps the sum of two integers exact\n\nrequirement-022 keeps the sum of two integers exact\n\nrequirement-023 keeps the sum of two integers exact\n\nrequirement-024 keeps the sum of two integers exact\n\nrequirement-025 keeps the sum of two integers exact\n\nrequirement-026 keeps the sum of two integers exact\n\nrequirement-027 keeps the sum of two integers exact\n\nrequirement-028 keeps the sum of two integers exact\n\nrequirement-029 keeps the sum of two integers exact\n\nrequirement-030 keeps the sum of two integers exact\n\nrequirement-031 keeps the sum of two integers exact\n\nrequirement-032 keeps the sum of two integers exact\n\nrequirement-033 keeps the sum of two integers exact\n\nrequirement-034 keeps the sum of two integers exact\n\nrequirement-035 keeps the sum of two integers exact\n\nrequirement-036 keeps the sum of two integers exact", + "namespace": "shared", + "tags": [ + "codex", + "shared-from=*", + "task-result", + "task:*" + ] + }, + { + "body": "requirement-037 keeps the sum of two integers exact\n\nrequirement-038 keeps the sum of two integers exact\n\nrequirement-039 keeps the sum of two integers exact\n\nrequirement-040 keeps the sum of two integers exact\n\nrequirement-041 keeps the sum of two integers exact\n\nrequirement-042 keeps the sum of two integers exact\n\nrequirement-043 keeps the sum of two integers exact\n\nrequirement-044 keeps the sum of two integers exact\n\nrequirement-045 keeps the sum of two integers exact\n\nrequirement-046 keeps the sum of two integers exact\n\nrequirement-047 keeps the sum of two integers exact\n\nrequirement-048 keeps the sum of two integers exact\n\nrequirement-049 keeps the sum of two integers exact\n\nrequirement-050 keeps the sum of two integers exact\n\nrequirement-051 keeps the sum of two integers exact\n\nrequirement-052 keeps the sum of two integers exact\n\nrequirement-053 keeps the sum of two integers exact\n\nrequirement-054 keeps the sum of two integers exact\n\nrequirement-055 keeps the sum of two integers exact\n\nrequirement-056 keeps the sum of two integers exact\n\nrequirement-057 keeps the sum of two integers exact\n\nrequirement-058 keeps the sum of two integers exact\n\nrequirement-059 keeps the sum of two integers exact\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor toklong", + "namespace": "agent-runtime:codex", + "tags": [ + "codex", + "task-result", + "task:*" + ] + }, + { + "body": "requirement-037 keeps the sum of two integers exact\n\nrequirement-038 keeps the sum of two integers exact\n\nrequirement-039 keeps the sum of two integers exact\n\nrequirement-040 keeps the sum of two integers exact\n\nrequirement-041 keeps the sum of two integers exact\n\nrequirement-042 keeps the sum of two integers exact\n\nrequirement-043 keeps the sum of two integers exact\n\nrequirement-044 keeps the sum of two integers exact\n\nrequirement-045 keeps the sum of two integers exact\n\nrequirement-046 keeps the sum of two integers exact\n\nrequirement-047 keeps the sum of two integers exact\n\nrequirement-048 keeps the sum of two integers exact\n\nrequirement-049 keeps the sum of two integers exact\n\nrequirement-050 keeps the sum of two integers exact\n\nrequirement-051 keeps the sum of two integers exact\n\nrequirement-052 keeps the sum of two integers exact\n\nrequirement-053 keeps the sum of two integers exact\n\nrequirement-054 keeps the sum of two integers exact\n\nrequirement-055 keeps the sum of two integers exact\n\nrequirement-056 keeps the sum of two integers exact\n\nrequirement-057 keeps the sum of two integers exact\n\nrequirement-058 keeps the sum of two integers exact\n\nrequirement-059 keeps the sum of two integers exact\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor toklong", + "namespace": "shared", + "tags": [ + "codex", + "shared-from=*", + "task-result", + "task:*" + ] + } + ], + "store": "store", + "token": "toklong" + }, + "pipeline": { + "prompt": "frozenmemoryanchor tokpipeline fix add in calc.py", + "rows": [ + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokpipeline fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokpipeline", + "namespace": "agent-runtime:codex", + "tags": [ + "codex", + "pipeline-stage", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokpipeline fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokpipeline", + "namespace": "shared", + "tags": [ + "codex", + "pipeline-stage", + "shared-from=*", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokpipeline fix add in calc.py\n\n**Agent:** kimi-code\n\n**Output:**\nkimi (fake) call 1: frozenmemoryanchor tokpipeline\n\n**Files changed:** calc.py", + "namespace": "agent-runtime:kimi-code", + "tags": [ + "kimi-code", + "task-result", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokpipeline fix add in calc.py\n\n**Agent:** kimi-code\n\n**Output:**\nkimi (fake) call 1: frozenmemoryanchor tokpipeline\n\n**Files changed:** calc.py", + "namespace": "shared", + "tags": [ + "kimi-code", + "shared-from=*", + "task-result", + "task:*" + ] + } + ], + "store": "store", + "token": "tokpipeline" + }, + "room-apply": { + "prompt": "frozenmemoryanchor tokroom fix add in calc.py", + "room_id": "c0279a79-f0e8-4d7f-824c-f1915a41138a", + "rows": [ + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokroom fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokroom\n\n**Files changed:** calc.py", + "namespace": "agent-runtime:codex", + "tags": [ + "codex", + "room-result", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokroom fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokroom\n\n**Files changed:** calc.py", + "namespace": "shared", + "tags": [ + "codex", + "room-result", + "shared-from=*", + "task:*" + ] + } + ], + "store": "store", + "token": "tokroom" + }, + "route": { + "prompt": "frozenmemoryanchor tokroute fix add in calc.py", + "rows": [ + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokroute fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokroute\n\n**Files changed:** calc.py", + "namespace": "agent-runtime:codex", + "tags": [ + "codex", + "task-result", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokroute fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokroute\n\n**Files changed:** calc.py", + "namespace": "shared", + "tags": [ + "codex", + "shared-from=*", + "task-result", + "task:*" + ] + } + ], + "store": "store", + "token": "tokroute" + }, + "unicode": { + "prompt": "frozenmemoryanchor tokunicode say something long", + "reply": " frozenmemoryanchor tokunicode 한글 본문 と日本語 🙂\r\nsecond line after CRLF\r\n가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 tail-after-the-cut ", + "rows": [ + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokunicode say something long\n\n**Agent:** codex\n\n**Output:**\nfrozenmemoryanchor tokunicode 한글 본문 と日本語 🙂\nsecond line after CRLF\n가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라", + "namespace": "agent-runtime:codex", + "tags": [ + "codex", + "task-result", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokunicode say something long\n\n**Agent:** codex\n\n**Output:**\nfrozenmemoryanchor tokunicode 한글 본문 と日本語 🙂\nsecond line after CRLF\n가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라", + "namespace": "shared", + "tags": [ + "codex", + "shared-from=*", + "task-result", + "task:*" + ] + } + ], + "store": "store", + "token": "tokunicode" + } + }, + "stores": { + "store": { + "board": "store/board.db", + "db": "store/mm.db", + "mem": "store/mem", + "root": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9/state/store" + } + } +} diff --git a/tests/fixtures/persisted/memory/v0.2.0/release-read.json b/tests/fixtures/persisted/memory/v0.2.0/release-read.json new file mode 100644 index 0000000..2ebe4c6 --- /dev/null +++ b/tests/fixtures/persisted/memory/v0.2.0/release-read.json @@ -0,0 +1,711 @@ +{ + "store": { + "count": { + "agent-runtime:codex": 15, + "agent-runtime:kimi-code": 5, + "board-run:4c504769-9982-4419-beb1-9e45f2fb0295": 1, + "board-run:fb601eff-5dfa-4474-ae36-d3fae997ff6c": 1, + "shared": 21 + }, + "get": { + "029f847c-76a1-4084-9ae7-ea05e1c1b158": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor toklong fix add in calc.py.\n\nrequirement-000 keeps the sum of two integers exact\n\nrequirement-001 keeps the sum of two integers exact\n\nrequirement-002 keeps the sum of two integers exact\n\nrequirement-003 keeps the sum of two integers exact\n\nrequirement-004 keeps the sum of two integers exact\n\nrequirement-005 keeps the sum of two integers exact\n\nrequirement-006 keeps the sum of two integers exact\n\nrequirement-007 keeps the sum of two integers exact\n\nrequirement-008 keeps the sum of two integers exact\n\nrequirement-009 keeps the sum of two integers exact\n\nrequirement-010 keeps the sum of two integers exact\n\nrequirement-011 keeps the sum of two integers exact\n\nrequirement-012 keeps the sum of two integers exact\n\nrequirement-013 keeps the sum of two integers exact\n\nrequirement-014 keeps the sum of two integers exact\n\nrequirement-015 keeps the sum of two integers exact\n\nrequirement-016 keeps the sum of two integers exact\n\nrequirement-017 keeps the sum of two integers exact\n\nrequirement-018 keeps the sum of two integers exact\n\nrequirement-019 keeps the sum of two integers exact\n\nrequirement-020 keeps the sum of two integers exact\n\nrequirement-021 keeps the sum of two integers exact\n\nrequirement-022 keeps the sum of two integers exact\n\nrequirement-023 keeps the sum of two integers exact\n\nrequirement-024 keeps the sum of two integers exact\n\nrequirement-025 keeps the sum of two integers exact\n\nrequirement-026 keeps the sum of two integers exact\n\nrequirement-027 keeps the sum of two integers exact\n\nrequirement-028 keeps the sum of two integers exact\n\nrequirement-029 keeps the sum of two integers exact\n\nrequirement-030 keeps the sum of two integers exact\n\nrequirement-031 keeps the sum of two integers exact\n\nrequirement-032 keeps the sum of two integers exact\n\nrequirement-033 keeps the sum of two integers exact\n\nrequirement-034 keeps the sum of two integers exact\n\nrequirement-035 keeps the sum of two integers exact\n\nrequirement-036 keeps the sum of two integers exact", + "id": "029f847c-76a1-4084-9ae7-ea05e1c1b158", + "namespace": "shared", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9/state/store/mem/2026-11-15.shared.md", + "tags": [ + "codex", + "shared-from=1c95e91e-bd90-460d-812f-bff92b3cc599", + "task-result", + "task:f61e779a-f0f1-42af-bb14-cf2c3dcfebcc" + ] + }, + "0fc609b3-d696-4fb4-930e-cd0e42873c29": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 2: frozenmemoryanchor tokcouncil", + "id": "0fc609b3-d696-4fb4-930e-cd0e42873c29", + "namespace": "shared", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9/state/store/mem/2026-11-15.shared.md", + "tags": [ + "codex", + "council-critique", + "shared-from=bb76a02a-ea92-48a7-b5c7-4bb654cda7a9", + "task:7cfe1b11-d283-4918-8479-10be2c218a12" + ] + }, + "0ff120ff-d8ec-4580-a983-b4551447fdde": { + "content": "**Task Result**\n\n**Prompt:** You are working on a tracked work-board item.\nGoal: frozen\n\nTask: frozenmemoryanchor tokboard fix add in calc.py\n\nWhen you finish, you MAY append ONE fenced block reporting the board update (every field optional):\n```syncmill-board\n{\"state\": \"review\", \"handoff\": \"\", \"outputs\": [\"\"], \"human_required\": false}\n```\nUse \"state\": \"blocked\" with a \"blocked_reason\" if you cannot proceed, or \"human_required\": true if a human must step in. Requesting \"done\" only takes effect if the work is independently verified (a passing quality gate or a human sign-off); otherwise it is recorded as \"review\".\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokboard\n\n**Files changed:** calc.py", + "id": "0ff120ff-d8ec-4580-a983-b4551447fdde", + "namespace": "board-run:fb601eff-5dfa-4474-ae36-d3fae997ff6c", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9/state/store/mem/2026-11-15.board-run.fb601eff-5dfa-4474-ae36-d3fae997ff6c.md", + "tags": [ + "codex", + "task-result", + "task:06b4939d-6fad-44cd-b113-3eebdf988bca" + ] + }, + "12820853-24bd-45a0-a509-578b618fac7f": { + "content": "**Task Result**\n\n**Prompt:** You are working on a tracked work-board item.\nGoal: frozen\n\nTask: frozenmemoryanchor tokkilled fix add in calc.py\n\nWhen you finish, you MAY append ONE fenced block reporting the board update (every field optional):\n```syncmill-board\n{\"state\": \"review\", \"handoff\": \"\", \"outputs\": [\"\"], \"human_required\": false}\n```\nUse \"state\": \"blocked\" with a \"blocked_reason\" if you cannot proceed, or \"human_required\": true if a human must step in. Requesting \"done\" only takes effect if the work is independently verified (a passing quality gate or a human sign-off); otherwise it is recorded as \"review\".\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokkilled", + "id": "12820853-24bd-45a0-a509-578b618fac7f", + "namespace": "board-run:4c504769-9982-4419-beb1-9e45f2fb0295", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9/state/store/mem/2026-11-15.board-run.4c504769-9982-4419-beb1-9e45f2fb0295.md", + "tags": [ + "codex", + "pipeline-stage", + "task:d48c359b-7b9c-4643-9680-6b6e8f309884" + ] + }, + "1b0213d2-3bd7-4c3d-904c-91954160cdbb": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\n[\"alpha part of the work frozenmemoryanchor tokdecompose\", \"beta part of the work frozenmemoryanchor tokdecompose\"]", + "id": "1b0213d2-3bd7-4c3d-904c-91954160cdbb", + "namespace": "shared", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9/state/store/mem/2026-11-15.shared.md", + "tags": [ + "codex", + "decompose-plan", + "shared-from=b8db39bc-7d7e-450e-9896-ba5ba7f09b41", + "task:720ea79c-a729-4068-9e97-9315ad0e8e61" + ] + }, + "1c95e91e-bd90-460d-812f-bff92b3cc599": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor toklong fix add in calc.py.\n\nrequirement-000 keeps the sum of two integers exact\n\nrequirement-001 keeps the sum of two integers exact\n\nrequirement-002 keeps the sum of two integers exact\n\nrequirement-003 keeps the sum of two integers exact\n\nrequirement-004 keeps the sum of two integers exact\n\nrequirement-005 keeps the sum of two integers exact\n\nrequirement-006 keeps the sum of two integers exact\n\nrequirement-007 keeps the sum of two integers exact\n\nrequirement-008 keeps the sum of two integers exact\n\nrequirement-009 keeps the sum of two integers exact\n\nrequirement-010 keeps the sum of two integers exact\n\nrequirement-011 keeps the sum of two integers exact\n\nrequirement-012 keeps the sum of two integers exact\n\nrequirement-013 keeps the sum of two integers exact\n\nrequirement-014 keeps the sum of two integers exact\n\nrequirement-015 keeps the sum of two integers exact\n\nrequirement-016 keeps the sum of two integers exact\n\nrequirement-017 keeps the sum of two integers exact\n\nrequirement-018 keeps the sum of two integers exact\n\nrequirement-019 keeps the sum of two integers exact\n\nrequirement-020 keeps the sum of two integers exact\n\nrequirement-021 keeps the sum of two integers exact\n\nrequirement-022 keeps the sum of two integers exact\n\nrequirement-023 keeps the sum of two integers exact\n\nrequirement-024 keeps the sum of two integers exact\n\nrequirement-025 keeps the sum of two integers exact\n\nrequirement-026 keeps the sum of two integers exact\n\nrequirement-027 keeps the sum of two integers exact\n\nrequirement-028 keeps the sum of two integers exact\n\nrequirement-029 keeps the sum of two integers exact\n\nrequirement-030 keeps the sum of two integers exact\n\nrequirement-031 keeps the sum of two integers exact\n\nrequirement-032 keeps the sum of two integers exact\n\nrequirement-033 keeps the sum of two integers exact\n\nrequirement-034 keeps the sum of two integers exact\n\nrequirement-035 keeps the sum of two integers exact\n\nrequirement-036 keeps the sum of two integers exact", + "id": "1c95e91e-bd90-460d-812f-bff92b3cc599", + "namespace": "agent-runtime:codex", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9/state/store/mem/2026-11-15.agent-runtime.codex.md", + "tags": [ + "codex", + "task-result", + "task:f61e779a-f0f1-42af-bb14-cf2c3dcfebcc" + ] + }, + "2331bbdb-26f8-401a-b356-5ff742a7e3fd": { + "content": "requirement-037 keeps the sum of two integers exact\n\nrequirement-038 keeps the sum of two integers exact\n\nrequirement-039 keeps the sum of two integers exact\n\nrequirement-040 keeps the sum of two integers exact\n\nrequirement-041 keeps the sum of two integers exact\n\nrequirement-042 keeps the sum of two integers exact\n\nrequirement-043 keeps the sum of two integers exact\n\nrequirement-044 keeps the sum of two integers exact\n\nrequirement-045 keeps the sum of two integers exact\n\nrequirement-046 keeps the sum of two integers exact\n\nrequirement-047 keeps the sum of two integers exact\n\nrequirement-048 keeps the sum of two integers exact\n\nrequirement-049 keeps the sum of two integers exact\n\nrequirement-050 keeps the sum of two integers exact\n\nrequirement-051 keeps the sum of two integers exact\n\nrequirement-052 keeps the sum of two integers exact\n\nrequirement-053 keeps the sum of two integers exact\n\nrequirement-054 keeps the sum of two integers exact\n\nrequirement-055 keeps the sum of two integers exact\n\nrequirement-056 keeps the sum of two integers exact\n\nrequirement-057 keeps the sum of two integers exact\n\nrequirement-058 keeps the sum of two integers exact\n\nrequirement-059 keeps the sum of two integers exact\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor toklong", + "id": "2331bbdb-26f8-401a-b356-5ff742a7e3fd", + "namespace": "agent-runtime:codex", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9/state/store/mem/2026-11-15.agent-runtime.codex.md", + "tags": [ + "codex", + "task-result", + "task:f61e779a-f0f1-42af-bb14-cf2c3dcfebcc" + ] + }, + "2430469c-2549-48d9-9c02-2811cdfa0dbd": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** kimi-code\n\n**Output:**\nkimi (fake) call 3: frozenmemoryanchor tokcouncil", + "id": "2430469c-2549-48d9-9c02-2811cdfa0dbd", + "namespace": "agent-runtime:kimi-code", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9/state/store/mem/2026-11-15.agent-runtime.kimi-code.md", + "tags": [ + "council-critique", + "kimi-code", + "task:7cfe1b11-d283-4918-8479-10be2c218a12" + ] + }, + "27d2de18-4c14-437d-901f-dbf7f20030d3": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokpipeline fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokpipeline", + "id": "27d2de18-4c14-437d-901f-dbf7f20030d3", + "namespace": "agent-runtime:codex", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9/state/store/mem/2026-11-15.agent-runtime.codex.md", + "tags": [ + "codex", + "pipeline-stage", + "task:b55b0835-1329-4490-8370-92abcd2e6044" + ] + }, + "28cd638e-33ce-4847-b57c-4c487d1cdae6": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokcouncil", + "id": "28cd638e-33ce-4847-b57c-4c487d1cdae6", + "namespace": "agent-runtime:codex", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9/state/store/mem/2026-11-15.agent-runtime.codex.md", + "tags": [ + "codex", + "council-proposal", + "task:7cfe1b11-d283-4918-8479-10be2c218a12" + ] + }, + "2a9fe97c-fef6-4e50-83f9-bf4fd33821ca": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokpipeline fix add in calc.py\n\n**Agent:** kimi-code\n\n**Output:**\nkimi (fake) call 1: frozenmemoryanchor tokpipeline\n\n**Files changed:** calc.py", + "id": "2a9fe97c-fef6-4e50-83f9-bf4fd33821ca", + "namespace": "shared", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9/state/store/mem/2026-11-15.shared.md", + "tags": [ + "kimi-code", + "shared-from=ffc1c84d-b10e-4a6b-95f3-d146ab3f252b", + "task-result", + "task:b55b0835-1329-4490-8370-92abcd2e6044" + ] + }, + "2d14650b-4f23-4870-ae79-6b5b4aedbeee": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 3: frozenmemoryanchor tokcouncil", + "id": "2d14650b-4f23-4870-ae79-6b5b4aedbeee", + "namespace": "shared", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9/state/store/mem/2026-11-15.shared.md", + "tags": [ + "codex", + "council-critique", + "shared-from=d4ebd12a-9b60-4d0f-9fed-c9c2debee31a", + "task:7cfe1b11-d283-4918-8479-10be2c218a12" + ] + }, + "366df9b1-ccdc-46db-9ca9-c7151155ed7f": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcompete fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokcompete\n\n**Files changed:** calc.py", + "id": "366df9b1-ccdc-46db-9ca9-c7151155ed7f", + "namespace": "agent-runtime:codex", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9/state/store/mem/2026-11-15.agent-runtime.codex.md", + "tags": [ + "codex", + "task-result", + "task:a180bd85-2eb7-48f6-9a9d-239d13398e01" + ] + }, + "49277171-cdb0-4522-8f1b-5a0df361d3f2": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokroute fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokroute\n\n**Files changed:** calc.py", + "id": "49277171-cdb0-4522-8f1b-5a0df361d3f2", + "namespace": "agent-runtime:codex", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9/state/store/mem/2026-11-15.agent-runtime.codex.md", + "tags": [ + "codex", + "task-result", + "task:39ccd2d9-a3ea-4283-9295-39f4d76af22e" + ] + }, + "501cdcb6-b66b-4a33-b88a-0e105d484cd3": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokheadings review calc.py\n\n**Agent:** codex\n\n**Output:**\nfrozenmemoryanchor tokheadings summary line\n\n### Findings\n\nfrozenmemoryanchor tokheadings findings. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument.\n\n### Next steps\n\nfrozenmemoryanchor tokheadings steps. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero.", + "id": "501cdcb6-b66b-4a33-b88a-0e105d484cd3", + "namespace": "shared", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9/state/store/mem/2026-11-15.shared.md", + "tags": [ + "codex", + "shared-from=569c493f-022c-461f-b12d-920b70886627", + "task-result", + "task:444ee417-970b-46ed-9789-ce4590d94b9d" + ] + }, + "569c493f-022c-461f-b12d-920b70886627": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokheadings review calc.py\n\n**Agent:** codex\n\n**Output:**\nfrozenmemoryanchor tokheadings summary line\n\n### Findings\n\nfrozenmemoryanchor tokheadings findings. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument.\n\n### Next steps\n\nfrozenmemoryanchor tokheadings steps. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero.", + "id": "569c493f-022c-461f-b12d-920b70886627", + "namespace": "agent-runtime:codex", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9/state/store/mem/2026-11-15.agent-runtime.codex.md", + "tags": [ + "codex", + "task-result", + "task:444ee417-970b-46ed-9789-ce4590d94b9d" + ] + }, + "5989c9f4-d81e-4c10-96a3-ffb678935dd1": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** kimi-code\n\n**Output:**\nkimi (fake) call 2: frozenmemoryanchor tokcouncil", + "id": "5989c9f4-d81e-4c10-96a3-ffb678935dd1", + "namespace": "agent-runtime:kimi-code", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9/state/store/mem/2026-11-15.agent-runtime.kimi-code.md", + "tags": [ + "council-critique", + "kimi-code", + "task:7cfe1b11-d283-4918-8479-10be2c218a12" + ] + }, + "69e05f8b-bfc7-43a4-8ace-d9726aacfd63": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokroom fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokroom\n\n**Files changed:** calc.py", + "id": "69e05f8b-bfc7-43a4-8ace-d9726aacfd63", + "namespace": "agent-runtime:codex", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9/state/store/mem/2026-11-15.agent-runtime.codex.md", + "tags": [ + "codex", + "room-result", + "task:768ba721-86d0-4275-baf0-10ddbfaa48cc" + ] + }, + "69e2c357-80d5-42cf-8b7e-3b05c7a3eece": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** kimi-code\n\n**Output:**\nkimi (fake) call 1: frozenmemoryanchor tokcouncil", + "id": "69e2c357-80d5-42cf-8b7e-3b05c7a3eece", + "namespace": "shared", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9/state/store/mem/2026-11-15.shared.md", + "tags": [ + "council-proposal", + "kimi-code", + "shared-from=b9b7f90f-2a79-4feb-b961-3dca7a7adbed", + "task:7cfe1b11-d283-4918-8479-10be2c218a12" + ] + }, + "6de02f80-f2d4-42e4-a49e-42d343196771": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 4: frozenmemoryanchor tokcouncil\n\n**Files changed:** calc.py", + "id": "6de02f80-f2d4-42e4-a49e-42d343196771", + "namespace": "agent-runtime:codex", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9/state/store/mem/2026-11-15.agent-runtime.codex.md", + "tags": [ + "codex", + "task-result", + "task:7cfe1b11-d283-4918-8479-10be2c218a12" + ] + }, + "74a3f417-ba22-4d9a-9592-5a5657facab9": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py\n\n**Agent:** kimi-code\n\n**Output:**\nkimi (fake) call 1: frozenmemoryanchor tokdecompose", + "id": "74a3f417-ba22-4d9a-9592-5a5657facab9", + "namespace": "agent-runtime:kimi-code", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9/state/store/mem/2026-11-15.agent-runtime.kimi-code.md", + "tags": [ + "decompose-subtask", + "kimi-code", + "task:720ea79c-a729-4068-9e97-9315ad0e8e61" + ] + }, + "81f2ccfa-3ffc-4288-8797-c7d711d4eb14": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokpipeline fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokpipeline", + "id": "81f2ccfa-3ffc-4288-8797-c7d711d4eb14", + "namespace": "shared", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9/state/store/mem/2026-11-15.shared.md", + "tags": [ + "codex", + "pipeline-stage", + "shared-from=27d2de18-4c14-437d-901f-dbf7f20030d3", + "task:b55b0835-1329-4490-8370-92abcd2e6044" + ] + }, + "86164089-6d2f-4c23-a823-b5ef4b448f9f": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** kimi-code\n\n**Output:**\nkimi (fake) call 2: frozenmemoryanchor tokcouncil", + "id": "86164089-6d2f-4c23-a823-b5ef4b448f9f", + "namespace": "shared", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9/state/store/mem/2026-11-15.shared.md", + "tags": [ + "council-critique", + "kimi-code", + "shared-from=5989c9f4-d81e-4c10-96a3-ffb678935dd1", + "task:7cfe1b11-d283-4918-8479-10be2c218a12" + ] + }, + "92145486-8c6e-4cf7-9332-b4e63dceaf7a": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokroute fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokroute\n\n**Files changed:** calc.py", + "id": "92145486-8c6e-4cf7-9332-b4e63dceaf7a", + "namespace": "shared", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9/state/store/mem/2026-11-15.shared.md", + "tags": [ + "codex", + "shared-from=49277171-cdb0-4522-8f1b-5a0df361d3f2", + "task-result", + "task:39ccd2d9-a3ea-4283-9295-39f4d76af22e" + ] + }, + "9b64a6a9-1d14-486b-9c80-65acc92f2da1": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py\n\n**Agent:** kimi-code\n\n**Output:**\nkimi (fake) call 1: frozenmemoryanchor tokdecompose", + "id": "9b64a6a9-1d14-486b-9c80-65acc92f2da1", + "namespace": "shared", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9/state/store/mem/2026-11-15.shared.md", + "tags": [ + "decompose-subtask", + "kimi-code", + "shared-from=74a3f417-ba22-4d9a-9592-5a5657facab9", + "task:720ea79c-a729-4068-9e97-9315ad0e8e61" + ] + }, + "9da77fd4-9356-4287-929f-7b5fc4c2cf7f": { + "content": "**Board Item Result**\n\n**Item:** b97d9de5-d8dd-40c7-8448-df510e41f5cf\n\n**Task:** frozenmemoryanchor tokboard fix add in calc.py\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokboard", + "id": "9da77fd4-9356-4287-929f-7b5fc4c2cf7f", + "namespace": "shared", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9/state/store/mem/2026-11-15.shared.md", + "tags": [ + "board-result:b97d9de5-d8dd-40c7-8448-df510e41f5cf" + ] + }, + "a2d68241-50f7-499f-bc2f-4ed3fc44a6ab": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokroom fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokroom\n\n**Files changed:** calc.py", + "id": "a2d68241-50f7-499f-bc2f-4ed3fc44a6ab", + "namespace": "shared", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9/state/store/mem/2026-11-15.shared.md", + "tags": [ + "codex", + "room-result", + "shared-from=69e05f8b-bfc7-43a4-8ace-d9726aacfd63", + "task:768ba721-86d0-4275-baf0-10ddbfaa48cc" + ] + }, + "ad1b9e2f-f838-464a-a6ac-d1bd3583d687": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokcouncil", + "id": "ad1b9e2f-f838-464a-a6ac-d1bd3583d687", + "namespace": "shared", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9/state/store/mem/2026-11-15.shared.md", + "tags": [ + "codex", + "council-proposal", + "shared-from=28cd638e-33ce-4847-b57c-4c487d1cdae6", + "task:7cfe1b11-d283-4918-8479-10be2c218a12" + ] + }, + "aef867c1-ded8-46b8-a33a-5563da5fa70f": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 2: frozenmemoryanchor tokdecompose", + "id": "aef867c1-ded8-46b8-a33a-5563da5fa70f", + "namespace": "shared", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9/state/store/mem/2026-11-15.shared.md", + "tags": [ + "codex", + "decompose-subtask", + "shared-from=f24d0586-6556-478a-acda-dfe67c8d10d0", + "task:720ea79c-a729-4068-9e97-9315ad0e8e61" + ] + }, + "b8db39bc-7d7e-450e-9896-ba5ba7f09b41": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\n[\"alpha part of the work frozenmemoryanchor tokdecompose\", \"beta part of the work frozenmemoryanchor tokdecompose\"]", + "id": "b8db39bc-7d7e-450e-9896-ba5ba7f09b41", + "namespace": "agent-runtime:codex", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9/state/store/mem/2026-11-15.agent-runtime.codex.md", + "tags": [ + "codex", + "decompose-plan", + "task:720ea79c-a729-4068-9e97-9315ad0e8e61" + ] + }, + "b9b7f90f-2a79-4feb-b961-3dca7a7adbed": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** kimi-code\n\n**Output:**\nkimi (fake) call 1: frozenmemoryanchor tokcouncil", + "id": "b9b7f90f-2a79-4feb-b961-3dca7a7adbed", + "namespace": "agent-runtime:kimi-code", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9/state/store/mem/2026-11-15.agent-runtime.kimi-code.md", + "tags": [ + "council-proposal", + "kimi-code", + "task:7cfe1b11-d283-4918-8479-10be2c218a12" + ] + }, + "bb76a02a-ea92-48a7-b5c7-4bb654cda7a9": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 2: frozenmemoryanchor tokcouncil", + "id": "bb76a02a-ea92-48a7-b5c7-4bb654cda7a9", + "namespace": "agent-runtime:codex", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9/state/store/mem/2026-11-15.agent-runtime.codex.md", + "tags": [ + "codex", + "council-critique", + "task:7cfe1b11-d283-4918-8479-10be2c218a12" + ] + }, + "c68ed626-ef79-4c55-a892-e3e719d647d7": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokunicode say something long\n\n**Agent:** codex\n\n**Output:**\nfrozenmemoryanchor tokunicode 한글 본문 と日本語 🙂\nsecond line after CRLF\n가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라", + "id": "c68ed626-ef79-4c55-a892-e3e719d647d7", + "namespace": "agent-runtime:codex", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9/state/store/mem/2026-11-15.agent-runtime.codex.md", + "tags": [ + "codex", + "task-result", + "task:2dca9c44-de01-4639-8ea9-7e9d1bcad61a" + ] + }, + "d0977460-58da-4d84-ac9b-cc49403bbc89": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokunicode say something long\n\n**Agent:** codex\n\n**Output:**\nfrozenmemoryanchor tokunicode 한글 본문 と日本語 🙂\nsecond line after CRLF\n가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라", + "id": "d0977460-58da-4d84-ac9b-cc49403bbc89", + "namespace": "shared", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9/state/store/mem/2026-11-15.shared.md", + "tags": [ + "codex", + "shared-from=c68ed626-ef79-4c55-a892-e3e719d647d7", + "task-result", + "task:2dca9c44-de01-4639-8ea9-7e9d1bcad61a" + ] + }, + "d127276e-4c6d-4fb3-ad6a-3925b01e7a01": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 3: frozenmemoryanchor tokdecompose\n\n**Files changed:** calc.py", + "id": "d127276e-4c6d-4fb3-ad6a-3925b01e7a01", + "namespace": "shared", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9/state/store/mem/2026-11-15.shared.md", + "tags": [ + "codex", + "shared-from=edb0103a-4fcc-45ed-8e2a-2519f8a41cea", + "task-result", + "task:720ea79c-a729-4068-9e97-9315ad0e8e61" + ] + }, + "d46c94f4-8497-4c43-9371-1ce021e04bc1": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** kimi-code\n\n**Output:**\nkimi (fake) call 3: frozenmemoryanchor tokcouncil", + "id": "d46c94f4-8497-4c43-9371-1ce021e04bc1", + "namespace": "shared", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9/state/store/mem/2026-11-15.shared.md", + "tags": [ + "council-critique", + "kimi-code", + "shared-from=2430469c-2549-48d9-9c02-2811cdfa0dbd", + "task:7cfe1b11-d283-4918-8479-10be2c218a12" + ] + }, + "d4cf9008-ca4e-413b-8884-4400ff4ed354": { + "content": "requirement-037 keeps the sum of two integers exact\n\nrequirement-038 keeps the sum of two integers exact\n\nrequirement-039 keeps the sum of two integers exact\n\nrequirement-040 keeps the sum of two integers exact\n\nrequirement-041 keeps the sum of two integers exact\n\nrequirement-042 keeps the sum of two integers exact\n\nrequirement-043 keeps the sum of two integers exact\n\nrequirement-044 keeps the sum of two integers exact\n\nrequirement-045 keeps the sum of two integers exact\n\nrequirement-046 keeps the sum of two integers exact\n\nrequirement-047 keeps the sum of two integers exact\n\nrequirement-048 keeps the sum of two integers exact\n\nrequirement-049 keeps the sum of two integers exact\n\nrequirement-050 keeps the sum of two integers exact\n\nrequirement-051 keeps the sum of two integers exact\n\nrequirement-052 keeps the sum of two integers exact\n\nrequirement-053 keeps the sum of two integers exact\n\nrequirement-054 keeps the sum of two integers exact\n\nrequirement-055 keeps the sum of two integers exact\n\nrequirement-056 keeps the sum of two integers exact\n\nrequirement-057 keeps the sum of two integers exact\n\nrequirement-058 keeps the sum of two integers exact\n\nrequirement-059 keeps the sum of two integers exact\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor toklong", + "id": "d4cf9008-ca4e-413b-8884-4400ff4ed354", + "namespace": "shared", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9/state/store/mem/2026-11-15.shared.md", + "tags": [ + "codex", + "shared-from=2331bbdb-26f8-401a-b356-5ff742a7e3fd", + "task-result", + "task:f61e779a-f0f1-42af-bb14-cf2c3dcfebcc" + ] + }, + "d4ebd12a-9b60-4d0f-9fed-c9c2debee31a": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 3: frozenmemoryanchor tokcouncil", + "id": "d4ebd12a-9b60-4d0f-9fed-c9c2debee31a", + "namespace": "agent-runtime:codex", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9/state/store/mem/2026-11-15.agent-runtime.codex.md", + "tags": [ + "codex", + "council-critique", + "task:7cfe1b11-d283-4918-8479-10be2c218a12" + ] + }, + "e0d5c324-b25f-403b-a157-c8cb6bf1fc19": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcompete fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokcompete\n\n**Files changed:** calc.py", + "id": "e0d5c324-b25f-403b-a157-c8cb6bf1fc19", + "namespace": "shared", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9/state/store/mem/2026-11-15.shared.md", + "tags": [ + "codex", + "shared-from=366df9b1-ccdc-46db-9ca9-c7151155ed7f", + "task-result", + "task:a180bd85-2eb7-48f6-9a9d-239d13398e01" + ] + }, + "e7f26c25-240a-4aea-bee2-a9cb52e1cc5a": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 4: frozenmemoryanchor tokcouncil\n\n**Files changed:** calc.py", + "id": "e7f26c25-240a-4aea-bee2-a9cb52e1cc5a", + "namespace": "shared", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9/state/store/mem/2026-11-15.shared.md", + "tags": [ + "codex", + "shared-from=6de02f80-f2d4-42e4-a49e-42d343196771", + "task-result", + "task:7cfe1b11-d283-4918-8479-10be2c218a12" + ] + }, + "edb0103a-4fcc-45ed-8e2a-2519f8a41cea": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 3: frozenmemoryanchor tokdecompose\n\n**Files changed:** calc.py", + "id": "edb0103a-4fcc-45ed-8e2a-2519f8a41cea", + "namespace": "agent-runtime:codex", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9/state/store/mem/2026-11-15.agent-runtime.codex.md", + "tags": [ + "codex", + "task-result", + "task:720ea79c-a729-4068-9e97-9315ad0e8e61" + ] + }, + "f24d0586-6556-478a-acda-dfe67c8d10d0": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 2: frozenmemoryanchor tokdecompose", + "id": "f24d0586-6556-478a-acda-dfe67c8d10d0", + "namespace": "agent-runtime:codex", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9/state/store/mem/2026-11-15.agent-runtime.codex.md", + "tags": [ + "codex", + "decompose-subtask", + "task:720ea79c-a729-4068-9e97-9315ad0e8e61" + ] + }, + "ffc1c84d-b10e-4a6b-95f3-d146ab3f252b": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokpipeline fix add in calc.py\n\n**Agent:** kimi-code\n\n**Output:**\nkimi (fake) call 1: frozenmemoryanchor tokpipeline\n\n**Files changed:** calc.py", + "id": "ffc1c84d-b10e-4a6b-95f3-d146ab3f252b", + "namespace": "agent-runtime:kimi-code", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpjgzuzie9/state/store/mem/2026-11-15.agent-runtime.kimi-code.md", + "tags": [ + "kimi-code", + "task-result", + "task:b55b0835-1329-4490-8370-92abcd2e6044" + ] + } + }, + "search": { + "agent-runtime:codex": [ + "1c95e91e-bd90-460d-812f-bff92b3cc599", + "2331bbdb-26f8-401a-b356-5ff742a7e3fd", + "27d2de18-4c14-437d-901f-dbf7f20030d3", + "28cd638e-33ce-4847-b57c-4c487d1cdae6", + "366df9b1-ccdc-46db-9ca9-c7151155ed7f", + "49277171-cdb0-4522-8f1b-5a0df361d3f2", + "569c493f-022c-461f-b12d-920b70886627", + "69e05f8b-bfc7-43a4-8ace-d9726aacfd63", + "6de02f80-f2d4-42e4-a49e-42d343196771", + "b8db39bc-7d7e-450e-9896-ba5ba7f09b41", + "bb76a02a-ea92-48a7-b5c7-4bb654cda7a9", + "c68ed626-ef79-4c55-a892-e3e719d647d7", + "d4ebd12a-9b60-4d0f-9fed-c9c2debee31a", + "edb0103a-4fcc-45ed-8e2a-2519f8a41cea", + "f24d0586-6556-478a-acda-dfe67c8d10d0" + ], + "agent-runtime:kimi-code": [ + "2430469c-2549-48d9-9c02-2811cdfa0dbd", + "5989c9f4-d81e-4c10-96a3-ffb678935dd1", + "74a3f417-ba22-4d9a-9592-5a5657facab9", + "b9b7f90f-2a79-4feb-b961-3dca7a7adbed", + "ffc1c84d-b10e-4a6b-95f3-d146ab3f252b" + ], + "board-run:4c504769-9982-4419-beb1-9e45f2fb0295": [ + "12820853-24bd-45a0-a509-578b618fac7f" + ], + "board-run:fb601eff-5dfa-4474-ae36-d3fae997ff6c": [ + "0ff120ff-d8ec-4580-a983-b4551447fdde" + ], + "shared": [ + "029f847c-76a1-4084-9ae7-ea05e1c1b158", + "0fc609b3-d696-4fb4-930e-cd0e42873c29", + "1b0213d2-3bd7-4c3d-904c-91954160cdbb", + "2a9fe97c-fef6-4e50-83f9-bf4fd33821ca", + "2d14650b-4f23-4870-ae79-6b5b4aedbeee", + "501cdcb6-b66b-4a33-b88a-0e105d484cd3", + "69e2c357-80d5-42cf-8b7e-3b05c7a3eece", + "81f2ccfa-3ffc-4288-8797-c7d711d4eb14", + "86164089-6d2f-4c23-a823-b5ef4b448f9f", + "92145486-8c6e-4cf7-9332-b4e63dceaf7a", + "9b64a6a9-1d14-486b-9c80-65acc92f2da1", + "9da77fd4-9356-4287-929f-7b5fc4c2cf7f", + "a2d68241-50f7-499f-bc2f-4ed3fc44a6ab", + "ad1b9e2f-f838-464a-a6ac-d1bd3583d687", + "aef867c1-ded8-46b8-a33a-5563da5fa70f", + "d0977460-58da-4d84-ac9b-cc49403bbc89", + "d127276e-4c6d-4fb3-ad6a-3925b01e7a01", + "d46c94f4-8497-4c43-9371-1ce021e04bc1", + "d4cf9008-ca4e-413b-8884-4400ff4ed354", + "e0d5c324-b25f-403b-a157-c8cb6bf1fc19", + "e7f26c25-240a-4aea-bee2-a9cb52e1cc5a" + ] + }, + "search_by_kind": { + "agent-runtime:codex": { + "council-critique": [ + "bb76a02a-ea92-48a7-b5c7-4bb654cda7a9", + "d4ebd12a-9b60-4d0f-9fed-c9c2debee31a" + ], + "council-proposal": [ + "28cd638e-33ce-4847-b57c-4c487d1cdae6" + ], + "decompose-plan": [ + "b8db39bc-7d7e-450e-9896-ba5ba7f09b41" + ], + "decompose-subtask": [ + "f24d0586-6556-478a-acda-dfe67c8d10d0" + ], + "pipeline-stage": [ + "27d2de18-4c14-437d-901f-dbf7f20030d3" + ], + "room-result": [ + "69e05f8b-bfc7-43a4-8ace-d9726aacfd63" + ], + "task-result": [ + "1c95e91e-bd90-460d-812f-bff92b3cc599", + "2331bbdb-26f8-401a-b356-5ff742a7e3fd", + "366df9b1-ccdc-46db-9ca9-c7151155ed7f", + "49277171-cdb0-4522-8f1b-5a0df361d3f2", + "569c493f-022c-461f-b12d-920b70886627", + "6de02f80-f2d4-42e4-a49e-42d343196771", + "c68ed626-ef79-4c55-a892-e3e719d647d7", + "edb0103a-4fcc-45ed-8e2a-2519f8a41cea" + ] + }, + "agent-runtime:kimi-code": { + "council-critique": [ + "2430469c-2549-48d9-9c02-2811cdfa0dbd", + "5989c9f4-d81e-4c10-96a3-ffb678935dd1" + ], + "council-proposal": [ + "b9b7f90f-2a79-4feb-b961-3dca7a7adbed" + ], + "decompose-plan": [], + "decompose-subtask": [ + "74a3f417-ba22-4d9a-9592-5a5657facab9" + ], + "pipeline-stage": [], + "room-result": [], + "task-result": [ + "ffc1c84d-b10e-4a6b-95f3-d146ab3f252b" + ] + }, + "board-run:4c504769-9982-4419-beb1-9e45f2fb0295": { + "council-critique": [], + "council-proposal": [], + "decompose-plan": [], + "decompose-subtask": [], + "pipeline-stage": [ + "12820853-24bd-45a0-a509-578b618fac7f" + ], + "room-result": [], + "task-result": [] + }, + "board-run:fb601eff-5dfa-4474-ae36-d3fae997ff6c": { + "council-critique": [], + "council-proposal": [], + "decompose-plan": [], + "decompose-subtask": [], + "pipeline-stage": [], + "room-result": [], + "task-result": [ + "0ff120ff-d8ec-4580-a983-b4551447fdde" + ] + }, + "shared": { + "council-critique": [ + "0fc609b3-d696-4fb4-930e-cd0e42873c29", + "2d14650b-4f23-4870-ae79-6b5b4aedbeee", + "86164089-6d2f-4c23-a823-b5ef4b448f9f", + "d46c94f4-8497-4c43-9371-1ce021e04bc1" + ], + "council-proposal": [ + "69e2c357-80d5-42cf-8b7e-3b05c7a3eece", + "ad1b9e2f-f838-464a-a6ac-d1bd3583d687" + ], + "decompose-plan": [ + "1b0213d2-3bd7-4c3d-904c-91954160cdbb" + ], + "decompose-subtask": [ + "9b64a6a9-1d14-486b-9c80-65acc92f2da1", + "aef867c1-ded8-46b8-a33a-5563da5fa70f" + ], + "pipeline-stage": [ + "81f2ccfa-3ffc-4288-8797-c7d711d4eb14" + ], + "room-result": [ + "a2d68241-50f7-499f-bc2f-4ed3fc44a6ab" + ], + "task-result": [ + "029f847c-76a1-4084-9ae7-ea05e1c1b158", + "2a9fe97c-fef6-4e50-83f9-bf4fd33821ca", + "501cdcb6-b66b-4a33-b88a-0e105d484cd3", + "92145486-8c6e-4cf7-9332-b4e63dceaf7a", + "d0977460-58da-4d84-ac9b-cc49403bbc89", + "d127276e-4c6d-4fb3-ad6a-3925b01e7a01", + "d4cf9008-ca4e-413b-8884-4400ff4ed354", + "e0d5c324-b25f-403b-a157-c8cb6bf1fc19", + "e7f26c25-240a-4aea-bee2-a9cb52e1cc5a" + ] + } + } + } +} diff --git a/tests/fixtures/persisted/memory/v0.2.0/store/board.db b/tests/fixtures/persisted/memory/v0.2.0/store/board.db new file mode 100644 index 0000000..43da0f6 Binary files /dev/null and b/tests/fixtures/persisted/memory/v0.2.0/store/board.db differ diff --git a/tests/fixtures/persisted/memory/v0.2.0/store/board.db-shm b/tests/fixtures/persisted/memory/v0.2.0/store/board.db-shm new file mode 100644 index 0000000..4dc5303 Binary files /dev/null and b/tests/fixtures/persisted/memory/v0.2.0/store/board.db-shm differ diff --git a/tests/fixtures/persisted/memory/v0.2.0/store/board.db-wal b/tests/fixtures/persisted/memory/v0.2.0/store/board.db-wal new file mode 100644 index 0000000..40842bc Binary files /dev/null and b/tests/fixtures/persisted/memory/v0.2.0/store/board.db-wal differ diff --git a/tests/fixtures/persisted/memory/v0.2.0/store/board.db.gc-lock b/tests/fixtures/persisted/memory/v0.2.0/store/board.db.gc-lock new file mode 100644 index 0000000..e69de29 diff --git a/tests/fixtures/persisted/memory/v0.2.0/store/mem/.2026-11-15.agent-runtime.codex.md.lock b/tests/fixtures/persisted/memory/v0.2.0/store/mem/.2026-11-15.agent-runtime.codex.md.lock new file mode 100644 index 0000000..e69de29 diff --git a/tests/fixtures/persisted/memory/v0.2.0/store/mem/.2026-11-15.agent-runtime.kimi-code.md.lock b/tests/fixtures/persisted/memory/v0.2.0/store/mem/.2026-11-15.agent-runtime.kimi-code.md.lock new file mode 100644 index 0000000..e69de29 diff --git a/tests/fixtures/persisted/memory/v0.2.0/store/mem/.2026-11-15.board-run.4c504769-9982-4419-beb1-9e45f2fb0295.md.lock b/tests/fixtures/persisted/memory/v0.2.0/store/mem/.2026-11-15.board-run.4c504769-9982-4419-beb1-9e45f2fb0295.md.lock new file mode 100644 index 0000000..e69de29 diff --git a/tests/fixtures/persisted/memory/v0.2.0/store/mem/.2026-11-15.board-run.fb601eff-5dfa-4474-ae36-d3fae997ff6c.md.lock b/tests/fixtures/persisted/memory/v0.2.0/store/mem/.2026-11-15.board-run.fb601eff-5dfa-4474-ae36-d3fae997ff6c.md.lock new file mode 100644 index 0000000..e69de29 diff --git a/tests/fixtures/persisted/memory/v0.2.0/store/mem/.2026-11-15.shared.md.lock b/tests/fixtures/persisted/memory/v0.2.0/store/mem/.2026-11-15.shared.md.lock new file mode 100644 index 0000000..e69de29 diff --git a/tests/fixtures/persisted/memory/v0.2.0/store/mem/.syncmill-ns-2cb9e21c9dc66ab8dd6826fd7028e103.lock b/tests/fixtures/persisted/memory/v0.2.0/store/mem/.syncmill-ns-2cb9e21c9dc66ab8dd6826fd7028e103.lock new file mode 100644 index 0000000..e69de29 diff --git a/tests/fixtures/persisted/memory/v0.2.0/store/mem/.syncmill-ns-42886aa205c9ff71943aece4ead9911c.lock b/tests/fixtures/persisted/memory/v0.2.0/store/mem/.syncmill-ns-42886aa205c9ff71943aece4ead9911c.lock new file mode 100644 index 0000000..e69de29 diff --git a/tests/fixtures/persisted/memory/v0.2.0/store/mem/.syncmill-ns-8ee87dbfcad6c9a732741f4837f06008.lock b/tests/fixtures/persisted/memory/v0.2.0/store/mem/.syncmill-ns-8ee87dbfcad6c9a732741f4837f06008.lock new file mode 100644 index 0000000..e69de29 diff --git a/tests/fixtures/persisted/memory/v0.2.0/store/mem/.syncmill-ns-a999ffded9900a8750c2f72fe167ec9b.lock b/tests/fixtures/persisted/memory/v0.2.0/store/mem/.syncmill-ns-a999ffded9900a8750c2f72fe167ec9b.lock new file mode 100644 index 0000000..e69de29 diff --git a/tests/fixtures/persisted/memory/v0.2.0/store/mem/.syncmill-ns-deea6649f1188da23bf56223e398ae36.lock b/tests/fixtures/persisted/memory/v0.2.0/store/mem/.syncmill-ns-deea6649f1188da23bf56223e398ae36.lock new file mode 100644 index 0000000..e69de29 diff --git a/tests/fixtures/persisted/memory/v0.2.0/store/mem/2026-11-15.agent-runtime.codex.md b/tests/fixtures/persisted/memory/v0.2.0/store/mem/2026-11-15.agent-runtime.codex.md new file mode 100644 index 0000000..087f9c2 --- /dev/null +++ b/tests/fixtures/persisted/memory/v0.2.0/store/mem/2026-11-15.agent-runtime.codex.md @@ -0,0 +1,340 @@ + +## Entry 2026-11-15T14:36:20.563+00:00 06bca7c9cd894bd4889d4612432d8f7a + +> created: 2026-11-15T14:36:20+00:00 +> tags: ["task-result", "codex", "task:39ccd2d9-a3ea-4283-9295-39f4d76af22e"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokroute fix add in calc.py + +**Agent:** codex + +**Output:** +codex (fake) call 1: frozenmemoryanchor tokroute + +**Files changed:** calc.py + +## Entry 2026-11-15T14:36:21.686+00:00 4c63a8a048df488d869812c0c950e1f7 + +> created: 2026-11-15T14:36:21+00:00 +> tags: ["pipeline-stage", "codex", "task:b55b0835-1329-4490-8370-92abcd2e6044"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokpipeline fix add in calc.py + +**Agent:** codex + +**Output:** +codex (fake) call 1: frozenmemoryanchor tokpipeline + +## Entry 2026-11-15T14:36:22.996+00:00 fd80102179cb4c69a665925beb3d9602 + +> created: 2026-11-15T14:36:22+00:00 +> tags: ["task-result", "codex", "task:a180bd85-2eb7-48f6-9a9d-239d13398e01"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokcompete fix add in calc.py + +**Agent:** codex + +**Output:** +codex (fake) call 1: frozenmemoryanchor tokcompete + +**Files changed:** calc.py + +## Entry 2026-11-15T14:36:24.114+00:00 e125089dbba34bc4b206db466a118247 + +> created: 2026-11-15T14:36:24+00:00 +> tags: ["council-proposal", "codex", "task:7cfe1b11-d283-4918-8479-10be2c218a12"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py + +**Agent:** codex + +**Output:** +codex (fake) call 1: frozenmemoryanchor tokcouncil + +## Entry 2026-11-15T14:36:24.158+00:00 a766fd3227374de2a765d143df0c9c69 + +> created: 2026-11-15T14:36:24+00:00 +> tags: ["council-critique", "codex", "task:7cfe1b11-d283-4918-8479-10be2c218a12"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py + +**Agent:** codex + +**Output:** +codex (fake) call 2: frozenmemoryanchor tokcouncil + +## Entry 2026-11-15T14:36:24.191+00:00 cb5fee1b39a940f99b5a1081a60b9b03 + +> created: 2026-11-15T14:36:24+00:00 +> tags: ["council-critique", "codex", "task:7cfe1b11-d283-4918-8479-10be2c218a12"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py + +**Agent:** codex + +**Output:** +codex (fake) call 3: frozenmemoryanchor tokcouncil + +## Entry 2026-11-15T14:36:24.263+00:00 935a9ae494494aea915884bc7561a7c3 + +> created: 2026-11-15T14:36:24+00:00 +> tags: ["task-result", "codex", "task:7cfe1b11-d283-4918-8479-10be2c218a12"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py + +**Agent:** codex + +**Output:** +codex (fake) call 4: frozenmemoryanchor tokcouncil + +**Files changed:** calc.py + +## Entry 2026-11-15T14:36:25.356+00:00 2cea5bbb15fd493abd1cca1d89a3504f + +> created: 2026-11-15T14:36:25+00:00 +> tags: ["decompose-plan", "codex", "task:720ea79c-a729-4068-9e97-9315ad0e8e61"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py + +**Agent:** codex + +**Output:** +["alpha part of the work frozenmemoryanchor tokdecompose", "beta part of the work frozenmemoryanchor tokdecompose"] + +## Entry 2026-11-15T14:36:25.429+00:00 c2af00fb23434a00addfdd1745a5ffb8 + +> created: 2026-11-15T14:36:25+00:00 +> tags: ["decompose-subtask", "codex", "task:720ea79c-a729-4068-9e97-9315ad0e8e61"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py + +**Agent:** codex + +**Output:** +codex (fake) call 2: frozenmemoryanchor tokdecompose + +## Entry 2026-11-15T14:36:25.543+00:00 9b49f1a401d4459d83dc62634715fd34 + +> created: 2026-11-15T14:36:25+00:00 +> tags: ["task-result", "codex", "task:720ea79c-a729-4068-9e97-9315ad0e8e61"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py + +**Agent:** codex + +**Output:** +codex (fake) call 3: frozenmemoryanchor tokdecompose + +**Files changed:** calc.py + +## Entry 2026-11-15T14:36:26.685+00:00 6dec38551b484093b14a88a95fe8aa44 + +> created: 2026-11-15T14:36:26+00:00 +> tags: ["task-result", "codex", "task:2dca9c44-de01-4639-8ea9-7e9d1bcad61a"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokunicode say something long + +**Agent:** codex + +**Output:** +frozenmemoryanchor tokunicode 한글 본문 と日本語 🙂 +second line after CRLF +가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라 + +## Entry 2026-11-15T14:36:27.827+00:00 a65cd18767734d2086c0777c5df2e084 + +> created: 2026-11-15T14:36:27+00:00 +> tags: ["task-result", "codex", "task:444ee417-970b-46ed-9789-ce4590d94b9d"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokheadings review calc.py + +**Agent:** codex + +**Output:** +frozenmemoryanchor tokheadings summary line + +### Findings +> tags: ["task-result", "codex", "task:444ee417-970b-46ed-9789-ce4590d94b9d"] + + +frozenmemoryanchor tokheadings findings. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. + +### Next steps +> tags: ["task-result", "codex", "task:444ee417-970b-46ed-9789-ce4590d94b9d"] + + +frozenmemoryanchor tokheadings steps. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. + +## Entry 2026-11-15T14:36:29.007+00:00 4d8425c54ddb4618871124fada0d2155 + +> created: 2026-11-15T14:36:29+00:00 +> tags: ["task-result", "codex", "task:f61e779a-f0f1-42af-bb14-cf2c3dcfebcc"] + +**Task Result** + +**Prompt:** frozenmemoryanchor toklong fix add in calc.py. + +requirement-000 keeps the sum of two integers exact + +requirement-001 keeps the sum of two integers exact + +requirement-002 keeps the sum of two integers exact + +requirement-003 keeps the sum of two integers exact + +requirement-004 keeps the sum of two integers exact + +requirement-005 keeps the sum of two integers exact + +requirement-006 keeps the sum of two integers exact + +requirement-007 keeps the sum of two integers exact + +requirement-008 keeps the sum of two integers exact + +requirement-009 keeps the sum of two integers exact + +requirement-010 keeps the sum of two integers exact + +requirement-011 keeps the sum of two integers exact + +requirement-012 keeps the sum of two integers exact + +requirement-013 keeps the sum of two integers exact + +requirement-014 keeps the sum of two integers exact + +requirement-015 keeps the sum of two integers exact + +requirement-016 keeps the sum of two integers exact + +requirement-017 keeps the sum of two integers exact + +requirement-018 keeps the sum of two integers exact + +requirement-019 keeps the sum of two integers exact + +requirement-020 keeps the sum of two integers exact + +requirement-021 keeps the sum of two integers exact + +requirement-022 keeps the sum of two integers exact + +requirement-023 keeps the sum of two integers exact + +requirement-024 keeps the sum of two integers exact + +requirement-025 keeps the sum of two integers exact + +requirement-026 keeps the sum of two integers exact + +requirement-027 keeps the sum of two integers exact + +requirement-028 keeps the sum of two integers exact + +requirement-029 keeps the sum of two integers exact + +requirement-030 keeps the sum of two integers exact + +requirement-031 keeps the sum of two integers exact + +requirement-032 keeps the sum of two integers exact + +requirement-033 keeps the sum of two integers exact + +requirement-034 keeps the sum of two integers exact + +requirement-035 keeps the sum of two integers exact + +requirement-036 keeps the sum of two integers exact + +requirement-037 keeps the sum of two integers exact + +requirement-038 keeps the sum of two integers exact + +requirement-039 keeps the sum of two integers exact + +requirement-040 keeps the sum of two integers exact + +requirement-041 keeps the sum of two integers exact + +requirement-042 keeps the sum of two integers exact + +requirement-043 keeps the sum of two integers exact + +requirement-044 keeps the sum of two integers exact + +requirement-045 keeps the sum of two integers exact + +requirement-046 keeps the sum of two integers exact + +requirement-047 keeps the sum of two integers exact + +requirement-048 keeps the sum of two integers exact + +requirement-049 keeps the sum of two integers exact + +requirement-050 keeps the sum of two integers exact + +requirement-051 keeps the sum of two integers exact + +requirement-052 keeps the sum of two integers exact + +requirement-053 keeps the sum of two integers exact + +requirement-054 keeps the sum of two integers exact + +requirement-055 keeps the sum of two integers exact + +requirement-056 keeps the sum of two integers exact + +requirement-057 keeps the sum of two integers exact + +requirement-058 keeps the sum of two integers exact + +requirement-059 keeps the sum of two integers exact + +**Agent:** codex + +**Output:** +codex (fake) call 1: frozenmemoryanchor toklong + +## Entry 2026-11-15T14:36:35.182+00:00 b0d42d9942644c7e8aef1cbdc521f588 + +> created: 2026-11-15T14:36:35+00:00 +> tags: ["room-result", "codex", "task:768ba721-86d0-4275-baf0-10ddbfaa48cc"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokroom fix add in calc.py + +**Agent:** codex + +**Output:** +codex (fake) call 1: frozenmemoryanchor tokroom + +**Files changed:** calc.py diff --git a/tests/fixtures/persisted/memory/v0.2.0/store/mem/2026-11-15.agent-runtime.kimi-code.md b/tests/fixtures/persisted/memory/v0.2.0/store/mem/2026-11-15.agent-runtime.kimi-code.md new file mode 100644 index 0000000..d97d5b4 --- /dev/null +++ b/tests/fixtures/persisted/memory/v0.2.0/store/mem/2026-11-15.agent-runtime.kimi-code.md @@ -0,0 +1,72 @@ + +## Entry 2026-11-15T14:36:21.827+00:00 f6a7c46116664fd9bad417aac7d114ad + +> created: 2026-11-15T14:36:21+00:00 +> tags: ["task-result", "kimi-code", "task:b55b0835-1329-4490-8370-92abcd2e6044"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokpipeline fix add in calc.py + +**Agent:** kimi-code + +**Output:** +kimi (fake) call 1: frozenmemoryanchor tokpipeline + +**Files changed:** calc.py + +## Entry 2026-11-15T14:36:24.121+00:00 bc629785755647c78c5a6c6926287f9e + +> created: 2026-11-15T14:36:24+00:00 +> tags: ["council-proposal", "kimi-code", "task:7cfe1b11-d283-4918-8479-10be2c218a12"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py + +**Agent:** kimi-code + +**Output:** +kimi (fake) call 1: frozenmemoryanchor tokcouncil + +## Entry 2026-11-15T14:36:24.163+00:00 ceaeffba22d9456da73835d492bb8b96 + +> created: 2026-11-15T14:36:24+00:00 +> tags: ["council-critique", "kimi-code", "task:7cfe1b11-d283-4918-8479-10be2c218a12"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py + +**Agent:** kimi-code + +**Output:** +kimi (fake) call 2: frozenmemoryanchor tokcouncil + +## Entry 2026-11-15T14:36:24.196+00:00 be4a537c7416407a85d75fa51cf27800 + +> created: 2026-11-15T14:36:24+00:00 +> tags: ["council-critique", "kimi-code", "task:7cfe1b11-d283-4918-8479-10be2c218a12"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py + +**Agent:** kimi-code + +**Output:** +kimi (fake) call 3: frozenmemoryanchor tokcouncil + +## Entry 2026-11-15T14:36:25.434+00:00 7e729c4d82894c7fabbd6e8dddcd55f7 + +> created: 2026-11-15T14:36:25+00:00 +> tags: ["decompose-subtask", "kimi-code", "task:720ea79c-a729-4068-9e97-9315ad0e8e61"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py + +**Agent:** kimi-code + +**Output:** +kimi (fake) call 1: frozenmemoryanchor tokdecompose diff --git a/tests/fixtures/persisted/memory/v0.2.0/store/mem/2026-11-15.board-run.4c504769-9982-4419-beb1-9e45f2fb0295.md b/tests/fixtures/persisted/memory/v0.2.0/store/mem/2026-11-15.board-run.4c504769-9982-4419-beb1-9e45f2fb0295.md new file mode 100644 index 0000000..f3bd0a7 --- /dev/null +++ b/tests/fixtures/persisted/memory/v0.2.0/store/mem/2026-11-15.board-run.4c504769-9982-4419-beb1-9e45f2fb0295.md @@ -0,0 +1,23 @@ + +## Entry 2026-11-15T14:36:36.848+00:00 a22352c8759b492397469d31026293bf + +> created: 2026-11-15T14:36:36+00:00 +> tags: ["pipeline-stage", "codex", "task:d48c359b-7b9c-4643-9680-6b6e8f309884"] + +**Task Result** + +**Prompt:** You are working on a tracked work-board item. +Goal: frozen + +Task: frozenmemoryanchor tokkilled fix add in calc.py + +When you finish, you MAY append ONE fenced block reporting the board update (every field optional): +```syncmill-board +{"state": "review", "handoff": "", "outputs": [""], "human_required": false} +``` +Use "state": "blocked" with a "blocked_reason" if you cannot proceed, or "human_required": true if a human must step in. Requesting "done" only takes effect if the work is independently verified (a passing quality gate or a human sign-off); otherwise it is recorded as "review". + +**Agent:** codex + +**Output:** +codex (fake) call 1: frozenmemoryanchor tokkilled diff --git a/tests/fixtures/persisted/memory/v0.2.0/store/mem/2026-11-15.board-run.fb601eff-5dfa-4474-ae36-d3fae997ff6c.md b/tests/fixtures/persisted/memory/v0.2.0/store/mem/2026-11-15.board-run.fb601eff-5dfa-4474-ae36-d3fae997ff6c.md new file mode 100644 index 0000000..94955f0 --- /dev/null +++ b/tests/fixtures/persisted/memory/v0.2.0/store/mem/2026-11-15.board-run.fb601eff-5dfa-4474-ae36-d3fae997ff6c.md @@ -0,0 +1,25 @@ + +## Entry 2026-11-15T14:36:31.830+00:00 a6cdedf90e0a4922b5523a780b4baf21 + +> created: 2026-11-15T14:36:31+00:00 +> tags: ["task-result", "codex", "task:06b4939d-6fad-44cd-b113-3eebdf988bca"] + +**Task Result** + +**Prompt:** You are working on a tracked work-board item. +Goal: frozen + +Task: frozenmemoryanchor tokboard fix add in calc.py + +When you finish, you MAY append ONE fenced block reporting the board update (every field optional): +```syncmill-board +{"state": "review", "handoff": "", "outputs": [""], "human_required": false} +``` +Use "state": "blocked" with a "blocked_reason" if you cannot proceed, or "human_required": true if a human must step in. Requesting "done" only takes effect if the work is independently verified (a passing quality gate or a human sign-off); otherwise it is recorded as "review". + +**Agent:** codex + +**Output:** +codex (fake) call 1: frozenmemoryanchor tokboard + +**Files changed:** calc.py diff --git a/tests/fixtures/persisted/memory/v0.2.0/store/mem/2026-11-15.shared.md b/tests/fixtures/persisted/memory/v0.2.0/store/mem/2026-11-15.shared.md new file mode 100644 index 0000000..66a0bf4 --- /dev/null +++ b/tests/fixtures/persisted/memory/v0.2.0/store/mem/2026-11-15.shared.md @@ -0,0 +1,431 @@ + +## Entry 2026-11-15T14:36:20.569+00:00 c67ca3cf46fd440c88d6c24ccad7de17 + +> created: 2026-11-15T14:36:20+00:00 +> tags: ["codex", "task-result", "task:39ccd2d9-a3ea-4283-9295-39f4d76af22e", "shared-from=49277171-cdb0-4522-8f1b-5a0df361d3f2"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokroute fix add in calc.py + +**Agent:** codex + +**Output:** +codex (fake) call 1: frozenmemoryanchor tokroute + +**Files changed:** calc.py + +## Entry 2026-11-15T14:36:21.691+00:00 6480915efaf5403cac0e35d6219c6895 + +> created: 2026-11-15T14:36:21+00:00 +> tags: ["codex", "pipeline-stage", "task:b55b0835-1329-4490-8370-92abcd2e6044", "shared-from=27d2de18-4c14-437d-901f-dbf7f20030d3"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokpipeline fix add in calc.py + +**Agent:** codex + +**Output:** +codex (fake) call 1: frozenmemoryanchor tokpipeline + +## Entry 2026-11-15T14:36:21.830+00:00 87348075a9fa474c80835e40c7d38675 + +> created: 2026-11-15T14:36:21+00:00 +> tags: ["kimi-code", "task-result", "task:b55b0835-1329-4490-8370-92abcd2e6044", "shared-from=ffc1c84d-b10e-4a6b-95f3-d146ab3f252b"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokpipeline fix add in calc.py + +**Agent:** kimi-code + +**Output:** +kimi (fake) call 1: frozenmemoryanchor tokpipeline + +**Files changed:** calc.py + +## Entry 2026-11-15T14:36:23.001+00:00 dd46379709c642c38362a40f79e332e3 + +> created: 2026-11-15T14:36:23+00:00 +> tags: ["codex", "task-result", "task:a180bd85-2eb7-48f6-9a9d-239d13398e01", "shared-from=366df9b1-ccdc-46db-9ca9-c7151155ed7f"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokcompete fix add in calc.py + +**Agent:** codex + +**Output:** +codex (fake) call 1: frozenmemoryanchor tokcompete + +**Files changed:** calc.py + +## Entry 2026-11-15T14:36:24.119+00:00 814d8a5236a94c14b376b79500c0cd70 + +> created: 2026-11-15T14:36:24+00:00 +> tags: ["codex", "council-proposal", "task:7cfe1b11-d283-4918-8479-10be2c218a12", "shared-from=28cd638e-33ce-4847-b57c-4c487d1cdae6"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py + +**Agent:** codex + +**Output:** +codex (fake) call 1: frozenmemoryanchor tokcouncil + +## Entry 2026-11-15T14:36:24.124+00:00 4ddbc650a83a4c5e86e08507a5bc1fc9 + +> created: 2026-11-15T14:36:24+00:00 +> tags: ["council-proposal", "kimi-code", "task:7cfe1b11-d283-4918-8479-10be2c218a12", "shared-from=b9b7f90f-2a79-4feb-b961-3dca7a7adbed"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py + +**Agent:** kimi-code + +**Output:** +kimi (fake) call 1: frozenmemoryanchor tokcouncil + +## Entry 2026-11-15T14:36:24.160+00:00 9c4605e0d731427f86d8d0ca03560a52 + +> created: 2026-11-15T14:36:24+00:00 +> tags: ["codex", "council-critique", "task:7cfe1b11-d283-4918-8479-10be2c218a12", "shared-from=bb76a02a-ea92-48a7-b5c7-4bb654cda7a9"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py + +**Agent:** codex + +**Output:** +codex (fake) call 2: frozenmemoryanchor tokcouncil + +## Entry 2026-11-15T14:36:24.165+00:00 0a01810a9d43440fbd1bb14d9f752d40 + +> created: 2026-11-15T14:36:24+00:00 +> tags: ["council-critique", "kimi-code", "task:7cfe1b11-d283-4918-8479-10be2c218a12", "shared-from=5989c9f4-d81e-4c10-96a3-ffb678935dd1"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py + +**Agent:** kimi-code + +**Output:** +kimi (fake) call 2: frozenmemoryanchor tokcouncil + +## Entry 2026-11-15T14:36:24.193+00:00 a75db13ec590477991635d713d912b2b + +> created: 2026-11-15T14:36:24+00:00 +> tags: ["codex", "council-critique", "task:7cfe1b11-d283-4918-8479-10be2c218a12", "shared-from=d4ebd12a-9b60-4d0f-9fed-c9c2debee31a"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py + +**Agent:** codex + +**Output:** +codex (fake) call 3: frozenmemoryanchor tokcouncil + +## Entry 2026-11-15T14:36:24.198+00:00 570641398bad4fc894dbc133c863ccf3 + +> created: 2026-11-15T14:36:24+00:00 +> tags: ["council-critique", "kimi-code", "task:7cfe1b11-d283-4918-8479-10be2c218a12", "shared-from=2430469c-2549-48d9-9c02-2811cdfa0dbd"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py + +**Agent:** kimi-code + +**Output:** +kimi (fake) call 3: frozenmemoryanchor tokcouncil + +## Entry 2026-11-15T14:36:24.266+00:00 5009e16f4d4c4c4188ae8e26714114da + +> created: 2026-11-15T14:36:24+00:00 +> tags: ["codex", "task-result", "task:7cfe1b11-d283-4918-8479-10be2c218a12", "shared-from=6de02f80-f2d4-42e4-a49e-42d343196771"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py + +**Agent:** codex + +**Output:** +codex (fake) call 4: frozenmemoryanchor tokcouncil + +**Files changed:** calc.py + +## Entry 2026-11-15T14:36:25.361+00:00 3d2ef6423aeb40f7b21f5bd0d1155e4d + +> created: 2026-11-15T14:36:25+00:00 +> tags: ["codex", "decompose-plan", "task:720ea79c-a729-4068-9e97-9315ad0e8e61", "shared-from=b8db39bc-7d7e-450e-9896-ba5ba7f09b41"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py + +**Agent:** codex + +**Output:** +["alpha part of the work frozenmemoryanchor tokdecompose", "beta part of the work frozenmemoryanchor tokdecompose"] + +## Entry 2026-11-15T14:36:25.432+00:00 ee88340380d348dcac7b43d709601d08 + +> created: 2026-11-15T14:36:25+00:00 +> tags: ["codex", "decompose-subtask", "task:720ea79c-a729-4068-9e97-9315ad0e8e61", "shared-from=f24d0586-6556-478a-acda-dfe67c8d10d0"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py + +**Agent:** codex + +**Output:** +codex (fake) call 2: frozenmemoryanchor tokdecompose + +## Entry 2026-11-15T14:36:25.436+00:00 50b7e3437111438999fcfa511716e21b + +> created: 2026-11-15T14:36:25+00:00 +> tags: ["decompose-subtask", "kimi-code", "task:720ea79c-a729-4068-9e97-9315ad0e8e61", "shared-from=74a3f417-ba22-4d9a-9592-5a5657facab9"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py + +**Agent:** kimi-code + +**Output:** +kimi (fake) call 1: frozenmemoryanchor tokdecompose + +## Entry 2026-11-15T14:36:25.546+00:00 c3eed48c2f34462e897b5697451253dd + +> created: 2026-11-15T14:36:25+00:00 +> tags: ["codex", "task-result", "task:720ea79c-a729-4068-9e97-9315ad0e8e61", "shared-from=edb0103a-4fcc-45ed-8e2a-2519f8a41cea"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py + +**Agent:** codex + +**Output:** +codex (fake) call 3: frozenmemoryanchor tokdecompose + +**Files changed:** calc.py + +## Entry 2026-11-15T14:36:26.691+00:00 ba18256fb6ee4313a46756b320418d6b + +> created: 2026-11-15T14:36:26+00:00 +> tags: ["codex", "task-result", "task:2dca9c44-de01-4639-8ea9-7e9d1bcad61a", "shared-from=c68ed626-ef79-4c55-a892-e3e719d647d7"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokunicode say something long + +**Agent:** codex + +**Output:** +frozenmemoryanchor tokunicode 한글 본문 と日本語 🙂 +second line after CRLF +가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라 + +## Entry 2026-11-15T14:36:27.833+00:00 8c7ed18ab4404c89b55bb0ee8862669e + +> created: 2026-11-15T14:36:27+00:00 +> tags: ["codex", "task-result", "task:444ee417-970b-46ed-9789-ce4590d94b9d", "shared-from=569c493f-022c-461f-b12d-920b70886627"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokheadings review calc.py + +**Agent:** codex + +**Output:** +frozenmemoryanchor tokheadings summary line + +### Findings +> tags: ["codex", "task-result", "task:444ee417-970b-46ed-9789-ce4590d94b9d", "shared-from=569c493f-022c-461f-b12d-920b70886627"] + + +frozenmemoryanchor tokheadings findings. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. + +### Next steps +> tags: ["codex", "task-result", "task:444ee417-970b-46ed-9789-ce4590d94b9d", "shared-from=569c493f-022c-461f-b12d-920b70886627"] + + +frozenmemoryanchor tokheadings steps. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. + +## Entry 2026-11-15T14:36:29.013+00:00 7c8182059c03482da49e150dad999fc9 + +> created: 2026-11-15T14:36:29+00:00 +> tags: ["codex", "task-result", "task:f61e779a-f0f1-42af-bb14-cf2c3dcfebcc", "shared-from=1c95e91e-bd90-460d-812f-bff92b3cc599"] + +**Task Result** + +**Prompt:** frozenmemoryanchor toklong fix add in calc.py. + +requirement-000 keeps the sum of two integers exact + +requirement-001 keeps the sum of two integers exact + +requirement-002 keeps the sum of two integers exact + +requirement-003 keeps the sum of two integers exact + +requirement-004 keeps the sum of two integers exact + +requirement-005 keeps the sum of two integers exact + +requirement-006 keeps the sum of two integers exact + +requirement-007 keeps the sum of two integers exact + +requirement-008 keeps the sum of two integers exact + +requirement-009 keeps the sum of two integers exact + +requirement-010 keeps the sum of two integers exact + +requirement-011 keeps the sum of two integers exact + +requirement-012 keeps the sum of two integers exact + +requirement-013 keeps the sum of two integers exact + +requirement-014 keeps the sum of two integers exact + +requirement-015 keeps the sum of two integers exact + +requirement-016 keeps the sum of two integers exact + +requirement-017 keeps the sum of two integers exact + +requirement-018 keeps the sum of two integers exact + +requirement-019 keeps the sum of two integers exact + +requirement-020 keeps the sum of two integers exact + +requirement-021 keeps the sum of two integers exact + +requirement-022 keeps the sum of two integers exact + +requirement-023 keeps the sum of two integers exact + +requirement-024 keeps the sum of two integers exact + +requirement-025 keeps the sum of two integers exact + +requirement-026 keeps the sum of two integers exact + +requirement-027 keeps the sum of two integers exact + +requirement-028 keeps the sum of two integers exact + +requirement-029 keeps the sum of two integers exact + +requirement-030 keeps the sum of two integers exact + +requirement-031 keeps the sum of two integers exact + +requirement-032 keeps the sum of two integers exact + +requirement-033 keeps the sum of two integers exact + +requirement-034 keeps the sum of two integers exact + +requirement-035 keeps the sum of two integers exact + +requirement-036 keeps the sum of two integers exact + +## Entry 2026-11-15T14:36:29.017+00:00 e9429c5c807142159f247481562effe3 + +> created: 2026-11-15T14:36:29+00:00 +> tags: ["codex", "task-result", "task:f61e779a-f0f1-42af-bb14-cf2c3dcfebcc", "shared-from=2331bbdb-26f8-401a-b356-5ff742a7e3fd"] + +requirement-037 keeps the sum of two integers exact + +requirement-038 keeps the sum of two integers exact + +requirement-039 keeps the sum of two integers exact + +requirement-040 keeps the sum of two integers exact + +requirement-041 keeps the sum of two integers exact + +requirement-042 keeps the sum of two integers exact + +requirement-043 keeps the sum of two integers exact + +requirement-044 keeps the sum of two integers exact + +requirement-045 keeps the sum of two integers exact + +requirement-046 keeps the sum of two integers exact + +requirement-047 keeps the sum of two integers exact + +requirement-048 keeps the sum of two integers exact + +requirement-049 keeps the sum of two integers exact + +requirement-050 keeps the sum of two integers exact + +requirement-051 keeps the sum of two integers exact + +requirement-052 keeps the sum of two integers exact + +requirement-053 keeps the sum of two integers exact + +requirement-054 keeps the sum of two integers exact + +requirement-055 keeps the sum of two integers exact + +requirement-056 keeps the sum of two integers exact + +requirement-057 keeps the sum of two integers exact + +requirement-058 keeps the sum of two integers exact + +requirement-059 keeps the sum of two integers exact + +**Agent:** codex + +**Output:** +codex (fake) call 1: frozenmemoryanchor toklong + +## Entry 2026-11-15T14:36:31.839+00:00 64bdb3a583ed4825a2a2a80e599a754d + +> created: 2026-11-15T14:36:31+00:00 +> tags: ["board-result:b97d9de5-d8dd-40c7-8448-df510e41f5cf"] + +**Board Item Result** + +**Item:** b97d9de5-d8dd-40c7-8448-df510e41f5cf + +**Task:** frozenmemoryanchor tokboard fix add in calc.py + +**Output:** +codex (fake) call 1: frozenmemoryanchor tokboard + +## Entry 2026-11-15T14:36:35.188+00:00 76b64568deae42b497367f1e501ecafe + +> created: 2026-11-15T14:36:35+00:00 +> tags: ["codex", "room-result", "task:768ba721-86d0-4275-baf0-10ddbfaa48cc", "shared-from=69e05f8b-bfc7-43a4-8ace-d9726aacfd63"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokroom fix add in calc.py + +**Agent:** codex + +**Output:** +codex (fake) call 1: frozenmemoryanchor tokroom + +**Files changed:** calc.py diff --git a/tests/fixtures/persisted/memory/v0.2.0/store/mm.db b/tests/fixtures/persisted/memory/v0.2.0/store/mm.db new file mode 100644 index 0000000..237d83f Binary files /dev/null and b/tests/fixtures/persisted/memory/v0.2.0/store/mm.db differ diff --git a/tests/fixtures/persisted/memory/v0.2.0/store/mm.db-shm b/tests/fixtures/persisted/memory/v0.2.0/store/mm.db-shm new file mode 100644 index 0000000..7c264cf Binary files /dev/null and b/tests/fixtures/persisted/memory/v0.2.0/store/mm.db-shm differ diff --git a/tests/fixtures/persisted/memory/v0.2.0/store/mm.db-wal b/tests/fixtures/persisted/memory/v0.2.0/store/mm.db-wal new file mode 100644 index 0000000..fa8f1e9 Binary files /dev/null and b/tests/fixtures/persisted/memory/v0.2.0/store/mm.db-wal differ diff --git a/tests/fixtures/persisted/memory/v0.3.0/index.json b/tests/fixtures/persisted/memory/v0.3.0/index.json new file mode 100644 index 0000000..d8f2c11 --- /dev/null +++ b/tests/fixtures/persisted/memory/v0.3.0/index.json @@ -0,0 +1,545 @@ +{ + "anchor": "frozenmemoryanchor", + "date": "2026-11-15", + "files": { + "release-read.json": "f70e4e5d2deb6a5afe6e334c5481779508b5743a10bd7332dde679f2711838ec", + "store/board.db": "10f1736b00f1c69f7d36b2b6a549578693bc5f2a00882c7c61c1f1bc4035bbc4", + "store/board.db-shm": "4d38947a5996cf2ab3acc3168b428fa06538478b1b6b7638921cd4ff90099ece", + "store/board.db-wal": "ed0273b792a916ad7428795880462cb917091cf0c15f84f3537793b167f11a81", + "store/board.db.gc-lock": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "store/mem/.2026-11-15.agent-runtime.codex.md.lock": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "store/mem/.2026-11-15.agent-runtime.kimi-code.md.lock": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "store/mem/.2026-11-15.board-run.5992afb8-d015-4009-81d1-aef11dd7c6ad.md.lock": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "store/mem/.2026-11-15.board-run.dc18cb96-9616-48bf-9ea0-4f84469bd299.md.lock": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "store/mem/.2026-11-15.shared.md.lock": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "store/mem/.syncmill-ns-1d1fc06506367405ccdc7f3235e15883.lock": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "store/mem/.syncmill-ns-930b7a5b82485ec440b00843470a38d7.lock": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "store/mem/.syncmill-ns-b89560d04c6de3d5e39180999e9e40df.lock": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "store/mem/.syncmill-ns-d2ac05253a75eddb34b7a5df8e6286ae.lock": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "store/mem/.syncmill-ns-dc3afa44d4409b79e5a2a1df89a4b3e5.lock": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "store/mem/2026-11-15.agent-runtime.codex.md": "21f05f185f2bb3afed3c5c3a1b85e4d0ce85dd030c1703a079317343c4590c90", + "store/mem/2026-11-15.agent-runtime.kimi-code.md": "01bc6792f6bcf73da88d1d611d76b66b8b22945a898f48e29fb37752daac3ef3", + "store/mem/2026-11-15.board-run.5992afb8-d015-4009-81d1-aef11dd7c6ad.md": "08bdf9fa3f77be89bea2a26df61a1964d3649f79855e538c2c69c6b92eb7988f", + "store/mem/2026-11-15.board-run.dc18cb96-9616-48bf-9ea0-4f84469bd299.md": "932534918fdb2e1eb17279a204c3fbd0e83f03d99fe8cedaad9e3c07d23de35e", + "store/mem/2026-11-15.shared.md": "4ead8689dc2595c861c4879ac5ff65a8978de71a8c0545315e79cd6c0a8c36d2", + "store/mm.db": "8b109ceaab2d0b3b1b9c05bafee6eed62aea1a57d2d522f836c5c03700e91e92", + "store/mm.db-shm": "8e8242f4789ac5619445933da3f9f0edaa6b57a437b843c2b2ac746a8a5d33ff", + "store/mm.db-wal": "527af012eca4ad7723b11ebbc5252ad1ce9460ea2e0c7d1552bb340491f63dc9" + }, + "generating_root": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip", + "memtomem": "0.6.8", + "release": "0.3.0", + "scenarios": { + "board-done": { + "item_id": "899be792-3851-4e3c-8b17-6ab33ccd5a01", + "rows": [ + { + "body": "**Task Result**\n\n**Prompt:** You are working on a tracked work-board item.\nGoal: frozen\n\nTask: frozenmemoryanchor tokboard fix add in calc.py\n\nWhen you finish, you MAY append ONE fenced block reporting the board update (every field optional):\n```syncmill-board\n{\"state\": \"review\", \"handoff\": \"\", \"outputs\": [\"\"], \"human_required\": false}\n```\nUse \"state\": \"blocked\" with a \"blocked_reason\" if you cannot proceed, or \"human_required\": true if a human must step in. Requesting \"done\" only takes effect if the work is independently verified (a passing quality gate or a human sign-off); otherwise it is recorded as \"review\".\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokboard\n\n**Files changed:** calc.py", + "body_is_release_text": true, + "namespace": "board-run:5992afb8-d015-4009-81d1-aef11dd7c6ad", + "tags": [ + "codex", + "task-result", + "task:*" + ] + }, + { + "body": "**Board Item Result**\n\n**Item:** 899be792-3851-4e3c-8b17-6ab33ccd5a01\n\n**Task:** frozenmemoryanchor tokboard fix add in calc.py\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokboard", + "namespace": "shared", + "tags": [ + "board-result:899be792-3851-4e3c-8b17-6ab33ccd5a01" + ] + } + ], + "run_id": "5992afb8-d015-4009-81d1-aef11dd7c6ad", + "store": "store", + "task": "frozenmemoryanchor tokboard fix add in calc.py", + "token": "tokboard" + }, + "board-killed": { + "claimed_at": 1794744190.6967092, + "item_id": "4cb3a977-916b-4f3f-a48c-4180d8adb2d4", + "rows": [ + { + "body": "**Task Result**\n\n**Prompt:** You are working on a tracked work-board item.\nGoal: frozen\n\nTask: frozenmemoryanchor tokkilled fix add in calc.py\n\nWhen you finish, you MAY append ONE fenced block reporting the board update (every field optional):\n```syncmill-board\n{\"state\": \"review\", \"handoff\": \"\", \"outputs\": [\"\"], \"human_required\": false}\n```\nUse \"state\": \"blocked\" with a \"blocked_reason\" if you cannot proceed, or \"human_required\": true if a human must step in. Requesting \"done\" only takes effect if the work is independently verified (a passing quality gate or a human sign-off); otherwise it is recorded as \"review\".\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokkilled", + "body_is_release_text": true, + "namespace": "board-run:dc18cb96-9616-48bf-9ea0-4f84469bd299", + "tags": [ + "codex", + "pipeline-stage", + "task:*" + ] + } + ], + "run_id": "dc18cb96-9616-48bf-9ea0-4f84469bd299", + "store": "store", + "task": "frozenmemoryanchor tokkilled fix add in calc.py", + "token": "tokkilled" + }, + "compete": { + "prompt": "frozenmemoryanchor tokcompete fix add in calc.py", + "rows": [ + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcompete fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokcompete\n\n**Files changed:** calc.py", + "namespace": "agent-runtime:codex", + "tags": [ + "codex", + "task-result", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcompete fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokcompete\n\n**Files changed:** calc.py", + "namespace": "shared", + "tags": [ + "codex", + "shared-from=*", + "task-result", + "task:*" + ] + } + ], + "store": "store", + "token": "tokcompete" + }, + "council": { + "prompt": "frozenmemoryanchor tokcouncil fix add in calc.py", + "rows": [ + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokcouncil", + "namespace": "agent-runtime:codex", + "tags": [ + "codex", + "council-proposal", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokcouncil", + "namespace": "shared", + "tags": [ + "codex", + "council-proposal", + "shared-from=*", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 2: frozenmemoryanchor tokcouncil", + "namespace": "agent-runtime:codex", + "tags": [ + "codex", + "council-critique", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 2: frozenmemoryanchor tokcouncil", + "namespace": "shared", + "tags": [ + "codex", + "council-critique", + "shared-from=*", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 3: frozenmemoryanchor tokcouncil", + "namespace": "agent-runtime:codex", + "tags": [ + "codex", + "council-critique", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 3: frozenmemoryanchor tokcouncil", + "namespace": "shared", + "tags": [ + "codex", + "council-critique", + "shared-from=*", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** kimi-code\n\n**Output:**\nkimi (fake) call 1: frozenmemoryanchor tokcouncil", + "namespace": "agent-runtime:kimi-code", + "tags": [ + "council-proposal", + "kimi-code", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** kimi-code\n\n**Output:**\nkimi (fake) call 1: frozenmemoryanchor tokcouncil", + "namespace": "shared", + "tags": [ + "council-proposal", + "kimi-code", + "shared-from=*", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** kimi-code\n\n**Output:**\nkimi (fake) call 2: frozenmemoryanchor tokcouncil", + "namespace": "agent-runtime:kimi-code", + "tags": [ + "council-critique", + "kimi-code", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** kimi-code\n\n**Output:**\nkimi (fake) call 2: frozenmemoryanchor tokcouncil", + "namespace": "shared", + "tags": [ + "council-critique", + "kimi-code", + "shared-from=*", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** kimi-code\n\n**Output:**\nkimi (fake) call 3: frozenmemoryanchor tokcouncil", + "namespace": "agent-runtime:kimi-code", + "tags": [ + "council-critique", + "kimi-code", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** kimi-code\n\n**Output:**\nkimi (fake) call 3: frozenmemoryanchor tokcouncil", + "namespace": "shared", + "tags": [ + "council-critique", + "kimi-code", + "shared-from=*", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 4: frozenmemoryanchor tokcouncil\n\n**Files changed:** calc.py", + "namespace": "agent-runtime:codex", + "tags": [ + "codex", + "task-result", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 4: frozenmemoryanchor tokcouncil\n\n**Files changed:** calc.py", + "namespace": "shared", + "tags": [ + "codex", + "shared-from=*", + "task-result", + "task:*" + ] + } + ], + "store": "store", + "token": "tokcouncil" + }, + "decompose": { + "prompt": "frozenmemoryanchor tokdecompose fix add in calc.py", + "rows": [ + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\n[\"alpha part of the work frozenmemoryanchor tokdecompose\", \"beta part of the work frozenmemoryanchor tokdecompose\"]", + "namespace": "agent-runtime:codex", + "tags": [ + "codex", + "decompose-plan", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\n[\"alpha part of the work frozenmemoryanchor tokdecompose\", \"beta part of the work frozenmemoryanchor tokdecompose\"]", + "namespace": "shared", + "tags": [ + "codex", + "decompose-plan", + "shared-from=*", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 2: frozenmemoryanchor tokdecompose", + "namespace": "agent-runtime:codex", + "tags": [ + "codex", + "decompose-subtask", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 2: frozenmemoryanchor tokdecompose", + "namespace": "shared", + "tags": [ + "codex", + "decompose-subtask", + "shared-from=*", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py\n\n**Agent:** kimi-code\n\n**Output:**\nkimi (fake) call 1: frozenmemoryanchor tokdecompose", + "namespace": "agent-runtime:kimi-code", + "tags": [ + "decompose-subtask", + "kimi-code", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py\n\n**Agent:** kimi-code\n\n**Output:**\nkimi (fake) call 1: frozenmemoryanchor tokdecompose", + "namespace": "shared", + "tags": [ + "decompose-subtask", + "kimi-code", + "shared-from=*", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 3: frozenmemoryanchor tokdecompose\n\n**Files changed:** calc.py", + "namespace": "agent-runtime:codex", + "tags": [ + "codex", + "task-result", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 3: frozenmemoryanchor tokdecompose\n\n**Files changed:** calc.py", + "namespace": "shared", + "tags": [ + "codex", + "shared-from=*", + "task-result", + "task:*" + ] + } + ], + "store": "store", + "subtasks": [ + "alpha part of the work frozenmemoryanchor tokdecompose", + "beta part of the work frozenmemoryanchor tokdecompose" + ], + "token": "tokdecompose" + }, + "failed": { + "prompt": "frozenmemoryanchor tokfailed fix add in calc.py", + "rows": [], + "store": "store", + "token": "tokfailed" + }, + "headings": { + "prompt": "frozenmemoryanchor tokheadings review calc.py", + "reply": "frozenmemoryanchor tokheadings summary line\n\n### Findings\n\nfrozenmemoryanchor tokheadings findings. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument.\n\n### Next steps\n\nfrozenmemoryanchor tokheadings steps. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero.", + "rows": [ + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokheadings review calc.py\n\n**Agent:** codex\n\n**Output:**\nfrozenmemoryanchor tokheadings summary line\n\n### Findings\n\nfrozenmemoryanchor tokheadings findings. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument.\n\n### Next steps\n\nfrozenmemoryanchor tokheadings steps. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero.", + "namespace": "agent-runtime:codex", + "tags": [ + "codex", + "task-result", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokheadings review calc.py\n\n**Agent:** codex\n\n**Output:**\nfrozenmemoryanchor tokheadings summary line\n\n### Findings\n\nfrozenmemoryanchor tokheadings findings. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument.\n\n### Next steps\n\nfrozenmemoryanchor tokheadings steps. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero.", + "namespace": "shared", + "tags": [ + "codex", + "shared-from=*", + "task-result", + "task:*" + ] + } + ], + "store": "store", + "token": "tokheadings" + }, + "longprompt": { + "private_chunks_per_entry": 2, + "prompt": "frozenmemoryanchor toklong fix add in calc.py.\n\nrequirement-000 keeps the sum of two integers exact\n\nrequirement-001 keeps the sum of two integers exact\n\nrequirement-002 keeps the sum of two integers exact\n\nrequirement-003 keeps the sum of two integers exact\n\nrequirement-004 keeps the sum of two integers exact\n\nrequirement-005 keeps the sum of two integers exact\n\nrequirement-006 keeps the sum of two integers exact\n\nrequirement-007 keeps the sum of two integers exact\n\nrequirement-008 keeps the sum of two integers exact\n\nrequirement-009 keeps the sum of two integers exact\n\nrequirement-010 keeps the sum of two integers exact\n\nrequirement-011 keeps the sum of two integers exact\n\nrequirement-012 keeps the sum of two integers exact\n\nrequirement-013 keeps the sum of two integers exact\n\nrequirement-014 keeps the sum of two integers exact\n\nrequirement-015 keeps the sum of two integers exact\n\nrequirement-016 keeps the sum of two integers exact\n\nrequirement-017 keeps the sum of two integers exact\n\nrequirement-018 keeps the sum of two integers exact\n\nrequirement-019 keeps the sum of two integers exact\n\nrequirement-020 keeps the sum of two integers exact\n\nrequirement-021 keeps the sum of two integers exact\n\nrequirement-022 keeps the sum of two integers exact\n\nrequirement-023 keeps the sum of two integers exact\n\nrequirement-024 keeps the sum of two integers exact\n\nrequirement-025 keeps the sum of two integers exact\n\nrequirement-026 keeps the sum of two integers exact\n\nrequirement-027 keeps the sum of two integers exact\n\nrequirement-028 keeps the sum of two integers exact\n\nrequirement-029 keeps the sum of two integers exact\n\nrequirement-030 keeps the sum of two integers exact\n\nrequirement-031 keeps the sum of two integers exact\n\nrequirement-032 keeps the sum of two integers exact\n\nrequirement-033 keeps the sum of two integers exact\n\nrequirement-034 keeps the sum of two integers exact\n\nrequirement-035 keeps the sum of two integers exact\n\nrequirement-036 keeps the sum of two integers exact\n\nrequirement-037 keeps the sum of two integers exact\n\nrequirement-038 keeps the sum of two integers exact\n\nrequirement-039 keeps the sum of two integers exact\n\nrequirement-040 keeps the sum of two integers exact\n\nrequirement-041 keeps the sum of two integers exact\n\nrequirement-042 keeps the sum of two integers exact\n\nrequirement-043 keeps the sum of two integers exact\n\nrequirement-044 keeps the sum of two integers exact\n\nrequirement-045 keeps the sum of two integers exact\n\nrequirement-046 keeps the sum of two integers exact\n\nrequirement-047 keeps the sum of two integers exact\n\nrequirement-048 keeps the sum of two integers exact\n\nrequirement-049 keeps the sum of two integers exact\n\nrequirement-050 keeps the sum of two integers exact\n\nrequirement-051 keeps the sum of two integers exact\n\nrequirement-052 keeps the sum of two integers exact\n\nrequirement-053 keeps the sum of two integers exact\n\nrequirement-054 keeps the sum of two integers exact\n\nrequirement-055 keeps the sum of two integers exact\n\nrequirement-056 keeps the sum of two integers exact\n\nrequirement-057 keeps the sum of two integers exact\n\nrequirement-058 keeps the sum of two integers exact\n\nrequirement-059 keeps the sum of two integers exact", + "rows": [ + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor toklong fix add in calc.py.\n\nrequirement-000 keeps the sum of two integers exact\n\nrequirement-001 keeps the sum of two integers exact\n\nrequirement-002 keeps the sum of two integers exact\n\nrequirement-003 keeps the sum of two integers exact\n\nrequirement-004 keeps the sum of two integers exact\n\nrequirement-005 keeps the sum of two integers exact\n\nrequirement-006 keeps the sum of two integers exact\n\nrequirement-007 keeps the sum of two integers exact\n\nrequirement-008 keeps the sum of two integers exact\n\nrequirement-009 keeps the sum of two integers exact\n\nrequirement-010 keeps the sum of two integers exact\n\nrequirement-011 keeps the sum of two integers exact\n\nrequirement-012 keeps the sum of two integers exact\n\nrequirement-013 keeps the sum of two integers exact\n\nrequirement-014 keeps the sum of two integers exact\n\nrequirement-015 keeps the sum of two integers exact\n\nrequirement-016 keeps the sum of two integers exact\n\nrequirement-017 keeps the sum of two integers exact\n\nrequirement-018 keeps the sum of two integers exact\n\nrequirement-019 keeps the sum of two integers exact\n\nrequirement-020 keeps the sum of two integers exact\n\nrequirement-021 keeps the sum of two integers exact\n\nrequirement-022 keeps the sum of two integers exact\n\nrequirement-023 keeps the sum of two integers exact\n\nrequirement-024 keeps the sum of two integers exact\n\nrequirement-025 keeps the sum of two integers exact\n\nrequirement-026 keeps the sum of two integers exact\n\nrequirement-027 keeps the sum of two integers exact\n\nrequirement-028 keeps the sum of two integers exact\n\nrequirement-029 keeps the sum of two integers exact\n\nrequirement-030 keeps the sum of two integers exact\n\nrequirement-031 keeps the sum of two integers exact\n\nrequirement-032 keeps the sum of two integers exact\n\nrequirement-033 keeps the sum of two integers exact\n\nrequirement-034 keeps the sum of two integers exact\n\nrequirement-035 keeps the sum of two integers exact\n\nrequirement-036 keeps the sum of two integers exact", + "namespace": "agent-runtime:codex", + "tags": [ + "codex", + "task-result", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor toklong fix add in calc.py.\n\nrequirement-000 keeps the sum of two integers exact\n\nrequirement-001 keeps the sum of two integers exact\n\nrequirement-002 keeps the sum of two integers exact\n\nrequirement-003 keeps the sum of two integers exact\n\nrequirement-004 keeps the sum of two integers exact\n\nrequirement-005 keeps the sum of two integers exact\n\nrequirement-006 keeps the sum of two integers exact\n\nrequirement-007 keeps the sum of two integers exact\n\nrequirement-008 keeps the sum of two integers exact\n\nrequirement-009 keeps the sum of two integers exact\n\nrequirement-010 keeps the sum of two integers exact\n\nrequirement-011 keeps the sum of two integers exact\n\nrequirement-012 keeps the sum of two integers exact\n\nrequirement-013 keeps the sum of two integers exact\n\nrequirement-014 keeps the sum of two integers exact\n\nrequirement-015 keeps the sum of two integers exact\n\nrequirement-016 keeps the sum of two integers exact\n\nrequirement-017 keeps the sum of two integers exact\n\nrequirement-018 keeps the sum of two integers exact\n\nrequirement-019 keeps the sum of two integers exact\n\nrequirement-020 keeps the sum of two integers exact\n\nrequirement-021 keeps the sum of two integers exact\n\nrequirement-022 keeps the sum of two integers exact\n\nrequirement-023 keeps the sum of two integers exact\n\nrequirement-024 keeps the sum of two integers exact\n\nrequirement-025 keeps the sum of two integers exact\n\nrequirement-026 keeps the sum of two integers exact\n\nrequirement-027 keeps the sum of two integers exact\n\nrequirement-028 keeps the sum of two integers exact\n\nrequirement-029 keeps the sum of two integers exact\n\nrequirement-030 keeps the sum of two integers exact\n\nrequirement-031 keeps the sum of two integers exact\n\nrequirement-032 keeps the sum of two integers exact\n\nrequirement-033 keeps the sum of two integers exact\n\nrequirement-034 keeps the sum of two integers exact\n\nrequirement-035 keeps the sum of two integers exact\n\nrequirement-036 keeps the sum of two integers exact", + "namespace": "shared", + "tags": [ + "codex", + "shared-from=*", + "task-result", + "task:*" + ] + }, + { + "body": "requirement-037 keeps the sum of two integers exact\n\nrequirement-038 keeps the sum of two integers exact\n\nrequirement-039 keeps the sum of two integers exact\n\nrequirement-040 keeps the sum of two integers exact\n\nrequirement-041 keeps the sum of two integers exact\n\nrequirement-042 keeps the sum of two integers exact\n\nrequirement-043 keeps the sum of two integers exact\n\nrequirement-044 keeps the sum of two integers exact\n\nrequirement-045 keeps the sum of two integers exact\n\nrequirement-046 keeps the sum of two integers exact\n\nrequirement-047 keeps the sum of two integers exact\n\nrequirement-048 keeps the sum of two integers exact\n\nrequirement-049 keeps the sum of two integers exact\n\nrequirement-050 keeps the sum of two integers exact\n\nrequirement-051 keeps the sum of two integers exact\n\nrequirement-052 keeps the sum of two integers exact\n\nrequirement-053 keeps the sum of two integers exact\n\nrequirement-054 keeps the sum of two integers exact\n\nrequirement-055 keeps the sum of two integers exact\n\nrequirement-056 keeps the sum of two integers exact\n\nrequirement-057 keeps the sum of two integers exact\n\nrequirement-058 keeps the sum of two integers exact\n\nrequirement-059 keeps the sum of two integers exact\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor toklong", + "namespace": "agent-runtime:codex", + "tags": [ + "codex", + "task-result", + "task:*" + ] + }, + { + "body": "requirement-037 keeps the sum of two integers exact\n\nrequirement-038 keeps the sum of two integers exact\n\nrequirement-039 keeps the sum of two integers exact\n\nrequirement-040 keeps the sum of two integers exact\n\nrequirement-041 keeps the sum of two integers exact\n\nrequirement-042 keeps the sum of two integers exact\n\nrequirement-043 keeps the sum of two integers exact\n\nrequirement-044 keeps the sum of two integers exact\n\nrequirement-045 keeps the sum of two integers exact\n\nrequirement-046 keeps the sum of two integers exact\n\nrequirement-047 keeps the sum of two integers exact\n\nrequirement-048 keeps the sum of two integers exact\n\nrequirement-049 keeps the sum of two integers exact\n\nrequirement-050 keeps the sum of two integers exact\n\nrequirement-051 keeps the sum of two integers exact\n\nrequirement-052 keeps the sum of two integers exact\n\nrequirement-053 keeps the sum of two integers exact\n\nrequirement-054 keeps the sum of two integers exact\n\nrequirement-055 keeps the sum of two integers exact\n\nrequirement-056 keeps the sum of two integers exact\n\nrequirement-057 keeps the sum of two integers exact\n\nrequirement-058 keeps the sum of two integers exact\n\nrequirement-059 keeps the sum of two integers exact\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor toklong", + "namespace": "shared", + "tags": [ + "codex", + "shared-from=*", + "task-result", + "task:*" + ] + } + ], + "store": "store", + "token": "toklong" + }, + "pipeline": { + "prompt": "frozenmemoryanchor tokpipeline fix add in calc.py", + "rows": [ + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokpipeline fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokpipeline", + "namespace": "agent-runtime:codex", + "tags": [ + "codex", + "pipeline-stage", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokpipeline fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokpipeline", + "namespace": "shared", + "tags": [ + "codex", + "pipeline-stage", + "shared-from=*", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokpipeline fix add in calc.py\n\n**Agent:** kimi-code\n\n**Output:**\nkimi (fake) call 1: frozenmemoryanchor tokpipeline\n\n**Files changed:** calc.py", + "namespace": "agent-runtime:kimi-code", + "tags": [ + "kimi-code", + "task-result", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokpipeline fix add in calc.py\n\n**Agent:** kimi-code\n\n**Output:**\nkimi (fake) call 1: frozenmemoryanchor tokpipeline\n\n**Files changed:** calc.py", + "namespace": "shared", + "tags": [ + "kimi-code", + "shared-from=*", + "task-result", + "task:*" + ] + } + ], + "store": "store", + "token": "tokpipeline" + }, + "room-apply": { + "prompt": "frozenmemoryanchor tokroom fix add in calc.py", + "room_id": "21f4ab73-05b7-4a71-bb56-d238bbc705f4", + "rows": [ + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokroom fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokroom\n\n**Files changed:** calc.py", + "namespace": "agent-runtime:codex", + "tags": [ + "codex", + "room-result", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokroom fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokroom\n\n**Files changed:** calc.py", + "namespace": "shared", + "tags": [ + "codex", + "room-result", + "shared-from=*", + "task:*" + ] + } + ], + "store": "store", + "token": "tokroom" + }, + "route": { + "prompt": "frozenmemoryanchor tokroute fix add in calc.py", + "rows": [ + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokroute fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokroute\n\n**Files changed:** calc.py", + "namespace": "agent-runtime:codex", + "tags": [ + "codex", + "task-result", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokroute fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokroute\n\n**Files changed:** calc.py", + "namespace": "shared", + "tags": [ + "codex", + "shared-from=*", + "task-result", + "task:*" + ] + } + ], + "store": "store", + "token": "tokroute" + }, + "unicode": { + "prompt": "frozenmemoryanchor tokunicode say something long", + "reply": " frozenmemoryanchor tokunicode 한글 본문 と日本語 🙂\r\nsecond line after CRLF\r\n가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 tail-after-the-cut ", + "rows": [ + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokunicode say something long\n\n**Agent:** codex\n\n**Output:**\nfrozenmemoryanchor tokunicode 한글 본문 と日本語 🙂\nsecond line after CRLF\n가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라", + "namespace": "agent-runtime:codex", + "tags": [ + "codex", + "task-result", + "task:*" + ] + }, + { + "body": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokunicode say something long\n\n**Agent:** codex\n\n**Output:**\nfrozenmemoryanchor tokunicode 한글 본문 と日本語 🙂\nsecond line after CRLF\n가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라", + "namespace": "shared", + "tags": [ + "codex", + "shared-from=*", + "task-result", + "task:*" + ] + } + ], + "store": "store", + "token": "tokunicode" + } + }, + "stores": { + "store": { + "board": "store/board.db", + "db": "store/mm.db", + "mem": "store/mem", + "root": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip/state/store" + } + } +} diff --git a/tests/fixtures/persisted/memory/v0.3.0/release-read.json b/tests/fixtures/persisted/memory/v0.3.0/release-read.json new file mode 100644 index 0000000..dd657d8 --- /dev/null +++ b/tests/fixtures/persisted/memory/v0.3.0/release-read.json @@ -0,0 +1,711 @@ +{ + "store": { + "count": { + "agent-runtime:codex": 15, + "agent-runtime:kimi-code": 5, + "board-run:5992afb8-d015-4009-81d1-aef11dd7c6ad": 1, + "board-run:dc18cb96-9616-48bf-9ea0-4f84469bd299": 1, + "shared": 21 + }, + "get": { + "0bbcfac6-49a5-4905-9535-0257ab1a71e6": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** kimi-code\n\n**Output:**\nkimi (fake) call 1: frozenmemoryanchor tokcouncil", + "id": "0bbcfac6-49a5-4905-9535-0257ab1a71e6", + "namespace": "shared", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip/state/store/mem/2026-11-15.shared.md", + "tags": [ + "council-proposal", + "kimi-code", + "shared-from=eb3f71e5-0967-4188-9fb9-294dd4cb7c37", + "task:63e73eb4-8851-45ac-86a4-e4d1dae7fd5b" + ] + }, + "0e20c913-8601-4e2c-bbc0-ef85b9e1bff0": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 2: frozenmemoryanchor tokdecompose", + "id": "0e20c913-8601-4e2c-bbc0-ef85b9e1bff0", + "namespace": "agent-runtime:codex", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip/state/store/mem/2026-11-15.agent-runtime.codex.md", + "tags": [ + "codex", + "decompose-subtask", + "task:60f4a050-14fb-4d07-993f-f6594cac1cff" + ] + }, + "0e8f432b-ed54-48b5-b6b1-eff426ed6294": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 2: frozenmemoryanchor tokcouncil", + "id": "0e8f432b-ed54-48b5-b6b1-eff426ed6294", + "namespace": "agent-runtime:codex", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip/state/store/mem/2026-11-15.agent-runtime.codex.md", + "tags": [ + "codex", + "council-critique", + "task:63e73eb4-8851-45ac-86a4-e4d1dae7fd5b" + ] + }, + "135cdc8b-ac33-4472-b5eb-cacc069ac8cd": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor toklong fix add in calc.py.\n\nrequirement-000 keeps the sum of two integers exact\n\nrequirement-001 keeps the sum of two integers exact\n\nrequirement-002 keeps the sum of two integers exact\n\nrequirement-003 keeps the sum of two integers exact\n\nrequirement-004 keeps the sum of two integers exact\n\nrequirement-005 keeps the sum of two integers exact\n\nrequirement-006 keeps the sum of two integers exact\n\nrequirement-007 keeps the sum of two integers exact\n\nrequirement-008 keeps the sum of two integers exact\n\nrequirement-009 keeps the sum of two integers exact\n\nrequirement-010 keeps the sum of two integers exact\n\nrequirement-011 keeps the sum of two integers exact\n\nrequirement-012 keeps the sum of two integers exact\n\nrequirement-013 keeps the sum of two integers exact\n\nrequirement-014 keeps the sum of two integers exact\n\nrequirement-015 keeps the sum of two integers exact\n\nrequirement-016 keeps the sum of two integers exact\n\nrequirement-017 keeps the sum of two integers exact\n\nrequirement-018 keeps the sum of two integers exact\n\nrequirement-019 keeps the sum of two integers exact\n\nrequirement-020 keeps the sum of two integers exact\n\nrequirement-021 keeps the sum of two integers exact\n\nrequirement-022 keeps the sum of two integers exact\n\nrequirement-023 keeps the sum of two integers exact\n\nrequirement-024 keeps the sum of two integers exact\n\nrequirement-025 keeps the sum of two integers exact\n\nrequirement-026 keeps the sum of two integers exact\n\nrequirement-027 keeps the sum of two integers exact\n\nrequirement-028 keeps the sum of two integers exact\n\nrequirement-029 keeps the sum of two integers exact\n\nrequirement-030 keeps the sum of two integers exact\n\nrequirement-031 keeps the sum of two integers exact\n\nrequirement-032 keeps the sum of two integers exact\n\nrequirement-033 keeps the sum of two integers exact\n\nrequirement-034 keeps the sum of two integers exact\n\nrequirement-035 keeps the sum of two integers exact\n\nrequirement-036 keeps the sum of two integers exact", + "id": "135cdc8b-ac33-4472-b5eb-cacc069ac8cd", + "namespace": "shared", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip/state/store/mem/2026-11-15.shared.md", + "tags": [ + "codex", + "shared-from=e6adcb55-4ca5-4ab9-a87a-da02598dc778", + "task-result", + "task:07319897-6d47-4e97-8c45-8ca464fc8f7b" + ] + }, + "14f30b30-3473-4a42-96da-5b297882aa32": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokpipeline fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokpipeline", + "id": "14f30b30-3473-4a42-96da-5b297882aa32", + "namespace": "shared", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip/state/store/mem/2026-11-15.shared.md", + "tags": [ + "codex", + "pipeline-stage", + "shared-from=9ecf4695-0642-4c0d-a56d-bf549df31146", + "task:fa54e714-2b40-4871-b201-1bd63aea633b" + ] + }, + "186206a9-c62a-4727-a5ce-86699bcf0ac1": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokroute fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokroute\n\n**Files changed:** calc.py", + "id": "186206a9-c62a-4727-a5ce-86699bcf0ac1", + "namespace": "agent-runtime:codex", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip/state/store/mem/2026-11-15.agent-runtime.codex.md", + "tags": [ + "codex", + "task-result", + "task:84f5d988-3bf7-4a6f-84d5-37df12876153" + ] + }, + "1b11e235-0888-4016-8fb4-8fab268c25f1": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 3: frozenmemoryanchor tokdecompose\n\n**Files changed:** calc.py", + "id": "1b11e235-0888-4016-8fb4-8fab268c25f1", + "namespace": "agent-runtime:codex", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip/state/store/mem/2026-11-15.agent-runtime.codex.md", + "tags": [ + "codex", + "task-result", + "task:60f4a050-14fb-4d07-993f-f6594cac1cff" + ] + }, + "26f0ee00-a4df-4331-9000-2fc701904528": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcompete fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokcompete\n\n**Files changed:** calc.py", + "id": "26f0ee00-a4df-4331-9000-2fc701904528", + "namespace": "shared", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip/state/store/mem/2026-11-15.shared.md", + "tags": [ + "codex", + "shared-from=d890c5b2-d19f-4ad3-8b2a-724422c5734d", + "task-result", + "task:48154546-ee89-44ab-92f0-936a5a9423e4" + ] + }, + "2ace998e-dba0-430e-b33a-3130512e0db8": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokunicode say something long\n\n**Agent:** codex\n\n**Output:**\nfrozenmemoryanchor tokunicode 한글 본문 と日本語 🙂\nsecond line after CRLF\n가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라", + "id": "2ace998e-dba0-430e-b33a-3130512e0db8", + "namespace": "shared", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip/state/store/mem/2026-11-15.shared.md", + "tags": [ + "codex", + "shared-from=9ffaa4d6-7951-4af9-ac74-f51065b00dfa", + "task-result", + "task:5852569e-a986-481e-a6ad-33553df3a114" + ] + }, + "2c3214a6-92f5-4ef6-b5bc-d565d8bd8053": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** kimi-code\n\n**Output:**\nkimi (fake) call 2: frozenmemoryanchor tokcouncil", + "id": "2c3214a6-92f5-4ef6-b5bc-d565d8bd8053", + "namespace": "shared", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip/state/store/mem/2026-11-15.shared.md", + "tags": [ + "council-critique", + "kimi-code", + "shared-from=6b7f291f-1844-4b7d-893f-329b5c4cc603", + "task:63e73eb4-8851-45ac-86a4-e4d1dae7fd5b" + ] + }, + "3b649fca-655d-4155-a939-5ad369e92ee4": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokpipeline fix add in calc.py\n\n**Agent:** kimi-code\n\n**Output:**\nkimi (fake) call 1: frozenmemoryanchor tokpipeline\n\n**Files changed:** calc.py", + "id": "3b649fca-655d-4155-a939-5ad369e92ee4", + "namespace": "shared", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip/state/store/mem/2026-11-15.shared.md", + "tags": [ + "kimi-code", + "shared-from=ddb5090d-3922-42f5-9792-efede3c63e60", + "task-result", + "task:fa54e714-2b40-4871-b201-1bd63aea633b" + ] + }, + "3f3be4a5-3f3d-42a7-9d17-eef3165ae597": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokheadings review calc.py\n\n**Agent:** codex\n\n**Output:**\nfrozenmemoryanchor tokheadings summary line\n\n### Findings\n\nfrozenmemoryanchor tokheadings findings. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument.\n\n### Next steps\n\nfrozenmemoryanchor tokheadings steps. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero.", + "id": "3f3be4a5-3f3d-42a7-9d17-eef3165ae597", + "namespace": "agent-runtime:codex", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip/state/store/mem/2026-11-15.agent-runtime.codex.md", + "tags": [ + "task:4dbd4741-e03e-49f2-b64b-c5fd010d23ae", + "task-result", + "codex" + ] + }, + "46bc6aee-cc5d-401d-a145-0c3b4e705110": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** kimi-code\n\n**Output:**\nkimi (fake) call 3: frozenmemoryanchor tokcouncil", + "id": "46bc6aee-cc5d-401d-a145-0c3b4e705110", + "namespace": "agent-runtime:kimi-code", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip/state/store/mem/2026-11-15.agent-runtime.kimi-code.md", + "tags": [ + "council-critique", + "kimi-code", + "task:63e73eb4-8851-45ac-86a4-e4d1dae7fd5b" + ] + }, + "46f33458-ee71-4a27-8b9b-fba9a1dcc873": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\n[\"alpha part of the work frozenmemoryanchor tokdecompose\", \"beta part of the work frozenmemoryanchor tokdecompose\"]", + "id": "46f33458-ee71-4a27-8b9b-fba9a1dcc873", + "namespace": "agent-runtime:codex", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip/state/store/mem/2026-11-15.agent-runtime.codex.md", + "tags": [ + "codex", + "decompose-plan", + "task:60f4a050-14fb-4d07-993f-f6594cac1cff" + ] + }, + "4d7ae35c-7a4a-448e-bb84-5d6454ea44aa": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 4: frozenmemoryanchor tokcouncil\n\n**Files changed:** calc.py", + "id": "4d7ae35c-7a4a-448e-bb84-5d6454ea44aa", + "namespace": "agent-runtime:codex", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip/state/store/mem/2026-11-15.agent-runtime.codex.md", + "tags": [ + "codex", + "task-result", + "task:63e73eb4-8851-45ac-86a4-e4d1dae7fd5b" + ] + }, + "557ee2e1-fc4c-4752-b8cc-f5cf32203cba": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py\n\n**Agent:** kimi-code\n\n**Output:**\nkimi (fake) call 1: frozenmemoryanchor tokdecompose", + "id": "557ee2e1-fc4c-4752-b8cc-f5cf32203cba", + "namespace": "shared", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip/state/store/mem/2026-11-15.shared.md", + "tags": [ + "decompose-subtask", + "kimi-code", + "shared-from=8d8a1bc6-315d-4350-9d43-349ee80f6c13", + "task:60f4a050-14fb-4d07-993f-f6594cac1cff" + ] + }, + "5654daed-a625-4c46-bebf-0dc8b6cbc132": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 3: frozenmemoryanchor tokcouncil", + "id": "5654daed-a625-4c46-bebf-0dc8b6cbc132", + "namespace": "agent-runtime:codex", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip/state/store/mem/2026-11-15.agent-runtime.codex.md", + "tags": [ + "codex", + "council-critique", + "task:63e73eb4-8851-45ac-86a4-e4d1dae7fd5b" + ] + }, + "5a870ff9-622a-44e9-96b9-0b66a94badc9": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 2: frozenmemoryanchor tokcouncil", + "id": "5a870ff9-622a-44e9-96b9-0b66a94badc9", + "namespace": "shared", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip/state/store/mem/2026-11-15.shared.md", + "tags": [ + "codex", + "council-critique", + "shared-from=0e8f432b-ed54-48b5-b6b1-eff426ed6294", + "task:63e73eb4-8851-45ac-86a4-e4d1dae7fd5b" + ] + }, + "6b7f291f-1844-4b7d-893f-329b5c4cc603": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** kimi-code\n\n**Output:**\nkimi (fake) call 2: frozenmemoryanchor tokcouncil", + "id": "6b7f291f-1844-4b7d-893f-329b5c4cc603", + "namespace": "agent-runtime:kimi-code", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip/state/store/mem/2026-11-15.agent-runtime.kimi-code.md", + "tags": [ + "council-critique", + "kimi-code", + "task:63e73eb4-8851-45ac-86a4-e4d1dae7fd5b" + ] + }, + "6dbd7746-73e2-4765-bb53-08ad7bf95a14": { + "content": "**Task Result**\n\n**Prompt:** You are working on a tracked work-board item.\nGoal: frozen\n\nTask: frozenmemoryanchor tokkilled fix add in calc.py\n\nWhen you finish, you MAY append ONE fenced block reporting the board update (every field optional):\n```syncmill-board\n{\"state\": \"review\", \"handoff\": \"\", \"outputs\": [\"\"], \"human_required\": false}\n```\nUse \"state\": \"blocked\" with a \"blocked_reason\" if you cannot proceed, or \"human_required\": true if a human must step in. Requesting \"done\" only takes effect if the work is independently verified (a passing quality gate or a human sign-off); otherwise it is recorded as \"review\".\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokkilled", + "id": "6dbd7746-73e2-4765-bb53-08ad7bf95a14", + "namespace": "board-run:dc18cb96-9616-48bf-9ea0-4f84469bd299", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip/state/store/mem/2026-11-15.board-run.dc18cb96-9616-48bf-9ea0-4f84469bd299.md", + "tags": [ + "codex", + "pipeline-stage", + "task:0b32376d-98cf-430d-a543-46fcf276e87f" + ] + }, + "6df51e42-076a-4c85-908e-5202e1c7c9c5": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokcouncil", + "id": "6df51e42-076a-4c85-908e-5202e1c7c9c5", + "namespace": "shared", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip/state/store/mem/2026-11-15.shared.md", + "tags": [ + "codex", + "council-proposal", + "shared-from=f8d4b001-c8c3-4f82-989e-c5a3d098d1a3", + "task:63e73eb4-8851-45ac-86a4-e4d1dae7fd5b" + ] + }, + "75a3dc66-e74d-4fcc-91dc-72e4ea7e6597": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 2: frozenmemoryanchor tokdecompose", + "id": "75a3dc66-e74d-4fcc-91dc-72e4ea7e6597", + "namespace": "shared", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip/state/store/mem/2026-11-15.shared.md", + "tags": [ + "codex", + "decompose-subtask", + "shared-from=0e20c913-8601-4e2c-bbc0-ef85b9e1bff0", + "task:60f4a050-14fb-4d07-993f-f6594cac1cff" + ] + }, + "82570bd9-c1fc-444f-acd6-7e045eb6d69f": { + "content": "**Board Item Result**\n\n**Item:** 899be792-3851-4e3c-8b17-6ab33ccd5a01\n\n**Task:** frozenmemoryanchor tokboard fix add in calc.py\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokboard", + "id": "82570bd9-c1fc-444f-acd6-7e045eb6d69f", + "namespace": "shared", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip/state/store/mem/2026-11-15.shared.md", + "tags": [ + "board-result:899be792-3851-4e3c-8b17-6ab33ccd5a01" + ] + }, + "89fa98dd-23cd-4a42-9450-e7a89a1d9308": { + "content": "requirement-037 keeps the sum of two integers exact\n\nrequirement-038 keeps the sum of two integers exact\n\nrequirement-039 keeps the sum of two integers exact\n\nrequirement-040 keeps the sum of two integers exact\n\nrequirement-041 keeps the sum of two integers exact\n\nrequirement-042 keeps the sum of two integers exact\n\nrequirement-043 keeps the sum of two integers exact\n\nrequirement-044 keeps the sum of two integers exact\n\nrequirement-045 keeps the sum of two integers exact\n\nrequirement-046 keeps the sum of two integers exact\n\nrequirement-047 keeps the sum of two integers exact\n\nrequirement-048 keeps the sum of two integers exact\n\nrequirement-049 keeps the sum of two integers exact\n\nrequirement-050 keeps the sum of two integers exact\n\nrequirement-051 keeps the sum of two integers exact\n\nrequirement-052 keeps the sum of two integers exact\n\nrequirement-053 keeps the sum of two integers exact\n\nrequirement-054 keeps the sum of two integers exact\n\nrequirement-055 keeps the sum of two integers exact\n\nrequirement-056 keeps the sum of two integers exact\n\nrequirement-057 keeps the sum of two integers exact\n\nrequirement-058 keeps the sum of two integers exact\n\nrequirement-059 keeps the sum of two integers exact\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor toklong", + "id": "89fa98dd-23cd-4a42-9450-e7a89a1d9308", + "namespace": "agent-runtime:codex", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip/state/store/mem/2026-11-15.agent-runtime.codex.md", + "tags": [ + "codex", + "task-result", + "task:07319897-6d47-4e97-8c45-8ca464fc8f7b" + ] + }, + "8c6f2d71-0bc3-48af-a70e-02c032b1b3d1": { + "content": "**Task Result**\n\n**Prompt:** You are working on a tracked work-board item.\nGoal: frozen\n\nTask: frozenmemoryanchor tokboard fix add in calc.py\n\nWhen you finish, you MAY append ONE fenced block reporting the board update (every field optional):\n```syncmill-board\n{\"state\": \"review\", \"handoff\": \"\", \"outputs\": [\"\"], \"human_required\": false}\n```\nUse \"state\": \"blocked\" with a \"blocked_reason\" if you cannot proceed, or \"human_required\": true if a human must step in. Requesting \"done\" only takes effect if the work is independently verified (a passing quality gate or a human sign-off); otherwise it is recorded as \"review\".\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokboard\n\n**Files changed:** calc.py", + "id": "8c6f2d71-0bc3-48af-a70e-02c032b1b3d1", + "namespace": "board-run:5992afb8-d015-4009-81d1-aef11dd7c6ad", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip/state/store/mem/2026-11-15.board-run.5992afb8-d015-4009-81d1-aef11dd7c6ad.md", + "tags": [ + "codex", + "task-result", + "task:afdebf58-9d5c-476a-bce6-05a5953f6429" + ] + }, + "8d8a1bc6-315d-4350-9d43-349ee80f6c13": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py\n\n**Agent:** kimi-code\n\n**Output:**\nkimi (fake) call 1: frozenmemoryanchor tokdecompose", + "id": "8d8a1bc6-315d-4350-9d43-349ee80f6c13", + "namespace": "agent-runtime:kimi-code", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip/state/store/mem/2026-11-15.agent-runtime.kimi-code.md", + "tags": [ + "decompose-subtask", + "kimi-code", + "task:60f4a050-14fb-4d07-993f-f6594cac1cff" + ] + }, + "8ec174b5-8e40-49a5-a41b-2cf6400274c3": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** kimi-code\n\n**Output:**\nkimi (fake) call 3: frozenmemoryanchor tokcouncil", + "id": "8ec174b5-8e40-49a5-a41b-2cf6400274c3", + "namespace": "shared", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip/state/store/mem/2026-11-15.shared.md", + "tags": [ + "council-critique", + "kimi-code", + "shared-from=46bc6aee-cc5d-401d-a145-0c3b4e705110", + "task:63e73eb4-8851-45ac-86a4-e4d1dae7fd5b" + ] + }, + "962a1ec0-a42f-40b0-b7b7-e361de2ac0d9": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokheadings review calc.py\n\n**Agent:** codex\n\n**Output:**\nfrozenmemoryanchor tokheadings summary line\n\n### Findings\n\nfrozenmemoryanchor tokheadings findings. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument.\n\n### Next steps\n\nfrozenmemoryanchor tokheadings steps. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero.", + "id": "962a1ec0-a42f-40b0-b7b7-e361de2ac0d9", + "namespace": "shared", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip/state/store/mem/2026-11-15.shared.md", + "tags": [ + "task:4dbd4741-e03e-49f2-b64b-c5fd010d23ae", + "codex", + "shared-from=3f3be4a5-3f3d-42a7-9d17-eef3165ae597", + "task-result" + ] + }, + "9ecf4695-0642-4c0d-a56d-bf549df31146": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokpipeline fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokpipeline", + "id": "9ecf4695-0642-4c0d-a56d-bf549df31146", + "namespace": "agent-runtime:codex", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip/state/store/mem/2026-11-15.agent-runtime.codex.md", + "tags": [ + "codex", + "pipeline-stage", + "task:fa54e714-2b40-4871-b201-1bd63aea633b" + ] + }, + "9f36a7aa-dc5d-4bd8-8ed7-67ccbfcafe9e": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokroom fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokroom\n\n**Files changed:** calc.py", + "id": "9f36a7aa-dc5d-4bd8-8ed7-67ccbfcafe9e", + "namespace": "shared", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip/state/store/mem/2026-11-15.shared.md", + "tags": [ + "codex", + "room-result", + "shared-from=f893fe02-4aab-46d6-8614-2a2899cb7826", + "task:b2e856ed-f192-46fe-b591-08e780cdd8c3" + ] + }, + "9ffaa4d6-7951-4af9-ac74-f51065b00dfa": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokunicode say something long\n\n**Agent:** codex\n\n**Output:**\nfrozenmemoryanchor tokunicode 한글 본문 と日本語 🙂\nsecond line after CRLF\n가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라", + "id": "9ffaa4d6-7951-4af9-ac74-f51065b00dfa", + "namespace": "agent-runtime:codex", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip/state/store/mem/2026-11-15.agent-runtime.codex.md", + "tags": [ + "codex", + "task-result", + "task:5852569e-a986-481e-a6ad-33553df3a114" + ] + }, + "a8840988-cfe0-4e70-83e0-2305eba6438e": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 3: frozenmemoryanchor tokcouncil", + "id": "a8840988-cfe0-4e70-83e0-2305eba6438e", + "namespace": "shared", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip/state/store/mem/2026-11-15.shared.md", + "tags": [ + "codex", + "council-critique", + "shared-from=5654daed-a625-4c46-bebf-0dc8b6cbc132", + "task:63e73eb4-8851-45ac-86a4-e4d1dae7fd5b" + ] + }, + "b42c6ce0-1342-4d22-8dad-7e16a7fc38ab": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\n[\"alpha part of the work frozenmemoryanchor tokdecompose\", \"beta part of the work frozenmemoryanchor tokdecompose\"]", + "id": "b42c6ce0-1342-4d22-8dad-7e16a7fc38ab", + "namespace": "shared", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip/state/store/mem/2026-11-15.shared.md", + "tags": [ + "codex", + "decompose-plan", + "shared-from=46f33458-ee71-4a27-8b9b-fba9a1dcc873", + "task:60f4a050-14fb-4d07-993f-f6594cac1cff" + ] + }, + "bb4d290f-8d5d-45c0-b074-a10ebfb38b81": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokroute fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokroute\n\n**Files changed:** calc.py", + "id": "bb4d290f-8d5d-45c0-b074-a10ebfb38b81", + "namespace": "shared", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip/state/store/mem/2026-11-15.shared.md", + "tags": [ + "codex", + "shared-from=186206a9-c62a-4727-a5ce-86699bcf0ac1", + "task-result", + "task:84f5d988-3bf7-4a6f-84d5-37df12876153" + ] + }, + "be41f47d-79ce-4cee-9679-9d2335830f4e": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 3: frozenmemoryanchor tokdecompose\n\n**Files changed:** calc.py", + "id": "be41f47d-79ce-4cee-9679-9d2335830f4e", + "namespace": "shared", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip/state/store/mem/2026-11-15.shared.md", + "tags": [ + "codex", + "shared-from=1b11e235-0888-4016-8fb4-8fab268c25f1", + "task-result", + "task:60f4a050-14fb-4d07-993f-f6594cac1cff" + ] + }, + "c400b6e7-c80f-4d4c-93c9-92967cfec7f6": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 4: frozenmemoryanchor tokcouncil\n\n**Files changed:** calc.py", + "id": "c400b6e7-c80f-4d4c-93c9-92967cfec7f6", + "namespace": "shared", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip/state/store/mem/2026-11-15.shared.md", + "tags": [ + "codex", + "shared-from=4d7ae35c-7a4a-448e-bb84-5d6454ea44aa", + "task-result", + "task:63e73eb4-8851-45ac-86a4-e4d1dae7fd5b" + ] + }, + "d890c5b2-d19f-4ad3-8b2a-724422c5734d": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcompete fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokcompete\n\n**Files changed:** calc.py", + "id": "d890c5b2-d19f-4ad3-8b2a-724422c5734d", + "namespace": "agent-runtime:codex", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip/state/store/mem/2026-11-15.agent-runtime.codex.md", + "tags": [ + "codex", + "task-result", + "task:48154546-ee89-44ab-92f0-936a5a9423e4" + ] + }, + "ddb5090d-3922-42f5-9792-efede3c63e60": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokpipeline fix add in calc.py\n\n**Agent:** kimi-code\n\n**Output:**\nkimi (fake) call 1: frozenmemoryanchor tokpipeline\n\n**Files changed:** calc.py", + "id": "ddb5090d-3922-42f5-9792-efede3c63e60", + "namespace": "agent-runtime:kimi-code", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip/state/store/mem/2026-11-15.agent-runtime.kimi-code.md", + "tags": [ + "kimi-code", + "task-result", + "task:fa54e714-2b40-4871-b201-1bd63aea633b" + ] + }, + "e2ca591c-cf62-490d-8527-aa6eb3e72ecc": { + "content": "requirement-037 keeps the sum of two integers exact\n\nrequirement-038 keeps the sum of two integers exact\n\nrequirement-039 keeps the sum of two integers exact\n\nrequirement-040 keeps the sum of two integers exact\n\nrequirement-041 keeps the sum of two integers exact\n\nrequirement-042 keeps the sum of two integers exact\n\nrequirement-043 keeps the sum of two integers exact\n\nrequirement-044 keeps the sum of two integers exact\n\nrequirement-045 keeps the sum of two integers exact\n\nrequirement-046 keeps the sum of two integers exact\n\nrequirement-047 keeps the sum of two integers exact\n\nrequirement-048 keeps the sum of two integers exact\n\nrequirement-049 keeps the sum of two integers exact\n\nrequirement-050 keeps the sum of two integers exact\n\nrequirement-051 keeps the sum of two integers exact\n\nrequirement-052 keeps the sum of two integers exact\n\nrequirement-053 keeps the sum of two integers exact\n\nrequirement-054 keeps the sum of two integers exact\n\nrequirement-055 keeps the sum of two integers exact\n\nrequirement-056 keeps the sum of two integers exact\n\nrequirement-057 keeps the sum of two integers exact\n\nrequirement-058 keeps the sum of two integers exact\n\nrequirement-059 keeps the sum of two integers exact\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor toklong", + "id": "e2ca591c-cf62-490d-8527-aa6eb3e72ecc", + "namespace": "shared", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip/state/store/mem/2026-11-15.shared.md", + "tags": [ + "codex", + "shared-from=89fa98dd-23cd-4a42-9450-e7a89a1d9308", + "task-result", + "task:07319897-6d47-4e97-8c45-8ca464fc8f7b" + ] + }, + "e6adcb55-4ca5-4ab9-a87a-da02598dc778": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor toklong fix add in calc.py.\n\nrequirement-000 keeps the sum of two integers exact\n\nrequirement-001 keeps the sum of two integers exact\n\nrequirement-002 keeps the sum of two integers exact\n\nrequirement-003 keeps the sum of two integers exact\n\nrequirement-004 keeps the sum of two integers exact\n\nrequirement-005 keeps the sum of two integers exact\n\nrequirement-006 keeps the sum of two integers exact\n\nrequirement-007 keeps the sum of two integers exact\n\nrequirement-008 keeps the sum of two integers exact\n\nrequirement-009 keeps the sum of two integers exact\n\nrequirement-010 keeps the sum of two integers exact\n\nrequirement-011 keeps the sum of two integers exact\n\nrequirement-012 keeps the sum of two integers exact\n\nrequirement-013 keeps the sum of two integers exact\n\nrequirement-014 keeps the sum of two integers exact\n\nrequirement-015 keeps the sum of two integers exact\n\nrequirement-016 keeps the sum of two integers exact\n\nrequirement-017 keeps the sum of two integers exact\n\nrequirement-018 keeps the sum of two integers exact\n\nrequirement-019 keeps the sum of two integers exact\n\nrequirement-020 keeps the sum of two integers exact\n\nrequirement-021 keeps the sum of two integers exact\n\nrequirement-022 keeps the sum of two integers exact\n\nrequirement-023 keeps the sum of two integers exact\n\nrequirement-024 keeps the sum of two integers exact\n\nrequirement-025 keeps the sum of two integers exact\n\nrequirement-026 keeps the sum of two integers exact\n\nrequirement-027 keeps the sum of two integers exact\n\nrequirement-028 keeps the sum of two integers exact\n\nrequirement-029 keeps the sum of two integers exact\n\nrequirement-030 keeps the sum of two integers exact\n\nrequirement-031 keeps the sum of two integers exact\n\nrequirement-032 keeps the sum of two integers exact\n\nrequirement-033 keeps the sum of two integers exact\n\nrequirement-034 keeps the sum of two integers exact\n\nrequirement-035 keeps the sum of two integers exact\n\nrequirement-036 keeps the sum of two integers exact", + "id": "e6adcb55-4ca5-4ab9-a87a-da02598dc778", + "namespace": "agent-runtime:codex", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip/state/store/mem/2026-11-15.agent-runtime.codex.md", + "tags": [ + "codex", + "task-result", + "task:07319897-6d47-4e97-8c45-8ca464fc8f7b" + ] + }, + "eb3f71e5-0967-4188-9fb9-294dd4cb7c37": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** kimi-code\n\n**Output:**\nkimi (fake) call 1: frozenmemoryanchor tokcouncil", + "id": "eb3f71e5-0967-4188-9fb9-294dd4cb7c37", + "namespace": "agent-runtime:kimi-code", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip/state/store/mem/2026-11-15.agent-runtime.kimi-code.md", + "tags": [ + "council-proposal", + "kimi-code", + "task:63e73eb4-8851-45ac-86a4-e4d1dae7fd5b" + ] + }, + "f893fe02-4aab-46d6-8614-2a2899cb7826": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokroom fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokroom\n\n**Files changed:** calc.py", + "id": "f893fe02-4aab-46d6-8614-2a2899cb7826", + "namespace": "agent-runtime:codex", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip/state/store/mem/2026-11-15.agent-runtime.codex.md", + "tags": [ + "codex", + "room-result", + "task:b2e856ed-f192-46fe-b591-08e780cdd8c3" + ] + }, + "f8d4b001-c8c3-4f82-989e-c5a3d098d1a3": { + "content": "**Task Result**\n\n**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py\n\n**Agent:** codex\n\n**Output:**\ncodex (fake) call 1: frozenmemoryanchor tokcouncil", + "id": "f8d4b001-c8c3-4f82-989e-c5a3d098d1a3", + "namespace": "agent-runtime:codex", + "scope": "user", + "source": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpb1vf_yip/state/store/mem/2026-11-15.agent-runtime.codex.md", + "tags": [ + "codex", + "council-proposal", + "task:63e73eb4-8851-45ac-86a4-e4d1dae7fd5b" + ] + } + }, + "search": { + "agent-runtime:codex": [ + "0e20c913-8601-4e2c-bbc0-ef85b9e1bff0", + "0e8f432b-ed54-48b5-b6b1-eff426ed6294", + "186206a9-c62a-4727-a5ce-86699bcf0ac1", + "1b11e235-0888-4016-8fb4-8fab268c25f1", + "3f3be4a5-3f3d-42a7-9d17-eef3165ae597", + "46f33458-ee71-4a27-8b9b-fba9a1dcc873", + "4d7ae35c-7a4a-448e-bb84-5d6454ea44aa", + "5654daed-a625-4c46-bebf-0dc8b6cbc132", + "89fa98dd-23cd-4a42-9450-e7a89a1d9308", + "9ecf4695-0642-4c0d-a56d-bf549df31146", + "9ffaa4d6-7951-4af9-ac74-f51065b00dfa", + "d890c5b2-d19f-4ad3-8b2a-724422c5734d", + "e6adcb55-4ca5-4ab9-a87a-da02598dc778", + "f893fe02-4aab-46d6-8614-2a2899cb7826", + "f8d4b001-c8c3-4f82-989e-c5a3d098d1a3" + ], + "agent-runtime:kimi-code": [ + "46bc6aee-cc5d-401d-a145-0c3b4e705110", + "6b7f291f-1844-4b7d-893f-329b5c4cc603", + "8d8a1bc6-315d-4350-9d43-349ee80f6c13", + "ddb5090d-3922-42f5-9792-efede3c63e60", + "eb3f71e5-0967-4188-9fb9-294dd4cb7c37" + ], + "board-run:5992afb8-d015-4009-81d1-aef11dd7c6ad": [ + "8c6f2d71-0bc3-48af-a70e-02c032b1b3d1" + ], + "board-run:dc18cb96-9616-48bf-9ea0-4f84469bd299": [ + "6dbd7746-73e2-4765-bb53-08ad7bf95a14" + ], + "shared": [ + "0bbcfac6-49a5-4905-9535-0257ab1a71e6", + "135cdc8b-ac33-4472-b5eb-cacc069ac8cd", + "14f30b30-3473-4a42-96da-5b297882aa32", + "26f0ee00-a4df-4331-9000-2fc701904528", + "2ace998e-dba0-430e-b33a-3130512e0db8", + "2c3214a6-92f5-4ef6-b5bc-d565d8bd8053", + "3b649fca-655d-4155-a939-5ad369e92ee4", + "557ee2e1-fc4c-4752-b8cc-f5cf32203cba", + "5a870ff9-622a-44e9-96b9-0b66a94badc9", + "6df51e42-076a-4c85-908e-5202e1c7c9c5", + "75a3dc66-e74d-4fcc-91dc-72e4ea7e6597", + "82570bd9-c1fc-444f-acd6-7e045eb6d69f", + "8ec174b5-8e40-49a5-a41b-2cf6400274c3", + "962a1ec0-a42f-40b0-b7b7-e361de2ac0d9", + "9f36a7aa-dc5d-4bd8-8ed7-67ccbfcafe9e", + "a8840988-cfe0-4e70-83e0-2305eba6438e", + "b42c6ce0-1342-4d22-8dad-7e16a7fc38ab", + "bb4d290f-8d5d-45c0-b074-a10ebfb38b81", + "be41f47d-79ce-4cee-9679-9d2335830f4e", + "c400b6e7-c80f-4d4c-93c9-92967cfec7f6", + "e2ca591c-cf62-490d-8527-aa6eb3e72ecc" + ] + }, + "search_by_kind": { + "agent-runtime:codex": { + "council-critique": [ + "0e8f432b-ed54-48b5-b6b1-eff426ed6294", + "5654daed-a625-4c46-bebf-0dc8b6cbc132" + ], + "council-proposal": [ + "f8d4b001-c8c3-4f82-989e-c5a3d098d1a3" + ], + "decompose-plan": [ + "46f33458-ee71-4a27-8b9b-fba9a1dcc873" + ], + "decompose-subtask": [ + "0e20c913-8601-4e2c-bbc0-ef85b9e1bff0" + ], + "pipeline-stage": [ + "9ecf4695-0642-4c0d-a56d-bf549df31146" + ], + "room-result": [ + "f893fe02-4aab-46d6-8614-2a2899cb7826" + ], + "task-result": [ + "186206a9-c62a-4727-a5ce-86699bcf0ac1", + "1b11e235-0888-4016-8fb4-8fab268c25f1", + "3f3be4a5-3f3d-42a7-9d17-eef3165ae597", + "4d7ae35c-7a4a-448e-bb84-5d6454ea44aa", + "89fa98dd-23cd-4a42-9450-e7a89a1d9308", + "9ffaa4d6-7951-4af9-ac74-f51065b00dfa", + "d890c5b2-d19f-4ad3-8b2a-724422c5734d", + "e6adcb55-4ca5-4ab9-a87a-da02598dc778" + ] + }, + "agent-runtime:kimi-code": { + "council-critique": [ + "46bc6aee-cc5d-401d-a145-0c3b4e705110", + "6b7f291f-1844-4b7d-893f-329b5c4cc603" + ], + "council-proposal": [ + "eb3f71e5-0967-4188-9fb9-294dd4cb7c37" + ], + "decompose-plan": [], + "decompose-subtask": [ + "8d8a1bc6-315d-4350-9d43-349ee80f6c13" + ], + "pipeline-stage": [], + "room-result": [], + "task-result": [ + "ddb5090d-3922-42f5-9792-efede3c63e60" + ] + }, + "board-run:5992afb8-d015-4009-81d1-aef11dd7c6ad": { + "council-critique": [], + "council-proposal": [], + "decompose-plan": [], + "decompose-subtask": [], + "pipeline-stage": [], + "room-result": [], + "task-result": [ + "8c6f2d71-0bc3-48af-a70e-02c032b1b3d1" + ] + }, + "board-run:dc18cb96-9616-48bf-9ea0-4f84469bd299": { + "council-critique": [], + "council-proposal": [], + "decompose-plan": [], + "decompose-subtask": [], + "pipeline-stage": [ + "6dbd7746-73e2-4765-bb53-08ad7bf95a14" + ], + "room-result": [], + "task-result": [] + }, + "shared": { + "council-critique": [ + "2c3214a6-92f5-4ef6-b5bc-d565d8bd8053", + "5a870ff9-622a-44e9-96b9-0b66a94badc9", + "8ec174b5-8e40-49a5-a41b-2cf6400274c3", + "a8840988-cfe0-4e70-83e0-2305eba6438e" + ], + "council-proposal": [ + "0bbcfac6-49a5-4905-9535-0257ab1a71e6", + "6df51e42-076a-4c85-908e-5202e1c7c9c5" + ], + "decompose-plan": [ + "b42c6ce0-1342-4d22-8dad-7e16a7fc38ab" + ], + "decompose-subtask": [ + "557ee2e1-fc4c-4752-b8cc-f5cf32203cba", + "75a3dc66-e74d-4fcc-91dc-72e4ea7e6597" + ], + "pipeline-stage": [ + "14f30b30-3473-4a42-96da-5b297882aa32" + ], + "room-result": [ + "9f36a7aa-dc5d-4bd8-8ed7-67ccbfcafe9e" + ], + "task-result": [ + "135cdc8b-ac33-4472-b5eb-cacc069ac8cd", + "26f0ee00-a4df-4331-9000-2fc701904528", + "2ace998e-dba0-430e-b33a-3130512e0db8", + "3b649fca-655d-4155-a939-5ad369e92ee4", + "962a1ec0-a42f-40b0-b7b7-e361de2ac0d9", + "bb4d290f-8d5d-45c0-b074-a10ebfb38b81", + "be41f47d-79ce-4cee-9679-9d2335830f4e", + "c400b6e7-c80f-4d4c-93c9-92967cfec7f6", + "e2ca591c-cf62-490d-8527-aa6eb3e72ecc" + ] + } + } + } +} diff --git a/tests/fixtures/persisted/memory/v0.3.0/store/board.db b/tests/fixtures/persisted/memory/v0.3.0/store/board.db new file mode 100644 index 0000000..8017cf5 Binary files /dev/null and b/tests/fixtures/persisted/memory/v0.3.0/store/board.db differ diff --git a/tests/fixtures/persisted/memory/v0.3.0/store/board.db-shm b/tests/fixtures/persisted/memory/v0.3.0/store/board.db-shm new file mode 100644 index 0000000..98cc025 Binary files /dev/null and b/tests/fixtures/persisted/memory/v0.3.0/store/board.db-shm differ diff --git a/tests/fixtures/persisted/memory/v0.3.0/store/board.db-wal b/tests/fixtures/persisted/memory/v0.3.0/store/board.db-wal new file mode 100644 index 0000000..f165434 Binary files /dev/null and b/tests/fixtures/persisted/memory/v0.3.0/store/board.db-wal differ diff --git a/tests/fixtures/persisted/memory/v0.3.0/store/board.db.gc-lock b/tests/fixtures/persisted/memory/v0.3.0/store/board.db.gc-lock new file mode 100644 index 0000000..e69de29 diff --git a/tests/fixtures/persisted/memory/v0.3.0/store/mem/.2026-11-15.agent-runtime.codex.md.lock b/tests/fixtures/persisted/memory/v0.3.0/store/mem/.2026-11-15.agent-runtime.codex.md.lock new file mode 100644 index 0000000..e69de29 diff --git a/tests/fixtures/persisted/memory/v0.3.0/store/mem/.2026-11-15.agent-runtime.kimi-code.md.lock b/tests/fixtures/persisted/memory/v0.3.0/store/mem/.2026-11-15.agent-runtime.kimi-code.md.lock new file mode 100644 index 0000000..e69de29 diff --git a/tests/fixtures/persisted/memory/v0.3.0/store/mem/.2026-11-15.board-run.5992afb8-d015-4009-81d1-aef11dd7c6ad.md.lock b/tests/fixtures/persisted/memory/v0.3.0/store/mem/.2026-11-15.board-run.5992afb8-d015-4009-81d1-aef11dd7c6ad.md.lock new file mode 100644 index 0000000..e69de29 diff --git a/tests/fixtures/persisted/memory/v0.3.0/store/mem/.2026-11-15.board-run.dc18cb96-9616-48bf-9ea0-4f84469bd299.md.lock b/tests/fixtures/persisted/memory/v0.3.0/store/mem/.2026-11-15.board-run.dc18cb96-9616-48bf-9ea0-4f84469bd299.md.lock new file mode 100644 index 0000000..e69de29 diff --git a/tests/fixtures/persisted/memory/v0.3.0/store/mem/.2026-11-15.shared.md.lock b/tests/fixtures/persisted/memory/v0.3.0/store/mem/.2026-11-15.shared.md.lock new file mode 100644 index 0000000..e69de29 diff --git a/tests/fixtures/persisted/memory/v0.3.0/store/mem/.syncmill-ns-1d1fc06506367405ccdc7f3235e15883.lock b/tests/fixtures/persisted/memory/v0.3.0/store/mem/.syncmill-ns-1d1fc06506367405ccdc7f3235e15883.lock new file mode 100644 index 0000000..e69de29 diff --git a/tests/fixtures/persisted/memory/v0.3.0/store/mem/.syncmill-ns-930b7a5b82485ec440b00843470a38d7.lock b/tests/fixtures/persisted/memory/v0.3.0/store/mem/.syncmill-ns-930b7a5b82485ec440b00843470a38d7.lock new file mode 100644 index 0000000..e69de29 diff --git a/tests/fixtures/persisted/memory/v0.3.0/store/mem/.syncmill-ns-b89560d04c6de3d5e39180999e9e40df.lock b/tests/fixtures/persisted/memory/v0.3.0/store/mem/.syncmill-ns-b89560d04c6de3d5e39180999e9e40df.lock new file mode 100644 index 0000000..e69de29 diff --git a/tests/fixtures/persisted/memory/v0.3.0/store/mem/.syncmill-ns-d2ac05253a75eddb34b7a5df8e6286ae.lock b/tests/fixtures/persisted/memory/v0.3.0/store/mem/.syncmill-ns-d2ac05253a75eddb34b7a5df8e6286ae.lock new file mode 100644 index 0000000..e69de29 diff --git a/tests/fixtures/persisted/memory/v0.3.0/store/mem/.syncmill-ns-dc3afa44d4409b79e5a2a1df89a4b3e5.lock b/tests/fixtures/persisted/memory/v0.3.0/store/mem/.syncmill-ns-dc3afa44d4409b79e5a2a1df89a4b3e5.lock new file mode 100644 index 0000000..e69de29 diff --git a/tests/fixtures/persisted/memory/v0.3.0/store/mem/2026-11-15.agent-runtime.codex.md b/tests/fixtures/persisted/memory/v0.3.0/store/mem/2026-11-15.agent-runtime.codex.md new file mode 100644 index 0000000..a252d34 --- /dev/null +++ b/tests/fixtures/persisted/memory/v0.3.0/store/mem/2026-11-15.agent-runtime.codex.md @@ -0,0 +1,340 @@ + +## Entry 2026-11-15T12:03:02.785+00:00 c1a7598729b94c1a951715e667a71741 + +> created: 2026-11-15T12:03:02+00:00 +> tags: ["task-result", "codex", "task:84f5d988-3bf7-4a6f-84d5-37df12876153"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokroute fix add in calc.py + +**Agent:** codex + +**Output:** +codex (fake) call 1: frozenmemoryanchor tokroute + +**Files changed:** calc.py + +## Entry 2026-11-15T12:03:03.367+00:00 441ef924432a480995203a49756b8749 + +> created: 2026-11-15T12:03:03+00:00 +> tags: ["pipeline-stage", "codex", "task:fa54e714-2b40-4871-b201-1bd63aea633b"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokpipeline fix add in calc.py + +**Agent:** codex + +**Output:** +codex (fake) call 1: frozenmemoryanchor tokpipeline + +## Entry 2026-11-15T12:03:04.096+00:00 892f9c3e4614489ba5465a89e34b7b7d + +> created: 2026-11-15T12:03:04+00:00 +> tags: ["task-result", "codex", "task:48154546-ee89-44ab-92f0-936a5a9423e4"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokcompete fix add in calc.py + +**Agent:** codex + +**Output:** +codex (fake) call 1: frozenmemoryanchor tokcompete + +**Files changed:** calc.py + +## Entry 2026-11-15T12:03:04.670+00:00 3ea5b69dc3034da0a31ee5b515391453 + +> created: 2026-11-15T12:03:04+00:00 +> tags: ["council-proposal", "codex", "task:63e73eb4-8851-45ac-86a4-e4d1dae7fd5b"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py + +**Agent:** codex + +**Output:** +codex (fake) call 1: frozenmemoryanchor tokcouncil + +## Entry 2026-11-15T12:03:04.701+00:00 ea810aa872a74c5ba94aa4d8f93833d2 + +> created: 2026-11-15T12:03:04+00:00 +> tags: ["council-critique", "codex", "task:63e73eb4-8851-45ac-86a4-e4d1dae7fd5b"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py + +**Agent:** codex + +**Output:** +codex (fake) call 2: frozenmemoryanchor tokcouncil + +## Entry 2026-11-15T12:03:04.731+00:00 2d3b7378e5e14cb88b6b510015cd6325 + +> created: 2026-11-15T12:03:04+00:00 +> tags: ["council-critique", "codex", "task:63e73eb4-8851-45ac-86a4-e4d1dae7fd5b"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py + +**Agent:** codex + +**Output:** +codex (fake) call 3: frozenmemoryanchor tokcouncil + +## Entry 2026-11-15T12:03:04.797+00:00 dccdc458be384c9dba312f2f56f1d5a3 + +> created: 2026-11-15T12:03:04+00:00 +> tags: ["task-result", "codex", "task:63e73eb4-8851-45ac-86a4-e4d1dae7fd5b"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py + +**Agent:** codex + +**Output:** +codex (fake) call 4: frozenmemoryanchor tokcouncil + +**Files changed:** calc.py + +## Entry 2026-11-15T12:03:05.370+00:00 8374d0208f7949858f030b3151403055 + +> created: 2026-11-15T12:03:05+00:00 +> tags: ["decompose-plan", "codex", "task:60f4a050-14fb-4d07-993f-f6594cac1cff"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py + +**Agent:** codex + +**Output:** +["alpha part of the work frozenmemoryanchor tokdecompose", "beta part of the work frozenmemoryanchor tokdecompose"] + +## Entry 2026-11-15T12:03:05.442+00:00 6134ae5a46174a7aa874fe266bbdf9b0 + +> created: 2026-11-15T12:03:05+00:00 +> tags: ["decompose-subtask", "codex", "task:60f4a050-14fb-4d07-993f-f6594cac1cff"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py + +**Agent:** codex + +**Output:** +codex (fake) call 2: frozenmemoryanchor tokdecompose + +## Entry 2026-11-15T12:03:05.561+00:00 1adaf5c5513741d2a7aa561c3ae89816 + +> created: 2026-11-15T12:03:05+00:00 +> tags: ["task-result", "codex", "task:60f4a050-14fb-4d07-993f-f6594cac1cff"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py + +**Agent:** codex + +**Output:** +codex (fake) call 3: frozenmemoryanchor tokdecompose + +**Files changed:** calc.py + +## Entry 2026-11-15T12:03:06.146+00:00 30f320184f8e429db9f32895d4151404 + +> created: 2026-11-15T12:03:06+00:00 +> tags: ["task-result", "codex", "task:5852569e-a986-481e-a6ad-33553df3a114"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokunicode say something long + +**Agent:** codex + +**Output:** +frozenmemoryanchor tokunicode 한글 본문 と日本語 🙂 +second line after CRLF +가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라 + +## Entry 2026-11-15T12:03:06.757+00:00 06db4cf60aed461fbd6ddac26926e818 + +> created: 2026-11-15T12:03:06+00:00 +> tags: ["task-result", "codex", "task:4dbd4741-e03e-49f2-b64b-c5fd010d23ae"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokheadings review calc.py + +**Agent:** codex + +**Output:** +frozenmemoryanchor tokheadings summary line + +### Findings +> tags: ["task-result", "codex", "task:4dbd4741-e03e-49f2-b64b-c5fd010d23ae"] + + +frozenmemoryanchor tokheadings findings. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. + +### Next steps +> tags: ["task-result", "codex", "task:4dbd4741-e03e-49f2-b64b-c5fd010d23ae"] + + +frozenmemoryanchor tokheadings steps. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. + +## Entry 2026-11-15T12:03:07.355+00:00 d13752e20b214bb9a6d6f508a95fac29 + +> created: 2026-11-15T12:03:07+00:00 +> tags: ["task-result", "codex", "task:07319897-6d47-4e97-8c45-8ca464fc8f7b"] + +**Task Result** + +**Prompt:** frozenmemoryanchor toklong fix add in calc.py. + +requirement-000 keeps the sum of two integers exact + +requirement-001 keeps the sum of two integers exact + +requirement-002 keeps the sum of two integers exact + +requirement-003 keeps the sum of two integers exact + +requirement-004 keeps the sum of two integers exact + +requirement-005 keeps the sum of two integers exact + +requirement-006 keeps the sum of two integers exact + +requirement-007 keeps the sum of two integers exact + +requirement-008 keeps the sum of two integers exact + +requirement-009 keeps the sum of two integers exact + +requirement-010 keeps the sum of two integers exact + +requirement-011 keeps the sum of two integers exact + +requirement-012 keeps the sum of two integers exact + +requirement-013 keeps the sum of two integers exact + +requirement-014 keeps the sum of two integers exact + +requirement-015 keeps the sum of two integers exact + +requirement-016 keeps the sum of two integers exact + +requirement-017 keeps the sum of two integers exact + +requirement-018 keeps the sum of two integers exact + +requirement-019 keeps the sum of two integers exact + +requirement-020 keeps the sum of two integers exact + +requirement-021 keeps the sum of two integers exact + +requirement-022 keeps the sum of two integers exact + +requirement-023 keeps the sum of two integers exact + +requirement-024 keeps the sum of two integers exact + +requirement-025 keeps the sum of two integers exact + +requirement-026 keeps the sum of two integers exact + +requirement-027 keeps the sum of two integers exact + +requirement-028 keeps the sum of two integers exact + +requirement-029 keeps the sum of two integers exact + +requirement-030 keeps the sum of two integers exact + +requirement-031 keeps the sum of two integers exact + +requirement-032 keeps the sum of two integers exact + +requirement-033 keeps the sum of two integers exact + +requirement-034 keeps the sum of two integers exact + +requirement-035 keeps the sum of two integers exact + +requirement-036 keeps the sum of two integers exact + +requirement-037 keeps the sum of two integers exact + +requirement-038 keeps the sum of two integers exact + +requirement-039 keeps the sum of two integers exact + +requirement-040 keeps the sum of two integers exact + +requirement-041 keeps the sum of two integers exact + +requirement-042 keeps the sum of two integers exact + +requirement-043 keeps the sum of two integers exact + +requirement-044 keeps the sum of two integers exact + +requirement-045 keeps the sum of two integers exact + +requirement-046 keeps the sum of two integers exact + +requirement-047 keeps the sum of two integers exact + +requirement-048 keeps the sum of two integers exact + +requirement-049 keeps the sum of two integers exact + +requirement-050 keeps the sum of two integers exact + +requirement-051 keeps the sum of two integers exact + +requirement-052 keeps the sum of two integers exact + +requirement-053 keeps the sum of two integers exact + +requirement-054 keeps the sum of two integers exact + +requirement-055 keeps the sum of two integers exact + +requirement-056 keeps the sum of two integers exact + +requirement-057 keeps the sum of two integers exact + +requirement-058 keeps the sum of two integers exact + +requirement-059 keeps the sum of two integers exact + +**Agent:** codex + +**Output:** +codex (fake) call 1: frozenmemoryanchor toklong + +## Entry 2026-11-15T12:03:10.243+00:00 bd789fdda9fe43f886345ba6b09a7f68 + +> created: 2026-11-15T12:03:10+00:00 +> tags: ["room-result", "codex", "task:b2e856ed-f192-46fe-b591-08e780cdd8c3"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokroom fix add in calc.py + +**Agent:** codex + +**Output:** +codex (fake) call 1: frozenmemoryanchor tokroom + +**Files changed:** calc.py diff --git a/tests/fixtures/persisted/memory/v0.3.0/store/mem/2026-11-15.agent-runtime.kimi-code.md b/tests/fixtures/persisted/memory/v0.3.0/store/mem/2026-11-15.agent-runtime.kimi-code.md new file mode 100644 index 0000000..d88198e --- /dev/null +++ b/tests/fixtures/persisted/memory/v0.3.0/store/mem/2026-11-15.agent-runtime.kimi-code.md @@ -0,0 +1,72 @@ + +## Entry 2026-11-15T12:03:03.497+00:00 9349d85098fa47dfb57948266f6ba351 + +> created: 2026-11-15T12:03:03+00:00 +> tags: ["task-result", "kimi-code", "task:fa54e714-2b40-4871-b201-1bd63aea633b"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokpipeline fix add in calc.py + +**Agent:** kimi-code + +**Output:** +kimi (fake) call 1: frozenmemoryanchor tokpipeline + +**Files changed:** calc.py + +## Entry 2026-11-15T12:03:04.676+00:00 44995d3cc40d4ae498f7306d455fa66e + +> created: 2026-11-15T12:03:04+00:00 +> tags: ["council-proposal", "kimi-code", "task:63e73eb4-8851-45ac-86a4-e4d1dae7fd5b"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py + +**Agent:** kimi-code + +**Output:** +kimi (fake) call 1: frozenmemoryanchor tokcouncil + +## Entry 2026-11-15T12:03:04.706+00:00 5f12595e42cc49b5a39a475da3cca55e + +> created: 2026-11-15T12:03:04+00:00 +> tags: ["council-critique", "kimi-code", "task:63e73eb4-8851-45ac-86a4-e4d1dae7fd5b"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py + +**Agent:** kimi-code + +**Output:** +kimi (fake) call 2: frozenmemoryanchor tokcouncil + +## Entry 2026-11-15T12:03:04.736+00:00 d874f7f53e3e43d09f7389c6555a3bbc + +> created: 2026-11-15T12:03:04+00:00 +> tags: ["council-critique", "kimi-code", "task:63e73eb4-8851-45ac-86a4-e4d1dae7fd5b"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py + +**Agent:** kimi-code + +**Output:** +kimi (fake) call 3: frozenmemoryanchor tokcouncil + +## Entry 2026-11-15T12:03:05.447+00:00 000e3d01a2f84c95a72bc94187ad629c + +> created: 2026-11-15T12:03:05+00:00 +> tags: ["decompose-subtask", "kimi-code", "task:60f4a050-14fb-4d07-993f-f6594cac1cff"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py + +**Agent:** kimi-code + +**Output:** +kimi (fake) call 1: frozenmemoryanchor tokdecompose diff --git a/tests/fixtures/persisted/memory/v0.3.0/store/mem/2026-11-15.board-run.5992afb8-d015-4009-81d1-aef11dd7c6ad.md b/tests/fixtures/persisted/memory/v0.3.0/store/mem/2026-11-15.board-run.5992afb8-d015-4009-81d1-aef11dd7c6ad.md new file mode 100644 index 0000000..5fe9b14 --- /dev/null +++ b/tests/fixtures/persisted/memory/v0.3.0/store/mem/2026-11-15.board-run.5992afb8-d015-4009-81d1-aef11dd7c6ad.md @@ -0,0 +1,25 @@ + +## Entry 2026-11-15T12:03:08.715+00:00 4b925248c3a94976a969fb5c01444f6a + +> created: 2026-11-15T12:03:08+00:00 +> tags: ["task-result", "codex", "task:afdebf58-9d5c-476a-bce6-05a5953f6429"] + +**Task Result** + +**Prompt:** You are working on a tracked work-board item. +Goal: frozen + +Task: frozenmemoryanchor tokboard fix add in calc.py + +When you finish, you MAY append ONE fenced block reporting the board update (every field optional): +```syncmill-board +{"state": "review", "handoff": "", "outputs": [""], "human_required": false} +``` +Use "state": "blocked" with a "blocked_reason" if you cannot proceed, or "human_required": true if a human must step in. Requesting "done" only takes effect if the work is independently verified (a passing quality gate or a human sign-off); otherwise it is recorded as "review". + +**Agent:** codex + +**Output:** +codex (fake) call 1: frozenmemoryanchor tokboard + +**Files changed:** calc.py diff --git a/tests/fixtures/persisted/memory/v0.3.0/store/mem/2026-11-15.board-run.dc18cb96-9616-48bf-9ea0-4f84469bd299.md b/tests/fixtures/persisted/memory/v0.3.0/store/mem/2026-11-15.board-run.dc18cb96-9616-48bf-9ea0-4f84469bd299.md new file mode 100644 index 0000000..7485798 --- /dev/null +++ b/tests/fixtures/persisted/memory/v0.3.0/store/mem/2026-11-15.board-run.dc18cb96-9616-48bf-9ea0-4f84469bd299.md @@ -0,0 +1,23 @@ + +## Entry 2026-11-15T12:03:11.023+00:00 2111a19862554080bcdeed16a9e7fbdf + +> created: 2026-11-15T12:03:11+00:00 +> tags: ["pipeline-stage", "codex", "task:0b32376d-98cf-430d-a543-46fcf276e87f"] + +**Task Result** + +**Prompt:** You are working on a tracked work-board item. +Goal: frozen + +Task: frozenmemoryanchor tokkilled fix add in calc.py + +When you finish, you MAY append ONE fenced block reporting the board update (every field optional): +```syncmill-board +{"state": "review", "handoff": "", "outputs": [""], "human_required": false} +``` +Use "state": "blocked" with a "blocked_reason" if you cannot proceed, or "human_required": true if a human must step in. Requesting "done" only takes effect if the work is independently verified (a passing quality gate or a human sign-off); otherwise it is recorded as "review". + +**Agent:** codex + +**Output:** +codex (fake) call 1: frozenmemoryanchor tokkilled diff --git a/tests/fixtures/persisted/memory/v0.3.0/store/mem/2026-11-15.shared.md b/tests/fixtures/persisted/memory/v0.3.0/store/mem/2026-11-15.shared.md new file mode 100644 index 0000000..217c021 --- /dev/null +++ b/tests/fixtures/persisted/memory/v0.3.0/store/mem/2026-11-15.shared.md @@ -0,0 +1,431 @@ + +## Entry 2026-11-15T12:03:02.789+00:00 a30facef36294e878fac04c8bb6afc0e + +> created: 2026-11-15T12:03:02+00:00 +> tags: ["codex", "task-result", "task:84f5d988-3bf7-4a6f-84d5-37df12876153", "shared-from=186206a9-c62a-4727-a5ce-86699bcf0ac1"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokroute fix add in calc.py + +**Agent:** codex + +**Output:** +codex (fake) call 1: frozenmemoryanchor tokroute + +**Files changed:** calc.py + +## Entry 2026-11-15T12:03:03.370+00:00 61ba9acccc7444bda2fa142454bd4892 + +> created: 2026-11-15T12:03:03+00:00 +> tags: ["codex", "pipeline-stage", "task:fa54e714-2b40-4871-b201-1bd63aea633b", "shared-from=9ecf4695-0642-4c0d-a56d-bf549df31146"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokpipeline fix add in calc.py + +**Agent:** codex + +**Output:** +codex (fake) call 1: frozenmemoryanchor tokpipeline + +## Entry 2026-11-15T12:03:03.500+00:00 0030b3f7ecbb4f72bb83f270a73d068a + +> created: 2026-11-15T12:03:03+00:00 +> tags: ["kimi-code", "task-result", "task:fa54e714-2b40-4871-b201-1bd63aea633b", "shared-from=ddb5090d-3922-42f5-9792-efede3c63e60"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokpipeline fix add in calc.py + +**Agent:** kimi-code + +**Output:** +kimi (fake) call 1: frozenmemoryanchor tokpipeline + +**Files changed:** calc.py + +## Entry 2026-11-15T12:03:04.099+00:00 5bc83da0d3df4f9988136b72444bd2d4 + +> created: 2026-11-15T12:03:04+00:00 +> tags: ["codex", "task-result", "task:48154546-ee89-44ab-92f0-936a5a9423e4", "shared-from=d890c5b2-d19f-4ad3-8b2a-724422c5734d"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokcompete fix add in calc.py + +**Agent:** codex + +**Output:** +codex (fake) call 1: frozenmemoryanchor tokcompete + +**Files changed:** calc.py + +## Entry 2026-11-15T12:03:04.674+00:00 b8c64c743b324e0d85f9051d96f6b3a7 + +> created: 2026-11-15T12:03:04+00:00 +> tags: ["codex", "council-proposal", "task:63e73eb4-8851-45ac-86a4-e4d1dae7fd5b", "shared-from=f8d4b001-c8c3-4f82-989e-c5a3d098d1a3"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py + +**Agent:** codex + +**Output:** +codex (fake) call 1: frozenmemoryanchor tokcouncil + +## Entry 2026-11-15T12:03:04.678+00:00 309ca31d095c45bb81b67af3de492f2d + +> created: 2026-11-15T12:03:04+00:00 +> tags: ["council-proposal", "kimi-code", "task:63e73eb4-8851-45ac-86a4-e4d1dae7fd5b", "shared-from=eb3f71e5-0967-4188-9fb9-294dd4cb7c37"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py + +**Agent:** kimi-code + +**Output:** +kimi (fake) call 1: frozenmemoryanchor tokcouncil + +## Entry 2026-11-15T12:03:04.703+00:00 716ee9a1983f455eb3108b3252e4b8c7 + +> created: 2026-11-15T12:03:04+00:00 +> tags: ["codex", "council-critique", "task:63e73eb4-8851-45ac-86a4-e4d1dae7fd5b", "shared-from=0e8f432b-ed54-48b5-b6b1-eff426ed6294"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py + +**Agent:** codex + +**Output:** +codex (fake) call 2: frozenmemoryanchor tokcouncil + +## Entry 2026-11-15T12:03:04.707+00:00 d049699d618247b7b415f88d5c008c6e + +> created: 2026-11-15T12:03:04+00:00 +> tags: ["council-critique", "kimi-code", "task:63e73eb4-8851-45ac-86a4-e4d1dae7fd5b", "shared-from=6b7f291f-1844-4b7d-893f-329b5c4cc603"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py + +**Agent:** kimi-code + +**Output:** +kimi (fake) call 2: frozenmemoryanchor tokcouncil + +## Entry 2026-11-15T12:03:04.734+00:00 36b541c103854088a26161dbbb96c715 + +> created: 2026-11-15T12:03:04+00:00 +> tags: ["codex", "council-critique", "task:63e73eb4-8851-45ac-86a4-e4d1dae7fd5b", "shared-from=5654daed-a625-4c46-bebf-0dc8b6cbc132"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py + +**Agent:** codex + +**Output:** +codex (fake) call 3: frozenmemoryanchor tokcouncil + +## Entry 2026-11-15T12:03:04.738+00:00 20164b36081b4afbbae33eba509c7537 + +> created: 2026-11-15T12:03:04+00:00 +> tags: ["council-critique", "kimi-code", "task:63e73eb4-8851-45ac-86a4-e4d1dae7fd5b", "shared-from=46bc6aee-cc5d-401d-a145-0c3b4e705110"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py + +**Agent:** kimi-code + +**Output:** +kimi (fake) call 3: frozenmemoryanchor tokcouncil + +## Entry 2026-11-15T12:03:04.799+00:00 84199788776849f1ac197d1f551ef2b4 + +> created: 2026-11-15T12:03:04+00:00 +> tags: ["codex", "task-result", "task:63e73eb4-8851-45ac-86a4-e4d1dae7fd5b", "shared-from=4d7ae35c-7a4a-448e-bb84-5d6454ea44aa"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokcouncil fix add in calc.py + +**Agent:** codex + +**Output:** +codex (fake) call 4: frozenmemoryanchor tokcouncil + +**Files changed:** calc.py + +## Entry 2026-11-15T12:03:05.373+00:00 dfaa8c1b00554181862a8252580096ab + +> created: 2026-11-15T12:03:05+00:00 +> tags: ["codex", "decompose-plan", "task:60f4a050-14fb-4d07-993f-f6594cac1cff", "shared-from=46f33458-ee71-4a27-8b9b-fba9a1dcc873"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py + +**Agent:** codex + +**Output:** +["alpha part of the work frozenmemoryanchor tokdecompose", "beta part of the work frozenmemoryanchor tokdecompose"] + +## Entry 2026-11-15T12:03:05.445+00:00 48473b24f699412bbc480d44c29dccbf + +> created: 2026-11-15T12:03:05+00:00 +> tags: ["codex", "decompose-subtask", "task:60f4a050-14fb-4d07-993f-f6594cac1cff", "shared-from=0e20c913-8601-4e2c-bbc0-ef85b9e1bff0"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py + +**Agent:** codex + +**Output:** +codex (fake) call 2: frozenmemoryanchor tokdecompose + +## Entry 2026-11-15T12:03:05.449+00:00 ea3c970cc3af4a68a11c899b896b2089 + +> created: 2026-11-15T12:03:05+00:00 +> tags: ["decompose-subtask", "kimi-code", "task:60f4a050-14fb-4d07-993f-f6594cac1cff", "shared-from=8d8a1bc6-315d-4350-9d43-349ee80f6c13"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py + +**Agent:** kimi-code + +**Output:** +kimi (fake) call 1: frozenmemoryanchor tokdecompose + +## Entry 2026-11-15T12:03:05.563+00:00 d2442b4743374619aec9c3e53c432720 + +> created: 2026-11-15T12:03:05+00:00 +> tags: ["codex", "task-result", "task:60f4a050-14fb-4d07-993f-f6594cac1cff", "shared-from=1b11e235-0888-4016-8fb4-8fab268c25f1"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokdecompose fix add in calc.py + +**Agent:** codex + +**Output:** +codex (fake) call 3: frozenmemoryanchor tokdecompose + +**Files changed:** calc.py + +## Entry 2026-11-15T12:03:06.150+00:00 e62f7ccb2e0a444c960691dcdded8815 + +> created: 2026-11-15T12:03:06+00:00 +> tags: ["codex", "task-result", "task:5852569e-a986-481e-a6ad-33553df3a114", "shared-from=9ffaa4d6-7951-4af9-ac74-f51065b00dfa"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokunicode say something long + +**Agent:** codex + +**Output:** +frozenmemoryanchor tokunicode 한글 본문 と日本語 🙂 +second line after CRLF +가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라마바사 가나다라 + +## Entry 2026-11-15T12:03:06.761+00:00 d08ac71f1aca47e5a459739463edc30b + +> created: 2026-11-15T12:03:06+00:00 +> tags: ["task:4dbd4741-e03e-49f2-b64b-c5fd010d23ae", "task-result", "codex", "shared-from=3f3be4a5-3f3d-42a7-9d17-eef3165ae597"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokheadings review calc.py + +**Agent:** codex + +**Output:** +frozenmemoryanchor tokheadings summary line + +### Findings +> tags: ["task:4dbd4741-e03e-49f2-b64b-c5fd010d23ae", "task-result", "codex", "shared-from=3f3be4a5-3f3d-42a7-9d17-eef3165ae597"] + + +frozenmemoryanchor tokheadings findings. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. The add function subtracted its second argument. + +### Next steps +> tags: ["task:4dbd4741-e03e-49f2-b64b-c5fd010d23ae", "task-result", "codex", "shared-from=3f3be4a5-3f3d-42a7-9d17-eef3165ae597"] + + +frozenmemoryanchor tokheadings steps. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. Add a test for negative numbers and for zero. + +## Entry 2026-11-15T12:03:07.360+00:00 a6d8874be0d14b8b8fc951566269a477 + +> created: 2026-11-15T12:03:07+00:00 +> tags: ["codex", "task-result", "task:07319897-6d47-4e97-8c45-8ca464fc8f7b", "shared-from=e6adcb55-4ca5-4ab9-a87a-da02598dc778"] + +**Task Result** + +**Prompt:** frozenmemoryanchor toklong fix add in calc.py. + +requirement-000 keeps the sum of two integers exact + +requirement-001 keeps the sum of two integers exact + +requirement-002 keeps the sum of two integers exact + +requirement-003 keeps the sum of two integers exact + +requirement-004 keeps the sum of two integers exact + +requirement-005 keeps the sum of two integers exact + +requirement-006 keeps the sum of two integers exact + +requirement-007 keeps the sum of two integers exact + +requirement-008 keeps the sum of two integers exact + +requirement-009 keeps the sum of two integers exact + +requirement-010 keeps the sum of two integers exact + +requirement-011 keeps the sum of two integers exact + +requirement-012 keeps the sum of two integers exact + +requirement-013 keeps the sum of two integers exact + +requirement-014 keeps the sum of two integers exact + +requirement-015 keeps the sum of two integers exact + +requirement-016 keeps the sum of two integers exact + +requirement-017 keeps the sum of two integers exact + +requirement-018 keeps the sum of two integers exact + +requirement-019 keeps the sum of two integers exact + +requirement-020 keeps the sum of two integers exact + +requirement-021 keeps the sum of two integers exact + +requirement-022 keeps the sum of two integers exact + +requirement-023 keeps the sum of two integers exact + +requirement-024 keeps the sum of two integers exact + +requirement-025 keeps the sum of two integers exact + +requirement-026 keeps the sum of two integers exact + +requirement-027 keeps the sum of two integers exact + +requirement-028 keeps the sum of two integers exact + +requirement-029 keeps the sum of two integers exact + +requirement-030 keeps the sum of two integers exact + +requirement-031 keeps the sum of two integers exact + +requirement-032 keeps the sum of two integers exact + +requirement-033 keeps the sum of two integers exact + +requirement-034 keeps the sum of two integers exact + +requirement-035 keeps the sum of two integers exact + +requirement-036 keeps the sum of two integers exact + +## Entry 2026-11-15T12:03:07.364+00:00 7f42c7c92184492f9aa8f45af627a15b + +> created: 2026-11-15T12:03:07+00:00 +> tags: ["codex", "task-result", "task:07319897-6d47-4e97-8c45-8ca464fc8f7b", "shared-from=89fa98dd-23cd-4a42-9450-e7a89a1d9308"] + +requirement-037 keeps the sum of two integers exact + +requirement-038 keeps the sum of two integers exact + +requirement-039 keeps the sum of two integers exact + +requirement-040 keeps the sum of two integers exact + +requirement-041 keeps the sum of two integers exact + +requirement-042 keeps the sum of two integers exact + +requirement-043 keeps the sum of two integers exact + +requirement-044 keeps the sum of two integers exact + +requirement-045 keeps the sum of two integers exact + +requirement-046 keeps the sum of two integers exact + +requirement-047 keeps the sum of two integers exact + +requirement-048 keeps the sum of two integers exact + +requirement-049 keeps the sum of two integers exact + +requirement-050 keeps the sum of two integers exact + +requirement-051 keeps the sum of two integers exact + +requirement-052 keeps the sum of two integers exact + +requirement-053 keeps the sum of two integers exact + +requirement-054 keeps the sum of two integers exact + +requirement-055 keeps the sum of two integers exact + +requirement-056 keeps the sum of two integers exact + +requirement-057 keeps the sum of two integers exact + +requirement-058 keeps the sum of two integers exact + +requirement-059 keeps the sum of two integers exact + +**Agent:** codex + +**Output:** +codex (fake) call 1: frozenmemoryanchor toklong + +## Entry 2026-11-15T12:03:08.724+00:00 675d30fe3ddc4f37bdb05f5a2a8105d0 + +> created: 2026-11-15T12:03:08+00:00 +> tags: ["board-result:899be792-3851-4e3c-8b17-6ab33ccd5a01"] + +**Board Item Result** + +**Item:** 899be792-3851-4e3c-8b17-6ab33ccd5a01 + +**Task:** frozenmemoryanchor tokboard fix add in calc.py + +**Output:** +codex (fake) call 1: frozenmemoryanchor tokboard + +## Entry 2026-11-15T12:03:10.247+00:00 0dc8d1694bf4489fb1991c351ad6d476 + +> created: 2026-11-15T12:03:10+00:00 +> tags: ["codex", "room-result", "task:b2e856ed-f192-46fe-b591-08e780cdd8c3", "shared-from=f893fe02-4aab-46d6-8614-2a2899cb7826"] + +**Task Result** + +**Prompt:** frozenmemoryanchor tokroom fix add in calc.py + +**Agent:** codex + +**Output:** +codex (fake) call 1: frozenmemoryanchor tokroom + +**Files changed:** calc.py diff --git a/tests/fixtures/persisted/memory/v0.3.0/store/mm.db b/tests/fixtures/persisted/memory/v0.3.0/store/mm.db new file mode 100644 index 0000000..e86fb11 Binary files /dev/null and b/tests/fixtures/persisted/memory/v0.3.0/store/mm.db differ diff --git a/tests/fixtures/persisted/memory/v0.3.0/store/mm.db-shm b/tests/fixtures/persisted/memory/v0.3.0/store/mm.db-shm new file mode 100644 index 0000000..2a812a5 Binary files /dev/null and b/tests/fixtures/persisted/memory/v0.3.0/store/mm.db-shm differ diff --git a/tests/fixtures/persisted/memory/v0.3.0/store/mm.db-wal b/tests/fixtures/persisted/memory/v0.3.0/store/mm.db-wal new file mode 100644 index 0000000..f28e9c3 Binary files /dev/null and b/tests/fixtures/persisted/memory/v0.3.0/store/mm.db-wal differ diff --git a/tests/frozen_memory_support.py b/tests/frozen_memory_support.py new file mode 100644 index 0000000..001f5bb --- /dev/null +++ b/tests/frozen_memory_support.py @@ -0,0 +1,142 @@ +"""Shared access to the frozen memtomem stores (#271). + +``tests/fixtures/persisted/memory//`` holds stores a released syncmill +wrote through its own CLI (see ``freeze.py`` beside them). Nothing here opens a +fixture file for writing: a test works on a copy under ``tmp_path``. +""" + +from __future__ import annotations + +import hashlib +import json +import re +import shutil +import sqlite3 +from dataclasses import dataclass +from pathlib import Path + +FIXTURES = Path(__file__).parent / "fixtures" / "persisted" / "memory" +RELEASES = sorted(p.name for p in FIXTURES.iterdir() if p.is_dir() and p.name.startswith("v")) + +_TASK_TAG = re.compile(r"task:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}") +_SHARED_FROM_TAG = re.compile( + r"shared-from=[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}" +) + + +def normal_tags(tags: list[str]) -> tuple[str, ...]: + """Tags with the two generated ids replaced by ``*``, the way the scenario + definitions name them (a task id and a private row id exist only once the + release has run).""" + out = [] + for tag in tags: + if _TASK_TAG.fullmatch(tag): + tag = "task:*" + elif _SHARED_FROM_TAG.fullmatch(tag): + tag = "shared-from=*" + out.append(tag) + return tuple(sorted(out)) + + +@dataclass(frozen=True) +class Row: + id: str + namespace: str + tags: tuple[str, ...] # as stored, sorted + content: str + source_file: str # the stored absolute path + + @property + def key(self) -> tuple[str, tuple[str, ...], str]: + return (self.namespace, normal_tags(list(self.tags)), self.content) + + +@dataclass(frozen=True) +class StoreCopy: + """A copy of one frozen store under ``tmp_path``, moved and nothing else.""" + + name: str + root: Path + db: Path + mem: Path + board: Path | None + generating_mem: str # the day-file directory the release wrote into + + def rows(self) -> dict[str, Row]: + """The chunk rows, through an ordinary connection so that a WAL the + release left is applied the way any SQLite reader applies it.""" + conn = sqlite3.connect(self.db) + try: + return { + r[0]: Row(r[0], r[1], tuple(sorted(json.loads(r[2]))), r[3], r[4]) + for r in conn.execute( + "SELECT id, namespace, tags, content, source_file FROM chunks ORDER BY rowid" + ) + } + finally: + conn.close() + + def day_files(self) -> list[Path]: + return sorted(p for p in self.mem.iterdir() if p.suffix == ".md" and p.name[0] != ".") + + +class Frozen: + def __init__(self, release: str): + self.release = release + self.root = FIXTURES / release + self.index = json.loads((self.root / "index.json").read_text(encoding="utf-8")) + self.read = json.loads((self.root / "release-read.json").read_text(encoding="utf-8")) + self.anchor: str = self.index["anchor"] + self.date: str = self.index["date"] + + @property + def stores(self) -> list[str]: + return sorted(self.index["stores"]) + + def scenario(self, name: str) -> dict: + return self.index["scenarios"][name] + + def verify_pins(self) -> None: + """Every fixture file is the byte sequence ``freeze.py`` recorded, and + there is no file it did not record.""" + pinned = self.index["files"] + present = { + str(p.relative_to(self.root)) + for p in self.root.rglob("*") + if p.is_file() and p.name != "index.json" + } + assert present == set(pinned), sorted(present ^ set(pinned)) + for relative, digest in pinned.items(): + actual = hashlib.sha256((self.root / relative).read_bytes()).hexdigest() + assert actual == digest, relative + + def copy(self, store: str, dest: Path) -> StoreCopy: + """Copy one store whole, database sidecars and lock files included.""" + spec = self.index["stores"][store] + target = dest.resolve() / store + shutil.copytree(self.root / store, target) + return StoreCopy( + name=store, + root=target, + db=target.parent / spec["db"], + mem=target.parent / spec["mem"], + board=target.parent / spec["board"] if spec["board"] else None, + generating_mem=str(Path(spec["root"]) / Path(spec["mem"]).relative_to(store)), + ) + + def expected(self, store: str) -> list[tuple[str, tuple[str, ...], str]]: + """The rows the scenario definitions name for one store.""" + return sorted( + (row["namespace"], tuple(row["tags"]), row["body"]) + for scenario in self.index["scenarios"].values() + if scenario["store"] == store + for row in scenario["rows"] + ) + + def scenario_rows(self, store: StoreCopy, name: str) -> list[Row]: + """The stored rows of one scenario, found by what its definition names.""" + wanted = { + (row["namespace"], tuple(row["tags"]), row["body"]) + for row in self.scenario(name)["rows"] + } + return [row for row in store.rows().values() if row.key in wanted] diff --git a/tests/test_frozen_memory.py b/tests/test_frozen_memory.py new file mode 100644 index 0000000..f54f7d8 --- /dev/null +++ b/tests/test_frozen_memory.py @@ -0,0 +1,257 @@ +"""memtomem stores written by released syncmill: the stored bytes (#271). + +The stores under ``tests/fixtures/persisted/memory//`` were written by +that release's own CLI (``freeze.py`` beside them) and are never regenerated. +This module needs no memtomem engine: it reads the databases with ``sqlite3`` +and the day files as text, and holds them to the scenario definitions and to +the names HEAD derives for them. What HEAD's readers make of these stores is +``test_frozen_memory_real.py``, which runs against real memtomem. +""" + +from __future__ import annotations + +import re +import sqlite3 +from pathlib import Path +from types import SimpleNamespace + +import pytest + +from syncmill.memory_backend import _day_file, _is_day_file, _namespace_day_file_suffixes + +from frozen_memory_support import RELEASES, Frozen, normal_tags + +#: Tables memtomem keys by source path. A release-written store leaves the ones +#: its memtomem version has empty; schema 1 (memtomem 0.3) has none of them. +SOURCE_TABLES = ( + "source_index_receipts", + "held_sources", + "pending_source_checks", + "source_visibility_generations", +) +#: The kind tags the release read searched by (``freeze.py`` ``KINDS``). +KINDS = { + "task-result", "room-result", "pipeline-stage", "council-proposal", + "council-critique", "decompose-plan", "decompose-subtask", +} +#: What ``_namespace_day_file_suffixes`` reads from a memtomem config. +STORE_CONFIG = SimpleNamespace(namespace=SimpleNamespace(default_namespace="default")) + +pytestmark = pytest.mark.parametrize("release", RELEASES) + + +@pytest.fixture(autouse=True, scope="module") +def fixtures_stay_as_frozen(): + yield + for release in RELEASES: + Frozen(release).verify_pins() + + +def test_the_fixture_files_are_the_frozen_bytes(release): + Frozen(release).verify_pins() + + +def test_each_store_holds_exactly_the_rows_its_scenarios_name(release, tmp_path): + frozen = Frozen(release) + for name in frozen.stores: + store = frozen.copy(name, tmp_path) + rows = store.rows() + assert sorted(row.key for row in rows.values()) == frozen.expected(name), name + assert rows, name + + # A run whose agent failed shared nothing: its token is in no row. + store = frozen.copy("store", tmp_path / "again") + failed = frozen.scenario("failed") + assert failed["rows"] == [] + assert not [r for r in store.rows().values() if failed["token"] in r.content] + + +def test_a_shared_copy_names_the_private_row_it_was_copied_from(release, tmp_path): + frozen = Frozen(release) + copies = 0 + for name in frozen.stores: + rows = frozen.copy(name, tmp_path).rows() + for row in rows.values(): + sources = [t.split("=", 1)[1] for t in row.tags if t.startswith("shared-from=")] + if not sources: + continue + copies += 1 + assert row.namespace == "shared" and len(sources) == 1 + private = rows[sources[0]] + assert private.namespace.startswith("agent-runtime:") + assert private.content == row.content + assert set(row.tags) == {*private.tags, f"shared-from={private.id}"} + assert copies + + +def test_head_derives_each_day_file_name_and_its_namespace(release, tmp_path): + frozen = Frozen(release) + for name in frozen.stores: + store = frozen.copy(name, tmp_path) + rows = store.rows() + namespaces = sorted({row.namespace for row in rows.values()}) + files = {p.name for p in store.day_files()} + assert files == {_day_file(store.mem, ns, frozen.date).name for ns in namespaces} + for ns in namespaces: + owned = { + f for f in files + if any( + _is_day_file(f, suffix) + for suffix in _namespace_day_file_suffixes(STORE_CONFIG, ns) + ) + } + assert owned == {_day_file(store.mem, ns, frozen.date).name}, ns + for row in rows.values(): + assert Path(row.source_file).name == _day_file( + store.mem, row.namespace, frozen.date + ).name + + +def test_a_day_file_holds_the_entries_the_scenarios_wrote(release, tmp_path): + frozen = Frozen(release) + for name in frozen.stores: + store = frozen.copy(name, tmp_path) + entries: dict[str, int] = {} + for scenario in frozen.index["scenarios"].values(): + if scenario["store"] != name: + continue + # A private entry too long for one chunk is several rows; each of + # its chunks is copied into `shared` as an entry of its own. + per_entry = scenario.get("private_chunks_per_entry", 1) + for row in scenario["rows"]: + private = row["namespace"].startswith("agent-runtime:") + share = 1 / per_entry if private else 1 + entries[row["namespace"]] = entries.get(row["namespace"], 0) + share + for path in store.day_files(): + text = path.read_text(encoding="utf-8") + ns = next( + ns for ns in entries if _day_file(store.mem, ns, frozen.date).name == path.name + ) + assert len(re.findall(r"(?m)^> created: ", text)) == entries[ns], path.name + assert len(re.findall(r"(?m)^## Entry ", text)) == entries[ns], path.name + assert frozen.index["generating_root"] not in text + + +def test_the_release_read_is_tied_to_the_stored_rows(release, tmp_path): + frozen = Frozen(release) + for name in frozen.stores: + rows = frozen.copy(name, tmp_path).rows() + read = frozen.read[name] + assert set(read["get"]) == set(rows) + for chunk_id, row in rows.items(): + got = read["get"][chunk_id] + assert got["id"] == chunk_id + assert got["namespace"] == row.namespace + assert got["content"] == row.content + assert tuple(sorted(got["tags"])) == row.tags + assert got["source"] == row.source_file + by_namespace: dict[str, list[str]] = {} + for row in rows.values(): + by_namespace.setdefault(row.namespace, []).append(row.id) + assert read["count"] == {ns: len(ids) for ns, ids in by_namespace.items()} + # Every stored body carries the common token, so the release's own + # search for it returns the whole namespace, and only that namespace. + assert all(frozen.anchor in row.content for row in rows.values()) + assert read["search"] == {ns: sorted(ids) for ns, ids in by_namespace.items()} + # Every release's backend search takes a tag filter, so the release + # searched every namespace by every kind. + assert set(read["search_by_kind"]) == set(by_namespace) + for ns, by_kind in read["search_by_kind"].items(): + assert set(by_kind) == KINDS, ns + for kind, ids in by_kind.items(): + assert ids == sorted( + r.id for r in rows.values() if r.namespace == ns and kind in r.tags + ), (ns, kind) + kinds = { + tag + for row in frozen.copy("store", tmp_path / "kinds").rows().values() + for tag in normal_tags(list(row.tags)) + } + assert KINDS <= kinds + + +def test_only_the_source_path_binds_a_store_to_where_it_was_written(release, tmp_path): + frozen = Frozen(release) + root = frozen.index["generating_root"] + for name in frozen.stores: + store = frozen.copy(name, tmp_path) + conn = sqlite3.connect(store.db) + try: + tables = [r[0] for r in conn.execute( + "SELECT name FROM sqlite_master WHERE type = 'table' ORDER BY name" + )] + holding = set() + for table in tables: + try: + columns = [r[1] for r in conn.execute(f'PRAGMA table_info("{table}")')] + for column in columns: + hit = conn.execute( + f'SELECT 1 FROM "{table}" WHERE CAST("{column}" AS TEXT) LIKE ? ' + "LIMIT 1", (f"%{root}%",), + ).fetchone() + if hit: + holding.add((table, column)) + except sqlite3.OperationalError: + continue # a virtual table whose module is not loaded here + assert holding == { + ("chunks", "source_file"), + ("chunks_fts", "source_file"), + ("chunks_fts_content", "c1"), + }, name + # The stored path is the day file under the generating directory. + for (path,) in conn.execute("SELECT source_file FROM chunks"): + assert str(Path(path).parent) == store.generating_mem + assert conn.execute( + "SELECT COUNT(*) FROM chunks c JOIN chunks_fts f ON f.rowid = c.rowid " + "WHERE f.source_file != c.source_file" + ).fetchone() == (0,) + present = [t for t in SOURCE_TABLES if t in tables] + memtomem = tuple(int(part) for part in frozen.index["memtomem"].split(".")[:2]) + expected = list(SOURCE_TABLES) if memtomem >= (0, 6) else [] + assert present == expected, name + for table in present: + assert conn.execute(f"SELECT COUNT(*) FROM {table}").fetchone() == (0,), table + assert conn.execute( + "SELECT COUNT(*) FROM chunks WHERE project_root IS NOT NULL" + ).fetchone() == (0,) + finally: + conn.close() + + +def test_the_store_was_written_with_no_embedding_provider(release, tmp_path): + """A search finds a released row only through a word (the tests rely on + the scenario tokens), because the store has no vectors at all.""" + frozen = Frozen(release) + for name in frozen.stores: + conn = sqlite3.connect(frozen.copy(name, tmp_path).db) + try: + meta = dict(conn.execute("SELECT key, value FROM _memtomem_meta")) + tables = {r[0] for r in conn.execute("SELECT name FROM sqlite_master")} + finally: + conn.close() + assert (meta["embedding_provider"], meta["embedding_dimension"]) == ("none", "0"), name + assert not [t for t in tables if t.startswith("chunks_vec")], name + + +def test_the_killed_runs_row_is_only_in_the_wal(release, tmp_path): + """The SIGKILLed board run is the last scenario, and its stage row never + reached the main database file: a reader that ignores the WAL misses it.""" + frozen = Frozen(release) + killed = frozen.scenario("board-killed") + store = frozen.copy("store", tmp_path / "whole") + wal = store.db.with_name(store.db.name + "-wal") + assert wal.is_file() and wal.stat().st_size > 0 + # The main file's bytes are taken before anything opens the copy: closing + # an ordinary connection checkpoints the WAL into it. + alone = tmp_path / "main-file-only" + alone.mkdir() + (alone / store.db.name).write_bytes(store.db.read_bytes()) + (row,) = frozen.scenario_rows(store, "board-killed") + assert row.namespace == f"board-run:{killed['run_id']}" + conn = sqlite3.connect(f"file:{alone / store.db.name}?mode=ro&immutable=1", uri=True) + try: + ids = {r[0] for r in conn.execute("SELECT id FROM chunks")} + finally: + conn.close() + assert row.id not in ids + assert ids == set(store.rows()) - {row.id} diff --git a/tests/test_frozen_memory_real.py b/tests/test_frozen_memory_real.py new file mode 100644 index 0000000..f44e2f6 --- /dev/null +++ b/tests/test_frozen_memory_real.py @@ -0,0 +1,829 @@ +"""memtomem stores written by released syncmill, read by HEAD (#271). + +Opt-in like every real-memtomem test (``SYNCMILL_TEST_MEMTOMEM_REAL=1``; CI's +``memory-backend-real`` job runs it): HEAD's ``MemtomemBackend`` and everything above it +(``SyncmillMemory``, the gateway, ``status``, the strategies, a room round, the +board's scratch collection) work on a copy of a store the release's own CLI +wrote. ``test_frozen_memory.py`` holds the stored bytes to the scenario +definitions without an engine; this module holds HEAD's readers to those +definitions and to what the release itself read (``release-read.json``). + +A store is bound to the directory it was written in by one column, +``chunks.source_file`` (and its FTS mirror). A copy that is only moved reads +correctly, and that is how the open tests use it. Anything that resolves a +source file (purge, reindex, a write) needs the copy rebound first; ``rebind`` +does that and proves it touched nothing else. +""" + +from __future__ import annotations + +import json +import os +import sqlite3 +from pathlib import Path +from uuid import UUID + +import pytest +from click.testing import CliRunner + +import syncmill.supervisor as S +from syncmill.board import Board +from syncmill.cli import cli +from syncmill.config import MemoryConfig, SyncmillConfig +from syncmill.gateway import build_gateway +from syncmill.memory import run_async +from syncmill.memory_backend import MemtomemBackend +from syncmill.models import Task, TaskResult +from syncmill.rooms import RoomCoordinator +from syncmill.strategies.compete import CompeteStrategy +from syncmill.strategies.council import CouncilStrategy +from syncmill.strategies.decompose import DecomposeStrategy +from syncmill.strategies.pipeline import PipelineStrategy +from syncmill.strategies.route import RouteStrategy +from syncmill.supervisor import Supervisor +from syncmill.worktree import CapturedChanges + +from conftest import FakeAgent, FakeRegistry, FakeWorktreePool, make_memory +from frozen_memory_support import RELEASES, Frozen, Row, StoreCopy + +pytestmark = [ + pytest.mark.integration, + pytest.mark.skipif( + os.environ.get("SYNCMILL_TEST_MEMTOMEM_REAL") != "1", + reason="set SYNCMILL_TEST_MEMTOMEM_REAL=1 to run the real memtomem tests", + ), + pytest.mark.parametrize("release", RELEASES), +] + +#: HEAD's default board lease. +LEASE = 1800 +#: Larger than any frozen store: a search with it is not cut by ``top_k``. +ALL = 200 +#: The filters HEAD's strategies send for a later phase, written out. The +#: values are compared with what a HEAD run actually sent, and each is shown to +#: select exactly the released rows of those kinds. +LATER_PHASE_FILTERS = { + "pipeline-stage": {"pipeline-stage"}, + "council-proposal": {"council-proposal"}, + "council-proposal,council-critique": {"council-proposal", "council-critique"}, + "decompose-plan,decompose-subtask": {"decompose-plan", "decompose-subtask"}, + "decompose-subtask": {"decompose-subtask"}, +} + + +@pytest.fixture(autouse=True) +def engine_environment(monkeypatch, tmp_path): + """Neither interpreter state nor the developer's memtomem may leak in: no + ambient memtomem settings, a home of its own, and a private runtime + directory (memtomem refuses a schema migration when it cannot read the + server registry there, and it only accepts a directory nobody else can + enter).""" + for key in list(os.environ): + if key.startswith("MEMTOMEM_"): + monkeypatch.delenv(key) + home = (tmp_path / "home").resolve() + home.mkdir(exist_ok=True) + monkeypatch.setenv("HOME", str(home)) + monkeypatch.setenv("XDG_CONFIG_HOME", str(home / ".config")) + runtime = (tmp_path / "memtomem-runtime").resolve() + runtime.mkdir(mode=0o700) + monkeypatch.setenv("_MEMTOMEM_TEST_RUNTIME_DIR", str(runtime)) + + +@pytest.fixture(autouse=True, scope="module") +def fixtures_stay_as_frozen(): + yield + for release in RELEASES: + Frozen(release).verify_pins() + + +def _snapshot(store: StoreCopy) -> dict[str, tuple]: + return {i: (r.namespace, r.tags, r.content) for i, r in store.rows().items()} + + +def _cells(db: Path) -> dict[str, list[tuple]]: + """Every cell of every ordinary table, with the one location-bound column + blanked. FTS shadow tables are left out: they mirror ``chunks``.""" + conn = sqlite3.connect(db) + try: + cells = {} + for (table,) in conn.execute( + "SELECT name FROM sqlite_master WHERE type = 'table' ORDER BY name" + ).fetchall(): + if table.startswith("chunks_fts") or table.startswith("chunks_vec"): + continue + columns = [r[1] for r in conn.execute(f'PRAGMA table_info("{table}")')] + picked = ", ".join( + "''" if (table, c) == ("chunks", "source_file") else f'"{c}"' for c in columns + ) + cells[table] = conn.execute(f'SELECT {picked} FROM "{table}" ORDER BY rowid').fetchall() + return cells + finally: + conn.close() + + +def rebind(store: StoreCopy) -> StoreCopy: + """Point a moved copy at its own directory. + + The same two statements memtomem itself uses when a source file moves + (``update_chunks_scope_for_source``): the path in ``chunks`` and, because + the FTS table has no trigger, its mirror there. The new path is spelled the + way memtomem spells one (``norm_path``). + """ + from memtomem.storage.sqlite_helpers import norm_path + + # Directory prefixes with their separator, compared exactly (a LIKE + # pattern would read the `_` in a temporary path as a wildcard). + old = store.generating_mem.rstrip("/") + "/" + new = norm_path(store.mem).rstrip("/") + "/" + before = _cells(store.db) + conn = sqlite3.connect(store.db) + try: + moved = conn.execute( + "UPDATE chunks SET source_file = ? || substr(source_file, ?) " + "WHERE substr(source_file, 1, ?) = ?", + (new, len(old) + 1, len(old), old), + ).rowcount + conn.execute( + "UPDATE chunks_fts SET source_file = " + "(SELECT source_file FROM chunks WHERE chunks.rowid = chunks_fts.rowid)" + ) + conn.commit() + assert moved == conn.execute("SELECT COUNT(*) FROM chunks").fetchone()[0] > 0 + assert conn.execute( + "SELECT COUNT(*) FROM chunks WHERE substr(source_file, 1, ?) = ?", (len(old), old) + ).fetchone() == (0,) + assert conn.execute( + "SELECT COUNT(*) FROM chunks c JOIN chunks_fts f ON f.rowid = c.rowid " + "WHERE f.source_file != c.source_file" + ).fetchone() == (0,) + finally: + conn.close() + assert _cells(store.db) == before + for row in store.rows().values(): + assert Path(row.source_file).parent == store.mem + return store + + +def _backend(store: StoreCopy) -> MemtomemBackend: + return MemtomemBackend(MemoryConfig(db_path=str(store.db), memory_dir=str(store.mem))) + + +class _Engine: + """HEAD's backend on one store copy, closed before anyone looks at the + database file again.""" + + def __init__(self, store: StoreCopy): + self.store = store + self.backend = _backend(store) + self.memory = make_memory(self.backend) + + def __enter__(self) -> "_Engine": + run_async(self.backend.ensure_ready()) + return self + + def __exit__(self, *exc) -> None: + run_async(self.backend.close()) + + def healthy(self) -> None: + assert not self.memory.degraded and self.memory.last_error is None + + +def _ids(rows) -> list[str]: + return sorted(row["id"] for row in rows) + + +def _private(frozen: Frozen, store: StoreCopy, scenario: str) -> Row: + (row,) = [ + r for r in frozen.scenario_rows(store, scenario) + if r.namespace.startswith("agent-runtime:") + ] + return row + + +def _shared(frozen: Frozen, store: StoreCopy, scenario: str) -> Row: + (row,) = [r for r in frozen.scenario_rows(store, scenario) if r.namespace == "shared"] + return row + + +# ── open ───────────────────────────────────────────────────────────────────── + + +def test_head_opens_every_released_store_and_leaves_its_rows_alone(release, tmp_path): + frozen = Frozen(release) + for name in frozen.stores: + # The reference rows come from a second copy: the copy HEAD opens must + # not have been opened by anything else first, least of all the store + # a SIGKILL left with its rows still in the WAL. + before = _snapshot(frozen.copy(name, tmp_path / "reference")) + assert before, name + released = frozen.read[name] + store = frozen.copy(name, tmp_path / "opened") + for _ in range(2): # the second open finds a store HEAD already opened + with _Engine(store) as engine: + counts = { + ns: run_async(engine.backend.count_namespace(ns)) + for ns in {v[0] for v in before.values()} + } + # Moved, not rebound: the rows read as stored, the killed + # run's row out of the WAL included. + for chunk_id, (ns, tags, content) in before.items(): + got = run_async(engine.backend.get(chunk_id)) + assert (got["namespace"], sorted(got["tags"]), got["content"]) == ( + ns, list(tags), content + ), chunk_id + assert got["source"] == released["get"][chunk_id]["source"] + found = { + ns: _ids(run_async(engine.backend.search( + frozen.anchor, namespace=ns, top_k=ALL + ))) + for ns in counts + } + assert counts == { + ns: sum(1 for v in before.values() if v[0] == ns) for ns in counts + }, name + assert found == released["search"], name + assert _snapshot(store) == before, name + + +# ── adapter reads ──────────────────────────────────────────────────────────── + + +def test_get_reads_each_released_row_as_the_release_did(release, tmp_path): + frozen = Frozen(release) + for name in frozen.stores: + store = rebind(frozen.copy(name, tmp_path)) + rows = store.rows() + with _Engine(store) as engine: + for chunk_id, row in rows.items(): + got = run_async(engine.backend.get(chunk_id)) + released = frozen.read[name]["get"][chunk_id] + assert got["id"] == released["id"] == chunk_id + assert got["namespace"] == released["namespace"] == row.namespace + assert got["content"] == released["content"] == row.content + assert sorted(got["tags"]) == sorted(released["tags"]) == list(row.tags) + # The release read its own path; HEAD reads the copy's. + assert Path(got["source"]).name == Path(released["source"]).name + assert Path(got["source"]).parent == store.mem + + +def test_search_stays_inside_the_namespace_and_the_kind_asked_for(release, tmp_path): + frozen = Frozen(release) + store = rebind(frozen.copy("store", tmp_path)) + rows = store.rows() + namespaces = sorted({r.namespace for r in rows.values()}) + kinds_seen = set() + with _Engine(store) as engine: + search = engine.backend.search + for ns in namespaces: + in_ns = [r for r in rows.values() if r.namespace == ns] + found = run_async(search(frozen.anchor, namespace=ns, top_k=ALL)) + assert _ids(found) == sorted(r.id for r in in_ns) == frozen.read["store"]["search"][ns] + assert {r["namespace"] for r in found} == {ns} + for wanted, kinds in LATER_PHASE_FILTERS.items(): + expected = sorted(r.id for r in in_ns if kinds & set(r.tags)) + found = run_async( + search(frozen.anchor, namespace=ns, top_k=ALL, tag_filter=wanted) + ) + assert _ids(found) == expected, (ns, wanted) + if expected: + kinds_seen.add(wanted) + assert run_async( + search(frozen.anchor, namespace=ns, top_k=ALL, tag_filter="no-such-kind") + ) == [] + # One scenario's own token finds that scenario's rows and no other. + for scenario in ("route", "unicode", "headings", "room-apply"): + token = frozen.scenario(scenario)["token"] + found = run_async(search(token, namespace="shared", top_k=ALL)) + assert _ids(found) == [_shared(frozen, store, scenario).id], scenario + assert kinds_seen == set(LATER_PHASE_FILTERS) # every filter met a released row + + +def test_search_multi_count_and_status_cover_the_released_rows(release, tmp_path): + frozen = Frozen(release) + store = rebind(frozen.copy("store", tmp_path)) + rows = store.rows() + codex, shared = ( + sorted(r.id for r in rows.values() if r.namespace == ns) + for ns in ("agent-runtime:codex", "shared") + ) + assert codex and shared + with _Engine(store) as engine: + backend = engine.backend + both = run_async(backend.search_multi( + frozen.anchor, namespaces=["agent-runtime:codex", "shared"], top_k=ALL + )) + assert _ids(both) == sorted(codex + shared) + only = run_async(backend.search_multi(frozen.anchor, namespaces=["shared"], top_k=ALL)) + assert _ids(only) == shared + assert len(run_async(backend.search_multi( + frozen.anchor, namespaces=["agent-runtime:codex", "shared"], top_k=3 + ))) == 3 + for ns in {r.namespace for r in rows.values()}: + count = run_async(backend.count_namespace(ns)) + assert count == sum(1 for r in rows.values() if r.namespace == ns) > 0 + assert count == frozen.read["store"]["count"][ns] + status = run_async(backend.status()) + assert status["db_path"] == str(store.db) + assert status["total_chunks"] == len(rows) + assert status["embedding_provider"] == "none" + + +# ── adapter writes beside released rows ────────────────────────────────────── + + +def test_sharing_a_released_row_copies_its_tags_and_names_it(release, tmp_path): + frozen = Frozen(release) + store = rebind(frozen.copy("store", tmp_path)) + before = _snapshot(store) + private = _private(frozen, store, "route") + (scratch,) = [ + r for r in frozen.scenario_rows(store, "board-done") + if r.namespace.startswith("board-run:") + ] + already_shared = _shared(frozen, store, "route") + made = {} + with _Engine(store) as engine: + storage = run_async(engine.backend._storage()) + for source in (private, scratch, already_shared): + new_id = run_async(engine.backend.share_chunk(source.id, target_namespace="shared")) + assert new_id and new_id not in before + link = run_async(storage.get_chunk_link(UUID(new_id), "shared")) + assert link is not None and str(link.source_id) == source.id + made[new_id] = source + after = store.rows() + assert {i: v for i, v in _snapshot(store).items() if i in before} == before + assert set(after) == set(before) | set(made) + for new_id, source in made.items(): + copy = after[new_id] + assert copy.namespace == "shared" and copy.content == source.content + kept = [t for t in source.tags if not t.startswith("shared-from=")] + assert sorted(copy.tags) == sorted([*kept, f"shared-from={source.id}"]) + + +@pytest.mark.parametrize("same_day", [False, True]) +def test_a_fresh_share_lands_beside_the_released_rows(release, tmp_path, monkeypatch, same_day): + """On a later day HEAD starts new day files and leaves the released ones + byte for byte; on the release's own day it appends to them.""" + frozen = Frozen(release) + store = rebind(frozen.copy("store", tmp_path)) + before = _snapshot(store) + released_files = {p.name: p.read_bytes() for p in store.day_files()} + day = frozen.date if same_day else "2099-01-01" + monkeypatch.setattr("syncmill.memory_backend._utc_date_str", lambda: day) + body = f"**Task Result**\n\nwritten by HEAD beside {frozen.anchor}" + with _Engine(store) as engine: + write = run_async(engine.backend.add_and_share( + body, tags=["task-result", "codex"], namespace="agent-runtime:codex", + target_namespace="shared", + )) + assert len(write.source_ids) == len(write.shared_ids) == 1 + found = run_async(engine.backend.search(frozen.anchor, namespace="shared", top_k=ALL)) + released_shared = {i for i, v in before.items() if v[0] == "shared"} + assert _ids(found) == sorted(released_shared | {write.shared_ids[0]}) + after = store.rows() + assert {i: v for i, v in _snapshot(store).items() if i in before} == before + assert set(after) == set(before) | {write.source_ids[0], write.shared_ids[0]} + assert after[write.shared_ids[0]].content == body + written = {f"{day}.agent-runtime.codex.md", f"{day}.shared.md"} + assert {Path(after[i].source_file).name for i in set(after) - set(before)} == written + for path in store.day_files(): + if path.name not in released_files: + assert not same_day and path.name in written + elif same_day and path.name in written: + grown = path.read_bytes() + assert grown.startswith(released_files[path.name]) and len(grown) > len( + released_files[path.name] + ) + else: + assert path.read_bytes() == released_files[path.name] + + +def test_purging_a_released_scratch_namespace_removes_only_it(release, tmp_path): + frozen = Frozen(release) + store = rebind(frozen.copy("store", tmp_path)) + before = store.rows() + scratch_ns = f"board-run:{frozen.scenario('board-done')['run_id']}" + doomed = {i for i, r in before.items() if r.namespace == scratch_ns} + (doomed_file,) = {Path(before[i].source_file) for i in doomed} + assert doomed and doomed_file.is_file() + files = {p.name for p in store.day_files()} + with _Engine(store) as engine: + assert run_async(engine.backend.purge_namespace(scratch_ns)) == len(doomed) + assert run_async(engine.backend.count_namespace(scratch_ns)) == 0 + after = store.rows() + assert set(after) == set(before) - doomed + assert {i: r for i, r in after.items()} == {i: r for i, r in before.items() if i not in doomed} + assert {p.name for p in store.day_files()} == files - {doomed_file.name} + + +def test_reindexing_the_released_day_files_changes_no_row(release, tmp_path): + frozen = Frozen(release) + for name in frozen.stores: + store = rebind(frozen.copy(name, tmp_path)) + before = _snapshot(store) + per_file: dict[str, int] = {} + for row in store.rows().values(): + per_file[Path(row.source_file).name] = per_file.get(Path(row.source_file).name, 0) + 1 + with _Engine(store) as engine: + components = run_async(engine.backend._store._ensure_init()) + for path in store.day_files(): + stats = run_async(components.index_engine.index_file(path, already_scanned=True)) + assert (stats.total_files, stats.indexed_chunks, stats.deleted_chunks) == (1, 0, 0) + assert stats.skipped_chunks == per_file[path.name] > 0 + assert tuple(stats.errors) == () + assert _snapshot(store) == before, name + + +# ── SyncmillMemory ─────────────────────────────────────────────────────────── + + +def _bodies(rows: list[Row]) -> set[str]: + return {r.content for r in rows} + + +def test_search_context_returns_the_released_bodies_a_phase_is_entitled_to(release, tmp_path): + frozen = Frozen(release) + store = rebind(frozen.copy("store", tmp_path)) + rows = list(store.rows().values()) + shared = [r for r in rows if r.namespace == "shared"] + elsewhere = _bodies([r for r in rows if r.namespace != "shared"]) - _bodies(shared) + assert elsewhere # the board run's scratch body exists nowhere in `shared` + with _Engine(store) as engine: + memory = engine.memory + + def context(**kwargs) -> str: + text = run_async(memory.search_context(frozen.anchor, max_bytes=10**7, **kwargs)) + engine.healthy() + return text + + everything = context(top_k=ALL) + assert all(body in everything for body in _bodies(shared)) + assert not any(body in everything for body in elsewhere) + for wanted, kinds in LATER_PHASE_FILTERS.items(): + entitled = _bodies([r for r in shared if kinds & set(r.tags)]) + others = _bodies(shared) - entitled + text = context(top_k=ALL, tag_filter=wanted) + assert entitled and all(body in text for body in entitled), wanted + assert not any(body in text for body in others), wanted + # The default limits return a handful of released rows, never none. + default = run_async(memory.search_context(frozen.anchor)) + engine.healthy() + assert 1 <= sum(1 for body in _bodies(shared) if body in default) <= 5 + # With an agent the private namespace is searched too: the route + # result is then found twice, as the private row and as its copy. + route = _shared(frozen, store, "route").content + token = frozen.scenario("route")["token"] + assert run_async(memory.search_context(token, top_k=ALL)).count(route) == 1 + assert run_async( + memory.search_context(token, agent_id="codex", top_k=ALL) + ).count(route) == 2 + engine.healthy() + + +def test_shared_reads_never_disclose_a_private_or_scratch_row(release, tmp_path): + frozen = Frozen(release) + store = rebind(frozen.copy("store", tmp_path)) + rows = store.rows() + shared = {i: r for i, r in rows.items() if r.namespace == "shared"} + private = _private(frozen, store, "route") + run_id = frozen.scenario("board-done")["run_id"] + (scratch,) = [r for r in rows.values() if r.namespace == f"board-run:{run_id}"] + with _Engine(store) as engine: + memory = engine.memory + found = run_async(memory.search_shared(frozen.anchor, top_k=ALL)) + assert _ids(found) == sorted(shared) + assert {row["namespace"] for row in found} == {"shared"} + for chunk_id, row in shared.items(): + read = run_async(memory.get_shared(chunk_id)) + assert read.status == "found" and read.chunk["content"] == row.content + for hidden in (private, scratch): + assert run_async(engine.backend.get(hidden.id))["content"] == hidden.content + read = run_async(memory.get_shared(hidden.id)) + assert (read.status, read.chunk) == ("not_found", None) + assert run_async(memory.shared_stats()) == { + "namespace": "shared", "chunk_count": len(shared) + } + engine.healthy() + + # A board-scoped view reads its own scratch namespace and `shared`. + view = memory.scoped(run_id) + text = run_async(view.search_context(frozen.anchor, top_k=ALL, max_bytes=10**7)) + assert scratch.content in text + assert _shared(frozen, store, "route").content in text + assert not view.degraded and view.last_error is None + + +# ── production surfaces ────────────────────────────────────────────────────── + + +def _call(mcp, name: str, args: dict) -> str: + return run_async(mcp.call_tool(name, args)).structured_content["result"] + + +def test_the_gateway_serves_the_released_shared_rows(release, tmp_path): + frozen = Frozen(release) + store = rebind(frozen.copy("store", tmp_path)) + rows = store.rows() + shared = _shared(frozen, store, "unicode") + private = _private(frozen, store, "unicode") + with _Engine(store) as engine: + gateway = build_gateway(engine.memory) + token = frozen.scenario("unicode")["token"] + out = _call(gateway, "shared_search", {"query": token}) + assert shared.id in out and private.id not in out + assert shared.content[:200] in out + assert shared.content in _call(gateway, "shared_read", {"chunk_id": shared.id}) + hidden = _call(gateway, "shared_read", {"chunk_id": private.id}) + assert private.content not in hidden and shared.content not in hidden + in_shared = sum(1 for r in rows.values() if r.namespace == "shared") + assert _call(gateway, "shared_stats", {}) == f"shared: {in_shared} chunks" + engine.healthy() + + +def test_status_connects_to_a_released_store(release, tmp_path, monkeypatch): + frozen = Frozen(release) + store = rebind(frozen.copy("store", tmp_path)) + before = _snapshot(store) + monkeypatch.setenv("SYNCMILL_MEMORY__DB_PATH", str(store.db)) + monkeypatch.setenv("SYNCMILL_MEMORY__MEMORY_DIR", str(store.mem)) + result = CliRunner().invoke(cli, ["status"]) + assert result.exit_code == 0, result.output + assert "memtomem: connected" in result.output + assert f"db_path: {store.db}" in result.output + assert _snapshot(store) == before + + +class _Scripted(FakeAgent): + """A fake agent whose replies are scripted per call (the last repeats). + Each call is also appended to ``events``, when given, as ``("call", + prompt)``.""" + + def __init__(self, agent_id: str, replies: list[str], events: list | None = None): + super().__init__(agent_id) + self._replies = replies + self._events = events + + def execute(self, prompt: str, workdir: Path, timeout: int) -> TaskResult: + self._output = self._replies[min(len(self.calls), len(self._replies) - 1)] + if self._events is not None: + self._events.append(("call", prompt)) + return super().execute(prompt, workdir, timeout) + + +@pytest.fixture +def pool(monkeypatch): + """No worktree and no git under a strategy: the store is what is real.""" + fake = FakeWorktreePool(is_git=True) + monkeypatch.setattr(S, "WorktreePool", lambda repo_root, task_id: fake) + monkeypatch.setattr( + "syncmill.strategies.base.capture_changes", + lambda p, base=None, *, git_dir=None: CapturedChanges(("changed.py",), ""), + ) + return fake + + +def _supervisor(memory, strategy, agents: list, *, board=None, **config) -> Supervisor: + sup = Supervisor.__new__(Supervisor) + sup._config = SyncmillConfig(**config) + sup._registry = FakeRegistry(agents) + sup._memory = memory + sup._breaker = None + sup._matcher = None + sup._board = board + sup._strategy = strategy + sup.last_report_path = None + return sup + + +def _recording(memory, events: list) -> None: + """Append each recall to ``events`` as ``("recall", tag filter, context + returned)``.""" + real = memory.search_context + + async def search_context(query, agent_id=None, **kwargs): + text = await real(query, agent_id, **kwargs) + events.append(("recall", kwargs.get("tag_filter"), text)) + return text + + memory.search_context = search_context + + +@pytest.mark.parametrize( + "strategy, config, filters", + [ + (RouteStrategy, {}, [None]), + (CompeteStrategy, {}, [None]), + (PipelineStrategy, {}, [None, "pipeline-stage"]), + ( + CouncilStrategy, + {"council": {"rounds": 2}}, + [ + None, + "council-proposal", + "council-proposal,council-critique", + "council-proposal,council-critique", + ], + ), + ( + DecomposeStrategy, + {}, + [None, "decompose-plan,decompose-subtask", "decompose-subtask"], + ), + ], +) +def test_a_head_strategy_asks_a_released_store_for_the_kinds_it_holds( + release, tmp_path, pool, strategy, config, filters +): + frozen = Frozen(release) + store = rebind(frozen.copy("store", tmp_path)) + released = [r for r in store.rows().values() if r.namespace == "shared"] + # Every word of the task is in each released strategy result (their + # prompts were " tok fix add in calc.py"). memtomem + # falls back from matching every word to matching any word only when the + # first finds nothing, so a word the released rows lack would leave a + # later phase with this run's own rows alone, which repeat the task. + task = f"{frozen.anchor} fix add in calc.py" + assert sum(1 for r in released if all(w in r.content for w in task.split())) >= 10 + events: list = [] + plan = json.dumps(["first half of the work", "second half of the work"]) + agents = [ + _Scripted("codex", [plan, "codex did it"], events), + _Scripted("kimi-code", ["kimi did it"], events), + ] + with _Engine(store) as engine: + _recording(engine.memory, events) + result = _supervisor(engine.memory, strategy(), agents, **config).run(Task(prompt=task)) + engine.healthy() + assert result.status.value == "completed", result.error + recalls = [i for i, event in enumerate(events) if event[0] == "recall"] + assert [events[i][1] for i in recalls] == filters + for n, at in enumerate(recalls): + _, wanted, text = events[at] + # A phase recalls once, then runs its agents: its prompts are the + # calls before the next recall. + until = recalls[n + 1] if n + 1 < len(recalls) else len(events) + phase = [event[1] for event in events[at + 1:until] if event[0] == "call"] + assert phase, wanted + kinds = LATER_PHASE_FILTERS[wanted] if wanted else None + entitled = _bodies([r for r in released if kinds is None or kinds & set(r.tags)]) + others = _bodies(released) - entitled + returned = {body for body in entitled if body in text} + # Each recall finds released rows, only of the kinds it asks for, and + # every agent of that phase is handed them. + assert returned, (wanted, text) + assert not any(body in text for body in others), wanted + for body in returned: + assert all(body in prompt for prompt in phase), (wanted, body[:80]) + + +def test_a_head_run_hands_its_agent_the_released_result(release, tmp_path, pool): + frozen = Frozen(release) + store = rebind(frozen.copy("store", tmp_path)) + released = _shared(frozen, store, "route") + agent = FakeAgent("codex", output="a follow-up") + with _Engine(store) as engine: + _supervisor(engine.memory, RouteStrategy(), [agent]).run( + Task(prompt=frozen.scenario("route")["token"]) + ) + engine.healthy() + (call,) = agent.calls + assert call["prompt"].startswith("Context from previous work:\n") + assert released.content in call["prompt"] + + +def test_a_head_room_round_hands_its_member_the_released_result(release, tmp_path, git_repo): + from test_rooms import WritingAgent + + frozen = Frozen(release) + store = rebind(frozen.copy("store", tmp_path / "store")) + released = _shared(frozen, store, "room-apply") + config = SyncmillConfig( + project={"id": "frozen-memory-room"}, + runs={"root": str(tmp_path / "runs")}, + workspace={"root": str(tmp_path / "workspaces")}, + rooms={"enabled": True}, + memory={"db_path": str(store.db), "memory_dir": str(store.mem)}, + ) + agents = [WritingAgent("codex")] + with _Engine(store) as engine: + coordinator = RoomCoordinator(config, git_repo, agents=agents, memory=engine.memory) + try: + room = coordinator.create("a new room task", ["codex"]) + coordinator.run_round(room["id"], frozen.scenario("room-apply")["token"]) + finally: + coordinator.close() + engine.healthy() + prompt = agents[0].calls[-1]["prompt"] + assert prompt.startswith("Context from previous work:\n") + assert released.content in prompt + + +def test_head_finds_a_released_store_at_the_project_default_location( + release, tmp_path, git_repo, monkeypatch +): + """An initialized project that leaves ``[memory]`` at its defaults keeps + its store under ``/.syncmill/memory``, database and day files side + by side. The released bytes are put there, and a HEAD room round, given no + memory and no memory paths, finds them through ``configure_project_memory``. + """ + import syncmill.rooms as rooms + from syncmill.memory import SyncmillMemory + from test_rooms import WritingAgent + + frozen = Frozen(release) + staged = frozen.copy("store", tmp_path / "staged") + home = git_repo / ".syncmill" / "memory" + home.mkdir(parents=True) + for path in staged.day_files(): + (home / path.name).write_bytes(path.read_bytes()) + for part in staged.db.parent.glob(staged.db.name + "*"): + (home / part.name.replace(staged.db.name, "memtomem.db", 1)).write_bytes(part.read_bytes()) + store = rebind(StoreCopy( + name="project", root=home.resolve(), db=home.resolve() / "memtomem.db", + mem=home.resolve(), board=None, generating_mem=staged.generating_mem, + )) + released = _shared(frozen, store, "room-apply") + config = SyncmillConfig( + project={"id": "frozen-memory-project"}, + runs={"root": str(tmp_path / "runs")}, + workspace={"root": str(tmp_path / "workspaces")}, + rooms={"enabled": True}, + ) + assert config.memory.memory_dir is None + # Undo the suite-wide stand-in: this round builds its own real memory. + monkeypatch.setattr(rooms, "SyncmillMemory", SyncmillMemory) + agents = [WritingAgent("codex")] + coordinator = RoomCoordinator(config, git_repo, agents=agents) + try: + assert config.memory.db_path == str(store.db) + assert config.memory.memory_dir == str(store.mem) + room = coordinator.create("a new room task", ["codex"]) + coordinator.run_round(room["id"], frozen.scenario("room-apply")["token"]) + finally: + coordinator.close() + prompt = agents[0].calls[-1]["prompt"] + assert prompt.startswith("Context from previous work:\n") + assert released.content in prompt + + +class _Clock: + def __init__(self, now: float): + self.now = now + + def __call__(self) -> float: + return self.now + + +def test_head_reclaims_a_released_lease_and_purges_its_scratch_namespace( + release, tmp_path, pool +): + frozen = Frozen(release) + killed = frozen.scenario("board-killed") + store = rebind(frozen.copy("store", tmp_path)) + before = store.rows() + scratch_ns = f"board-run:{killed['run_id']}" + doomed = {i for i, r in before.items() if r.namespace == scratch_ns} + (scratch_file,) = {Path(before[i].source_file) for i in doomed} + assert doomed and scratch_file.is_file() + + clock = _Clock(killed["claimed_at"] + LEASE) + board = Board(str(store.board), now=clock, lease_timeout_seconds=LEASE) + agent = FakeAgent("codex", output="finished after the crash") + try: + with _Engine(store) as engine: + sup = _supervisor(engine.memory, RouteStrategy(), [agent], board=board) + # First sweep: the released lease has just run out, so the item is + # reclaimed and run again. Its old scratch namespace is inside its + # grace period and stays. + result = sup.run_item() + assert result is not None and result.status.value == "completed" + assert f"Task: {killed['task']}" in agent.calls[0]["prompt"] + assert run_async(engine.backend.count_namespace(scratch_ns)) == len(doomed) + # Second sweep, one more lease timeout later: now it is collected. + clock.now += LEASE + sup._gc_board_run_namespaces(board) + assert run_async(engine.backend.count_namespace(scratch_ns)) == 0 + engine.healthy() + ledger = sqlite3.connect(store.board) + try: + purged_at = ledger.execute( + "SELECT purged_at FROM board_run_namespaces WHERE run_id = ?", + (killed["run_id"],), + ).fetchone() + finally: + ledger.close() + assert purged_at == (clock.now,) + finally: + board.close() + after = store.rows() + assert not set(after) & doomed + assert not scratch_file.exists() + # Nothing the release stored outside a scratch namespace was touched, and + # the reclaimed run added one row there: its board-result. + durable = {i: r for i, r in before.items() if not r.namespace.startswith("board-run:")} + assert {i: r for i, r in after.items() if i in durable} == durable + assert [ + (r.namespace, r.tags) for i, r in after.items() + if i not in before and not r.namespace.startswith("board-run:") + ] == [("shared", (f"board-result:{killed['item_id']}",))]