From 0c2d1465b0e9eba6db57e5b51198364cc81250a7 Mon Sep 17 00:00:00 2001 From: dtzp555 Date: Fri, 13 Mar 2026 19:03:47 +1000 Subject: [PATCH] docs: record ACP worker vs agent communication findings --- MEMORY.md | 1 + memory/2026-03-13.md | 37 +++++++++++++++++++++++++++++++++++++ memory/CURRENT_STATE.md | 7 +++++-- 3 files changed, 43 insertions(+), 2 deletions(-) create mode 100644 memory/2026-03-13.md diff --git a/MEMORY.md b/MEMORY.md index b0e3632..db635da 100644 --- a/MEMORY.md +++ b/MEMORY.md @@ -28,6 +28,7 @@ ## 4) ACP/Codex delegation constraints - Telegram channel plugin currently does **not** support `subagent_spawning` hooks → cannot bind persistent subagent sessions with `thread=true`; use `sessions_spawn(mode="run")` as workaround. - Current durable conclusion on `execution-agent-dispatch`: it is a **process/protocol skill**, not a fix for OpenClaw/ACP runtime communication. We previously tested parent↔child / agent↔agent flows and did **not** get stable bidirectional communication. Default behavior is still closer to spawn + announce than reliable free-form agent-to-agent conversation. Keep the skill frozen as a workflow aid only; wait for OpenClaw ACP/runtime support to become stable before resuming development aimed at true inter-agent communication. +- New clarified split after ACP re-check on 2026-03-13: **main → ACP worker** invocation is now confirmed basically usable on this machine (ACPX installed/enabled; Codex ACP smoke test could start, inherit workspace, and read expected files). But this does **not** prove stable **agent↔agent** or **subagent↔subagent** communication over ACP. Treat the safe default as: main acts as PM/architect/reviewer, ACP workers execute tasks and report back to main; do **not** assume a reliable free-form multi-agent ACP communication mesh. ## 5) OCM (OpenClaw Manager) repo policies - OCM repo path: `~/.openclaw/ocm`. diff --git a/memory/2026-03-13.md b/memory/2026-03-13.md new file mode 100644 index 0000000..c3da3b5 --- /dev/null +++ b/memory/2026-03-13.md @@ -0,0 +1,37 @@ +# 2026-03-13 + +- Memory-continuity project reached a solid Phase 1 checkpoint. +- Verified subagent continuity can work after fixing Telegram resident agents' tool permissions; root cause was agent config inheriting `tools.profile = messaging` without `tools.alsoAllow`, so subagents lacked `read`. Added `group:fs`, `group:runtime`, `group:memory`, `sessions_spawn`, and `subagents` to key resident agents (`tech_geek`, `travel_assistant`, `finance_assistant`, `interpreter`) and restart made the change effective. +- Confirmed Telegram resident agent continuity failure was not just stale state; after tool fix, `tech_geek` successfully recovered a test fact from `CURRENT_STATE.md` after `/new`. +- Determined OpenClaw `contextEngine` is an exclusive slot, so memory-continuity should not use ContextEngine as the primary v1 architecture because it would conflict with ecosystem plugins like `lossless-claw`. +- Design direction finalized: `memory-continuity` is a structured working-state checkpoint layer that complements native OpenClaw memory/compaction, not a replacement. Primary path is now `SKILL.md + standard lifecycle plugin`; ContextEngine is a future option only. +- Added and pushed design docs to GitHub repo `dtzp555-max/memory-continuity`: + - `references/scope.md` + - `references/plugin-design.md` +- Updated and pushed skill docs aligned to lifecycle-plugin direction: + - `SKILL.md` + - `README.md` + - `references/template.md` + - `references/doctor-spec.md` +- Added Phase 2 development artifacts to skill repo: + - `plugin/lifecycle-prototype.ts` + - `references/phase2-hook-validation.md` +- Lifecycle plugin prototype now targets ordinary hooks instead of ContextEngine. Current key validated evidence from local SDK/docs: standard plugins can use prompt-injection hooks, especially `before_prompt_build` (preferred) and `before_agent_start` (fallback), plus `command:new`, `agent_end`, and compaction-related hooks. +- Prototype bugfixes completed before next live testing phase: + - fixed JS section parser regex in `extractSection` + - aligned archive filenames to `YYYY-MM-DD_HH-MM.md` + - added compaction probe marker/log so Experiment C is observable +- Latest local checkpoint before next phase: ready to mount plugin and run real experiments, prioritizing: + 1. Experiment A — verify `before_prompt_build` startup continuity injection is actually visible to the agent + 2. Experiment C — verify compaction hook behavior is synchronous/reliable enough for checkpoint safety +- User preference/process note: for future GitHub pushes on this skill, include a release/version identifier. +- Phase 2 runtime probe status: + - Experiment A passed on `tech_geek`: the resident subagent answered correctly from plugin-injected startup continuity state without using `read`. + - After upgrade, `travel_assistant` initially failed as a sample because it had historical pollution from an old wrong workspace path (`~/.openclaw/workspace-travel_assistant`) and its `AGENTS.md` startup sequence did not read `memory/CURRENT_STATE.md`. + - After removing the old wrong workspace and fixing `travel_assistant`'s `AGENTS.md` to read `memory/CURRENT_STATE.md` on startup, `travel_assistant` also passed the startup-injection smoke test without using `read`. + - Therefore Experiment A is now confirmed on multiple resident subagent samples, including post-upgrade validation. + - Experiment C is still pending, not failed: the attempted pressure test on `tech_geek` never actually entered compaction (`13%` context, `0` compactions), so compaction-hook behavior remains unproven. + - Conservative decision taken: do not force compaction on the main live session. Run compaction testing later in a disposable/sacrificial test session instead. + - Additional boundary discovered after fresh Discord testing: Discord main/channel/thread sessions are not currently in the supported continuity set for `v0.3.0-probe`. Even with fresh `/new`, new thread, and new channel tests, Discord main failed to preserve short facts or restore concrete working-state details across sessions. Treat resident subagents as the validated support surface; treat Discord main continuity as unsupported for this alpha. +- New fallback-path finding: during a main-session fallback/new-session event, `memory-continuity-probe`'s `before_prompt_build` hook did run but logged `workspaceDir= statePath=`, so startup recovery could not resolve `CURRENT_STATE.md`. Opened upstream issue `openclaw/openclaw#44746` and currently suspect an OpenClaw lifecycle/runtime contract gap rather than a pure plugin logic bug. +- ACP capability clarified: this machine does have ACPX installed and enabled; a Codex ACP smoke test successfully started and inherited workspace context. Current safe operational model is therefore `main -> ACP worker -> main`, not free-form stable agent↔agent ACP communication. diff --git a/memory/CURRENT_STATE.md b/memory/CURRENT_STATE.md index 194247f..6c82422 100644 --- a/memory/CURRENT_STATE.md +++ b/memory/CURRENT_STATE.md @@ -16,10 +16,13 @@ Startup-injection testing is confirmed on multiple resident subagents after the - Alpha support boundary is now explicit: resident subagent startup continuity is supported; Discord main/channel/thread continuity is not yet supported in `v0.3.0-probe`. ## Next Action -Use `travel_assistant` as the sacrificial session, reload the updated probe logging, then force/accelerate a real compaction event and compare hook behavior against the failure chain seen on main. +Two-track next step: +1. If continuing active testing, use `travel_assistant` as the sacrificial session, reload the updated probe logging, then force/accelerate a real compaction event and compare hook behavior against the failure chain seen on main. +2. If pausing for upstream uncertainty, keep the fallback-continuity GitHub issue open and wait for OpenClaw feedback before spending more effort on the main-session fallback path. ## Blockers -Experiment C still lacks a real compaction event, so compaction-hook behavior remains unproven. +- Experiment C still lacks a real compaction event, so compaction-hook behavior remains unproven. +- New upstream-suspected blocker: fallback continuity failure may be caused by OpenClaw providing incomplete plugin runtime (`workspaceDir=`) on fallback/new-session recovery path. ## Unsurfaced Results - Experiment A is now confirmed on multiple resident subagents.