memory: comprehensive week retrospective -- PT/orama collab Lessons

.agent/memory/candidates/graduated/2d53056e593c.json

@@ -0,0 +1,110 @@
+{
+  "id": "2d53056e593c",
+  "key": "manual_2d5305",
+  "name": "manual_2d5305",
+  "claim": "Several tooling and API gotchas recur across a working session even after being individually caught once, because a single encounter doesn't automatically generalize into a standing rule: the PR-list API's merged field being unreliable (must check the single-PR endpoint); squash-merged branches never showing as git ancestors (verify by content/ID presence, not ancestry); a stale local checkout after an earlier push in the same session diverging silently; and diff-scoped CI lint checking a whole touched file, not just the changed hunk. Each of these needs to be treated as a standing checklist item to consult before the relevant operation, not a one-off lesson learned and then re-derived from scratch the next time it's encountered.",
+  "conditions": [
+    "across",
+    "after",
+    "ancestors",
+    "ancestry",
+    "api",
+    "automatically",
+    "because",
+    "before",
+    "branches",
+    "caught",
+    "changed",
+    "check",
+    "checking",
+    "checklist",
+    "checkout",
+    "consult",
+    "content",
+    "diff-scoped",
+    "diverging",
+    "doesn",
+    "each",
+    "earlier",
+    "encounter",
+    "encountered",
+    "endpoint",
+    "even",
+    "field",
+    "file",
+    "generalize",
+    "git",
+    "gotchas",
+    "hunk",
+    "individually",
+    "into",
+    "item",
+    "just",
+    "learned",
+    "lesson",
+    "lint",
+    "local",
+    "merged",
+    "needs",
+    "never",
+    "next",
+    "once",
+    "one-off",
+    "operation",
+    "pr-list",
+    "presence",
+    "push",
+    "re-derived",
+    "recur",
+    "relevant",
+    "rule",
+    "same",
+    "scratch",
+    "session",
+    "several",
+    "showing",
+    "silently",
+    "single",
+    "single-pr",
+    "squash-merged",
+    "stale",
+    "standing",
+    "time",
+    "tooling",
+    "touched",
+    "treated",
+    "unreliable",
+    "verify",
+    "whole",
+    "working"
+  ],
+  "evidence_ids": [
+    "2026-08-01T06:53:43.671436+00:00"
+  ],
+  "cluster_size": 1,
+  "canonical_salience": 8.0,
+  "staged_at": "2026-08-01T06:53:43.671436+00:00",
+  "status": "accepted",
+  "decisions": [
+    {
+      "ts": "2026-08-01T06:53:43.671436+00:00",
+      "action": "staged",
+      "reviewer": "learn"
+    },
+    {
+      "ts": "2026-08-01T06:53:50.650448+00:00",
+      "action": "graduated",
+      "reviewer": "host-agent",
+      "notes": "Several gotchas recurred even after individual capture -- worth the meta-lesson that a checklist consulted before the operation, not recall alone, is what actually prevents repetition.",
+      "provisional": false,
+      "evidence_snapshot": [
+        "2026-08-01T06:53:43.671436+00:00"
+      ],
+      "lessons_sha": "4bce83c74754"
+    }
+  ],
+  "rejection_count": 0,
+  "accepted_at": "2026-08-01T06:53:50.650434+00:00",
+  "reviewer": "host-agent",
+  "rationale": "Several gotchas recurred even after individual capture -- worth the meta-lesson that a checklist consulted before the operation, not recall alone, is what actually prevents repetition."
+}

.agent/memory/candidates/graduated/718c9430f44b.json

@@ -0,0 +1,128 @@
+{
+  "id": "718c9430f44b",
+  "key": "manual_718c94",
+  "name": "manual_718c94",
+  "claim": "When resolving real overlap between a new draft and an existing, more comprehensive doctrine, \"avoid duplication\" does not automatically mean \"make the newer, simpler thing subordinate to the older, more complex one.\" It means determining which document actually serves which situation and sizing each to its own job. A heavyweight protocol built for a rare, hard problem (e.g. concurrent multi-agent edits to the same repo, or reconciling a fork separated from its source by months of drift) should not become the default an agent reads first for the common, simple case (one branch, one agent, no concurrent editing) just because it existed first and is more thorough. Getting this backwards is not caught by re-reading a project's own stated single-source-of-truth value, since that value is genuinely being honored in some sense (no literal duplication) even while the sizing is wrong -- it may require direct correction from a human collaborator who can see the actual audience mismatch.",
+  "conditions": [
+    "actual",
+    "actually",
+    "agent",
+    "audience",
+    "automatically",
+    "avoid",
+    "backwards",
+    "because",
+    "become",
+    "between",
+    "branch",
+    "built",
+    "case",
+    "caught",
+    "collaborator",
+    "common",
+    "complex",
+    "comprehensive",
+    "concurrent",
+    "correction",
+    "default",
+    "determining",
+    "direct",
+    "doctrine",
+    "document",
+    "draft",
+    "drift",
+    "duplication",
+    "each",
+    "editing",
+    "edits",
+    "even",
+    "existed",
+    "existing",
+    "first",
+    "fork",
+    "genuinely",
+    "getting",
+    "hard",
+    "heavyweight",
+    "honored",
+    "human",
+    "job",
+    "just",
+    "literal",
+    "make",
+    "mean",
+    "means",
+    "mismatch",
+    "months",
+    "more",
+    "multi-agent",
+    "new",
+    "newer",
+    "older",
+    "one",
+    "overlap",
+    "own",
+    "problem",
+    "project",
+    "protocol",
+    "rare",
+    "re-reading",
+    "reads",
+    "real",
+    "reconciling",
+    "repo",
+    "require",
+    "resolving",
+    "same",
+    "see",
+    "sense",
+    "separated",
+    "serves",
+    "simple",
+    "simpler",
+    "since",
+    "single-source-of-truth",
+    "situation",
+    "sizing",
+    "some",
+    "source",
+    "stated",
+    "subordinate",
+    "thing",
+    "thorough",
+    "value",
+    "which",
+    "while",
+    "who",
+    "wrong"
+  ],
+  "evidence_ids": [
+    "2026-08-01T06:53:43.608740+00:00"
+  ],
+  "cluster_size": 1,
+  "canonical_salience": 8.0,
+  "staged_at": "2026-08-01T06:53:43.608740+00:00",
+  "status": "accepted",
+  "decisions": [
+    {
+      "ts": "2026-08-01T06:53:43.608740+00:00",
+      "action": "staged",
+      "reviewer": "learn"
+    },
+    {
+      "ts": "2026-08-01T06:53:50.501493+00:00",
+      "action": "graduated",
+      "reviewer": "host-agent",
+      "notes": "The hierarchy-inversion mistake this session, requiring direct human correction rather than self-catching -- worth a durable lesson about resolving overlap correctly, not just avoiding literal duplication.",
+      "provisional": false,
+      "evidence_snapshot": [
+        "2026-08-01T06:53:43.608740+00:00"
+      ],
+      "lessons_sha": "c7f4daa0894a"
+    }
+  ],
+  "rejection_count": 0,
+  "accepted_at": "2026-08-01T06:53:50.501478+00:00",
+  "reviewer": "host-agent",
+  "rationale": "The hierarchy-inversion mistake this session, requiring direct human correction rather than self-catching -- worth a durable lesson about resolving overlap correctly, not just avoiding literal duplication."
+}

.agent/memory/episodic/AGENT_LEARNINGS.jsonl

@@ -621,3 +621,5 @@
 {"timestamp": "2026-08-01T00:45:00+00:00", "skill": "phase1b-integration-review", "action": "memory-reencode-correction", "result": "success", "detail": "G5 (per-witness reputation-decay ledger) implemented via kimi fan-out and merged (orchestrator/reputation.py, 12/12 tests). Ran integration review across all 4 prior Phase 1b security modules (G1/G4/G6/G8): only provenance.py (G1) has a real caller (witness_quorum.py) — equivocation.py, distance_bucket.py, audit_log.py all sit at zero callers because StateTransitionManager, the intended integration point, only exists as pseudocode. Documented in docs/phase-0-specifications/2026-07-11-phase1b-integration-review.md rather than silently treating spec-compliant-and-tested as integrated-and-done. Reconfigured gemini-coder agent primary model to google-antigravity/claude-sonnet-4-6-thinking (was gemini-3-pro-high) per user preference order; corrected a wrong CLI command I had given the user for antigravity OAuth login (--agent belongs on the parent openclaw models auth command, not the login subcommand) and fixed the same stale example inside gemini-coder/IDENTITY.md.", "pain_score": 2, "importance": 8, "reflection": "Re-encoded from legacy date/summary row that was incorrectly prepended out of chronological order during episodic ledger normalization; preserved as append-only correction.", "confidence": 0.85, "source": {"skill": "phase1b-integration-review", "profile": "host-agent", "run_id": "pr313-review-4833040713", "commit_sha": "375c24d"}, "evidence_ids": ["docs/phase-0-specifications/2026-07-11-phase1b-integration-review.md"], "tags": ["phase1b", "G5", "integration-review", "gemini-coder", "openclaw-cli"], "supersedes": "episodic:sha256:64852643fa58430771914d086ad0b51c35c75b898a0e3efe3c48ad1e1f20a7d3"}
 {"timestamp": "2026-08-01T03:43:41.227998+00:00", "skill": "cursor-pr-body", "action": "PT314-pr-body-clobber-recovery-enforcement-plan", "result": "insight", "detail": "PT #314: agent clobbered PR body again via ManagePullRequest update_pr delta-only body= (4833493387 remediation), erasing original guard-sync Summary despite lesson_3b13ab0a45d4, lesson_4a38f0e95fcf, lesson_6fff093ccb00, and append-pr-body.sh. User caught it. Restored integratively: Summary + Follow-up 4833307836 + Follow-up 4833493387 + CodeRabbit block. Documented incident ledger: PT#154, orama#222, PT#298+orama#239, PT#314 (5 PRs / 4 incidents); ~5x silent estimate. Added .agent/memory/working/PR_BODY_ANTI_CLOBBER_ENFORCEMENT_PLAN.md, scripts/git/remind-pr-body-append-only.sh (hooked in publish-clean-branch.sh), sync append-only-pr-body.mdc to downstream repos.", "pain_score": 4, "importance": 10, "reflection": "Writing the rule is not enforcement. Agents shortcut update_pr at turn-end. Mechanical remind-before-push + strict mode + alwaysApply rule sync closes the loop.", "confidence": 0.95, "source": {"skill": "cursor-pr-body", "profile": "cursor-cloud", "run_id": "bc-70e499fc"}, "evidence_ids": ["lesson_3b13ab0a45d4", "lesson_4a38f0e95fcf", "lesson_6fff093ccb00", "PT:PR#314"]}
 {"timestamp": "2026-08-01T05:30:00+00:00", "skill": "cursor-pr-body", "action": "layer6-ci-strict-mode-sync-dirty-guard-rollout", "result": "success", "detail": "Completed PR body anti-clobber enforcement rollout on cursor/pr-body-enforcement-f559: (1) strict mode default in publish-clean-branch.sh (PR_BODY_GUARD_STRICT=1); (2) Layer 6 CI verify-pr-body-not-clobbered.sh + pr-body-guard.yml workflow; (3) sync-attribution-guard-scripts.sh aborts on dirty canonical/target guard-sync paths; (4) formalized incident ledger + learn-eval/ECC ritual + agent frugality reference cards in orama bin/orama-system/references/; (5) post-review-micro-remediation Phase 2 PR body + guard sync sections; (6) NEVER delta update_pr in append-only-pr-body.mdc and cursor-pr-body skill.", "pain_score": 2, "importance": 9, "reflection": "Mechanical gates beat repeated lessons. Dogfood: merge enforcement to main then merge PT#314 and orama#251 to test post-merge hooks.", "confidence": 0.95, "source": {"skill": "cursor-pr-body", "profile": "cursor-cloud", "run_id": "bc-70e499fc"}, "evidence_ids": ["lesson_a8f3c2e91d04", "PR_BODY_ANTI_CLOBBER_ENFORCEMENT_PLAN.md"]}
+{"timestamp": "2026-08-01T06:53:43.608740+00:00", "skill": "learn", "action": "manual-stage:718c9430f44b", "result": "success", "detail": "Manually staged lesson 718c9430f44b via .agent/tools/learn.py: 'When resolving real overlap between a new draft and an existing, more comprehensive doctrine, \"avoid duplication\" does not automatically mean \"make the newer, simpler thing subordinate to the older, more complex one.\" It means determining which document actually serves which situation and sizing each to its own job. A heavyweight protocol built for a rare, hard problem (e.g. concurrent multi-agent edits to the same repo, or reconciling a fork separated from its source by months of drift) should not become the default an agent reads first for the common, simple case (one branch, one agent, no concurrent editing) just because it existed first and is more thorough. Getting this backwards is not caught by re-reading a project\\'s own stated single-source-of-truth value, since that value is genuinely being honored in some sense (no literal duplication) even while the sizing is wrong -- it may require direct correction from a human collaborator who can see the actual audience mismatch.'", "pain_score": 1, "importance": 6, "reflection": "", "confidence": 0.9, "source": {"skill": "learn", "profile": "manual", "run_id": "manual_718c94"}, "evidence_ids": ["2026-08-01T06:53:43.608740+00:00"]}
+{"timestamp": "2026-08-01T06:53:43.671436+00:00", "skill": "learn", "action": "manual-stage:2d53056e593c", "result": "success", "detail": "Manually staged lesson 2d53056e593c via .agent/tools/learn.py: \"Several tooling and API gotchas recur across a working session even after being individually caught once, because a single encounter doesn't automatically generalize into a standing rule: the PR-list API's merged field being unreliable (must check the single-PR endpoint); squash-merged branches never showing as git ancestors (verify by content/ID presence, not ancestry); a stale local checkout after an earlier push in the same session diverging silently; and diff-scoped CI lint checking a whole touched file, not just the changed hunk. Each of these needs to be treated as a standing checklist item to consult before the relevant operation, not a one-off lesson learned and then re-derived from scratch the next time it's encountered.\"", "pain_score": 1, "importance": 6, "reflection": "", "confidence": 0.9, "source": {"skill": "learn", "profile": "manual", "run_id": "manual_2d5305"}, "evidence_ids": ["2026-08-01T06:53:43.671436+00:00"]}

.agent/memory/semantic/LESSONS.md

@@ -8,6 +8,9 @@
 
 - ~~Handwaving a known error always costs more later than fixing it now. When a check surfaces something that looks minor, tangential, or "not what I'm here to fix," the instinct to note it and move on is usually wrong -- the cost doesn't disappear, it just relocates to whoever hits it next (often the same agent, in a later, more expensive context). Treat every surfaced finding as either fixed now or explicitly, visibly deferred with a stated reason -- never silently absorbed into "I'll get to it."~~  <!-- status=legacy confidence=0.7 evidence=0 id=lesson_legacy_0b3f101508e4 superseded_by=lesson_502211a1be56 -->
 - ~~Append-only historical records (lessons, audits, vulnerability memory, review ledgers, and any file whose value depends on an intact record of what was actually claimed and when) must never be rewritten in place, even to fix a real error in the original entry. A direct edit destroys the original claim with no queryable trace within the data itself of what it used to say -- exactly the auditability the record exists to provide. The correct fix: append a new entry that supersedes the original (a supersedes/superseded_by back-reference), never mutate the original's fields. This applies to the record itself, not to copies rendered or cached from it -- a machine-generated markdown file regenerated from a corrected append-only source is fine to regenerate in place, and non-historical documents (working docs, prose restating a claim) can be edited directly.~~  <!-- status=legacy confidence=0.7 evidence=0 id=lesson_legacy_8ebfd5447e38 superseded_by=lesson_e773f6f957c2 -->
+- PR body updates are append-only — ManagePullRequest update_pr and gh pr edit replace the entire body. After every commit on a branch with an open PR, run bash scripts/git/remind-pr-body-append-only.sh before push; use scripts/cursor/append-pr-body.sh for writes. Documented clobber incidents: PT#154, orama#222, PT#298, orama#239, PT#314; treat ~5x undocumented silent clobbers as likely. PR_BODY_GUARD_STRICT=1 blocks publish until PR_BODY_UPDATE_ACK=1.  <!-- status=accepted confidence=0.9 evidence=1 id=lesson_a8f3c2e91d04 -->
+- When resolving real overlap between a new draft and an existing, more comprehensive doctrine, "avoid duplication" does not automatically mean "make the newer, simpler thing subordinate to the older, more complex one." It means determining which document actually serves which situation and sizing each to its own job. A heavyweight protocol built for a rare, hard problem (e.g. concurrent multi-agent edits to the same repo, or reconciling a fork separated from its source by months of drift) should not become the default an agent reads first for the common, simple case (one branch, one agent, no concurrent editing) just because it existed first and is more thorough. Getting this backwards is not caught by re-reading a project's own stated single-source-of-truth value, since that value is genuinely being honored in some sense (no literal duplication) even while the sizing is wrong -- it may require direct correction from a human collaborator who can see the actual audience mismatch.  <!-- status=accepted confidence=0.6 evidence=1 id=lesson_718c9430f44b -->
+- Several tooling and API gotchas recur across a working session even after being individually caught once, because a single encounter doesn't automatically generalize into a standing rule: the PR-list API's merged field being unreliable (must check the single-PR endpoint); squash-merged branches never showing as git ancestors (verify by content/ID presence, not ancestry); a stale local checkout after an earlier push in the same session diverging silently; and diff-scoped CI lint checking a whole touched file, not just the changed hunk. Each of these needs to be treated as a standing checklist item to consult before the relevant operation, not a one-off lesson learned and then re-derived from scratch the next time it's encountered.  <!-- status=accepted confidence=0.6 evidence=1 id=lesson_2d53056e593c -->
 
 ### 2026-07