oacp-cli 0.5.0__tar.gz → 0.5.1__tar.gz

{oacp_cli-0.5.0 → oacp_cli-0.5.1}/CHANGELOG.md

@@ -7,6 +7,27 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.5.1] - 2026-09-11
+
+### Added
+
+- Attributed work-clock deductions for multiple excluded intervals, including human-directed time away ([contract](docs/protocol/autonomy.md#threshold-exceeded-checkpoint)).
+- Cancellation receipts that close admitted tasks while preserving partial delivery and pause history ([contract](docs/protocol/autonomy.md#terminal-finalization-and-audit-integrity)).
+- Envelope compilation stamps the enforcement it resolved: `hooks` only when the receiver's adapter is present, `none` with a reason otherwise ([contract](docs/protocol/autonomy.md#enforcement-recording)).
+
+### Changed
+
+- Protocol contract stamp `spec_version` moves to `0.5.1` ([contract version](docs/protocol/autonomy.md#contract-version)).
+- `oacp retention` no longer prunes: the engine is parked outside the kernel and the subcommand prints where it went until its removal in 0.5.3 ([inbox/outbox](docs/protocol/inbox_outbox.md#message-history-retention)).
+- `oacp write-event` execs `agent-memory event write` when the installed tool serves it, falling back to the bundled script until its removal in 0.5.2 ([README](README.md#commands)).
+- The exec path prints `published:`/`idempotent:` where the bundled script prints `OK:` ([README](README.md#commands)).
+- `oacp session-init --pull-memory` is a no-op that names the memory tool's own SessionStart hook, until its removal in 0.5.3 ([codex](docs/protocol/session_init.md#codex)).
+
+### Fixed
+
+- The sync allowlist anchors `.gitignore` and `.oacp-memory-repo` to the home root, matching the memory tool's golden byte for byte ([memory layout](docs/protocol/org_memory.md#the-sync-allowlist)).
+- Preflight's conflict-marker check flags the diff3 `|||||||` base marker ([preflight](scripts/preflight.py)).
+
 ## [0.5.0] - 2026-09-09
 
 ### Added
@@ -868,6 +889,7 @@ The central debrief store is the headline change: every agent's full end-of-sess
 - Checkout step in github-release workflow job (#19)
 - Pre-release audit fixes: SHA-pinned actions, dangling doc refs (#15, #16)
 
+[0.5.1]: https://github.com/kiloloop/oacp/compare/v0.5.0...v0.5.1
 [0.5.0]: https://github.com/kiloloop/oacp/compare/v0.4.6...v0.5.0
 [0.4.6]: https://github.com/kiloloop/oacp/compare/v0.4.5...v0.4.6
 [0.4.5]: https://github.com/kiloloop/oacp/compare/v0.4.4...v0.4.5

{oacp_cli-0.5.0 → oacp_cli-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: oacp-cli
-Version: 0.5.0
+Version: 0.5.1
 Summary: Open Agent Coordination Protocol CLI for file-based multi-agent workflows
 Project-URL: Homepage, https://github.com/kiloloop/oacp
 Project-URL: Repository, https://github.com/kiloloop/oacp
@@ -21,7 +21,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.9.2
-Requires-Dist: pyyaml>=6.0
+Requires-Dist: pyyaml>=6.0.1
 Provides-Extra: crypto
 Requires-Dist: cryptography>=50.0.0; extra == 'crypto'
 Description-Content-Type: text/markdown
@@ -261,7 +261,7 @@ uv tool install .
 | `oacp agent` | Manage global agent profiles (init, sync, show, list) |
 | `oacp inbox` | List pending inbox messages |
 | `oacp watch` | Emit inbox delta events for Monitor-friendly polling |
-| `oacp retention` | Prune project message history by age and count |
+| `oacp retention` | Parked: engine archived outside the kernel; advisory shim until 0.5.3 |
 | `oacp memory` | Run agent-memory (sync, archive, restore); shim until 0.5.2 |
 | `oacp session-init` | Verify Codex startup inputs and emit SessionStart context |
 | `oacp setup` | Generate runtime-specific config files in a repo |

{oacp_cli-0.5.0 → oacp_cli-0.5.1}/README.md

@@ -233,7 +233,7 @@ uv tool install .
 | `oacp agent` | Manage global agent profiles (init, sync, show, list) |
 | `oacp inbox` | List pending inbox messages |
 | `oacp watch` | Emit inbox delta events for Monitor-friendly polling |
-| `oacp retention` | Prune project message history by age and count |
+| `oacp retention` | Parked: engine archived outside the kernel; advisory shim until 0.5.3 |
 | `oacp memory` | Run agent-memory (sync, archive, restore); shim until 0.5.2 |
 | `oacp session-init` | Verify Codex startup inputs and emit SessionStart context |
 | `oacp setup` | Generate runtime-specific config files in a repo |

{oacp_cli-0.5.0 → oacp_cli-0.5.1}/docs/protocol/autonomy.md

@@ -322,7 +322,7 @@ Every autonomy decision writes one YAML file:
 
 ```yaml
 schema_version: 2
-spec_version: "0.4.5"
+spec_version: "0.5.1"
 created_at_utc: "2026-05-12T13:23:25Z"
 receiver: codex
 sender: iris
@@ -470,6 +470,10 @@ terminal finalization. Records, envelopes, and workspaces written between the
 0.4.4 release (2026-08-28) and the 0.4.5 release are therefore stamped
 `0.4.3` under a contract that had already moved — readers tolerate that
 stamp on artifacts dated in the window and read them by the 0.4.5 shape.
+The 0.5.1 contract adds cancellation receipts and attributed clock adjustments. Existing records keep their
+original stamp; new cancellation fixtures use 0.5.1. Schema version remains 2
+because the record container is unchanged; readers must recognize the new
+terminal vocabulary before consuming 0.5.1 receipts.
 
 `evaluator` is **gate-emitted, not receiver-composed**: the evaluator
 self-stamps its provenance into every decision it returns, and receivers
@@ -823,7 +827,7 @@ in place with `--replace`.
 
 **Run-state vocabulary.** `result.final_state` splits by lifecycle phase:
 `pending`, `paused`, and `blocked` are live states; `done`, `superseded`,
-and `error` are terminal. Only terminal states can be finalized.
+`error`, and `cancelled` are terminal. Only terminal states can be finalized.
 `pending` is receiver-written (an admission record picked up for
 execution) — the evaluator itself never writes it.
 
@@ -857,11 +861,38 @@ actuals, whichever receiver writes it. Within the envelope, the
 checkpoint records `within_declared_envelope` (or
 `continued_with_grant`) and the terminal write proceeds; a breach leaves
 the record checkpoint-paused (exit code 4) and the §E re-authorization
-flow applies before any terminal state can be written. Realized effects
+flow applies before successful completion can be written. Cancellation
+closes the task without resuming or erasing a breached checkpoint. Realized effects
 use the canonical axis names only: `actual_minutes`,
 `actual_files_touched`, `side_effects_actual.<capability>`, and
 `task_profile.<field>` for declared-intent corrections.
 
+**Cancellation.** Use `cancelled` when the human or sender stops an admitted
+task; use `superseded` when a replacement evaluation inherits its authority.
+`oacp autonomy-finalize <record> --final-state cancelled --cancelled-by human
+--cancelled-at <UTC>` writes `result.cancelled_by` (`human` or `sender`),
+`cancelled_at_utc` (equal to `completed_at_utc`), optional `reason` (`--reason`),
+and `deliverables_landed` (a list of PR/commit reference strings, supplied with
+repeatable `--deliverable-landed`; empty when none landed). Cancellation must
+follow admission approval and any work start. It requires non-negative integer
+`actual_minutes` and `actual_files_touched`; existing work-start and pause stamps
+remain binding. Before work begins, no start is invented: both actuals are zero
+and the landed list is empty.
+
+Cancellation accepts live `pending`/`paused`/`blocked` records and the provisional
+`done` shape emitted at auto-admission (no completion stamp). A paused admission
+must have a recorded `approved`/`modified` human outcome. Completed `done`,
+`error`, `superseded`, and `cancelled` records refuse cancellation even with
+`--replace`. Cancelled history cannot be reopened by a checkpoint, another
+outcome, or a done/error correction; linked supersession remains available.
+Cancellation preserves the admission and any unresolved checkpoint evidence,
+including its historical `paused_for_reauthorization` action, but does not
+require an implementation-success checkpoint or manufacture resumed authority.
+Cancellation accepts only clock/count actuals (including `clock_adjustments`): record effects, risks, and
+re-authorization through a checkpoint while still live before cancelling.
+Unsupported actuals are refused rather than silently discarded. The cancelled
+lifecycle is closed for doctor and envelope clear.
+
 **Evaluation identity and supersession.** Every persisted evaluation
 carries an `evaluation_id` derived from receiver, message id, message
 bytes, and evaluation time. Re-evaluating a message the evaluator
@@ -1047,7 +1078,55 @@ completion or the current checkpoint, rounded up to a whole minute, excluding
 each represented re-authorization pause from `paused_at_utc` through
 `cleared_paused_at_utc`. If a terminal outcome leaves that pause uncleared,
 active work ends at `paused_at_utc`; the subsequent paused wait does not count.
-The current record shape represents at most its current pause interval.
+The scalar pair keeps its original meaning. Explicit human-directed exclusions
+are carried separately in `result.clock_adjustments`, including deductions that
+were never checkpoint pauses. Supply additions through `--actuals <yaml>`:
+
+```yaml
+actual_files_touched: 2
+completed_at_utc: "2026-08-01T02:00:00Z"
+clock_adjustments:
+  - from_utc: "2026-08-01T01:30:00Z"
+    to_utc: "2026-08-01T01:45:00Z"
+    actor: alice
+    decided_at_utc: "2026-08-01T02:00:00Z"
+    reason: "Human directed exclusion for time away"
+```
+
+Each closed interval requires exactly these five input fields; the finalizer
+adds `recorded_at_utc` as writer provenance. The actor is a stable nonempty
+handle, the reason is nonempty, and all timestamps use `YYYY-MM-DDTHH:MM:SSZ`.
+The interval starts at or after work start and finishes after its start, no
+later than recording and the measurement/completion endpoint. The decision
+cannot postdate recording. Duration is derived from the interval, so no
+independently editable minutes field can disagree with it. Only explicit human
+direction authorizes a deduction; an adjustment neither grants scope nor
+resumes a checkpoint.
+
+Additions append to recorded evidence; omission or an empty list preserves it,
+and identical entries are idempotent. A supplied writer timestamp for a new
+entry is refused; only an exact replay may carry its existing writer stamp.
+Rewriting a stored timestamp is refused. Corrections that remove or rewrite history use linked supersession.
+The list survives checkpoints and metadata-only `--replace`. These rules
+apply to direct library calls as well as the CLI and to cancellation after
+work has begun.
+
+Arithmetic uses the union of the scalar pause and explicit intervals. Sort and
+merge overlapping or adjacent intervals, subtract their total seconds from
+elapsed seconds, then round active minutes up once. Every excluded second
+counts once, including a pause also recorded explicitly before a later
+checkpoint replaces the scalar pair. A malformed scalar remains invalid even
+when an explicit list exists. Existing scalar-only receipts keep their original
+behavior; absent adjustments mean no extra deduction. Read-back validates list
+shape and provenance even on live records without numeric actuals, and terminal
+actuals retain the one-minute `actual_minutes_inconsistent` tolerance.
+Live read-back does not bound `recorded_at_utc` against the reading wall clock;
+finalization rejects intervals beyond its measurement/completion endpoint.
+
+For `--final-state done --replace`, automatic scalar-pause derivation reads the
+stored checkpoint first. When also changing that scalar pause through actuals,
+supply explicit `actual_minutes`; the final read-back still checks the resulting
+clock. Newly supplied explicit adjustments participate in derivation immediately.
 Admission-to-start idle time never counts; time waiting on a peer reviewer does
 count because it is part of that task's review loop. Serialized tasks admitted
 together therefore stamp and measure their own starts independently.
@@ -1335,9 +1414,14 @@ and then human-approved), the receiver compiles the profile plus its own
 autonomy config into a runtime envelope:
 
 ```
-oacp envelope compile <message.yaml> --receiver <agent>
+oacp envelope compile <message.yaml> --receiver <agent> \
+  [--audit <admission-record.yaml>]
 ```
 
+With `--audit`, the compiler also stamps the admission record with the
+enforcement state it compiled (see Enforcement recording below); the
+record and the envelope then tell one story.
+
 **Admitted public-visibility tasks are the one explicit exception.** A
 compiled `public_visibility: true` envelope denies the entire chain the
 human just approved — the runtime adapter has no post-approval carve-out —
@@ -1385,7 +1469,7 @@ The envelope is written to
 ```json
 {
   "envelope_version": 1,
-  "spec_version": "0.4.5",
+  "spec_version": "0.5.1",
   "compiler": "envelope_compiler.py",
   "compiled_at_utc": "2026-07-12T02:00:00Z",
   "project": "my-project",
@@ -1412,10 +1496,19 @@ The envelope is written to
   },
   "counters": {"files_touched": []},
   "enforcement": "hooks",
+  "adapter": {
+    "runtime": "claude",
+    "state": "resolved",
+    "console": "oacp-envelope-hook",
+    "detail": "console script 'oacp-envelope-hook' on PATH at …; registered as a PreToolUse hook"
+  },
   "session_id": "sess-…"
 }
 ```
 
+`enforcement_reason` appears beside `enforcement` exactly when it is
+`none`, naming the adapter state (below).
+
 Compilation rules:
 
 - **Fail closed.** A missing, unparsable, or invalid profile — or a malformed
@@ -1427,6 +1520,33 @@ Compilation rules:
   runtime enforcement never trusts sender declarations alone.
 - Granular side-effect fields absent from a legacy profile compile to
   `false`. `counters` are runtime state and always start empty.
+- **Adapter detection.** `enforcement` is earned, not assumed. The
+  compiler resolves the receiver's runtime from its agent card
+  (`agents/<receiver>/agent_card.yaml` → `runtime:`) and detects that
+  runtime's envelope adapter **by console name, never by module path**,
+  so the adapter can move between distributions without touching the
+  compiler. Every compile stamps exactly one of four `adapter.state`
+  values: `resolved` → `enforcement: hooks`; `unsupported`,
+  `expected_missing`, or `failed` → `enforcement: none` plus
+  `enforcement_reason` naming the state (`adapter_unsupported`,
+  `adapter_expected_missing`, `adapter_detection_failed`). Detection
+  inputs, per runtime:
+  - `claude` — the `oacp-envelope-hook` console script resolves on
+    PATH **and** is registered as a `PreToolUse` hook command in the
+    project repo's `.claude/settings.json` (the registration
+    `oacp setup claude` writes, reached through the workspace marker's
+    `repo_path`). Both present → `resolved`; either absent →
+    `expected_missing`; a workspace marker or settings file that cannot
+    be read → `failed`.
+  - `codex`, `cursor`, `gemini`, `human` — no envelope adapter by
+    design → `unsupported`.
+  - `unknown`, a missing or unreadable card, or a value outside the
+    card's runtime enum → `failed`.
+
+  `expected_missing` and `failed` are loud: the compiler prints a stderr
+  advisory naming the reason. The compile still succeeds (exit 0) and the
+  envelope is still written — degradation is named, never silent, and
+  never fail-closed here.
 - **Session binding.** The envelope records which harness session it
   belongs to. The runtime hook — the only party that sees the harness
   session id (it is not present in the command environment) — records a
@@ -1581,7 +1701,7 @@ the active envelope — `message_id` and `receiver` fields in the record
 itself; filenames are never trusted, and the envelope's message id (pinned
 to a safe-id grammar at compile time) never reaches a filesystem glob:
 
-- `result.final_state: done | error` — the lifecycle is over; the clear is
+- `result.final_state: done | error | cancelled` — the lifecycle is over; the clear is
   allowed and the enforcement window closes from inside the session.
 - `pending` or `paused` (or no matching record at all) — the clear is
   denied: an open task keeps its envelope, and a checkpoint-paused task
@@ -1625,15 +1745,26 @@ grants nothing durable. The envelope itself stays immutable; only `scope`
 
 ### Enforcement recording
 
-The audit `result` block records `envelope_enforcement: hooks | none`.
-Receivers set `hooks` after a successful compile on an adapter-equipped
-runtime; `none` means pickup-gate-only enforcement. Degradation must never
-be silent: when `none` is a **rule** rather than a runtime gap, the record
-carries the named reason alongside it —
-`envelope_enforcement_reason: public_visibility_admission_approved` for
-the admitted-public branch above, stamped by the compiler itself. A bare
-`none` with no reason means an adapterless runtime (the historical
-pickup-gate-only state), distinguishable from the rule-based mode.
+The audit `result` block records `envelope_enforcement: hooks | none`,
+and it tells the same story as the envelope. The admission gate writes
+`none` at admission. A compile run with `--audit <admission-record>`
+stamps the record with the detected adapter state — under the audit
+lock, in one locked read, on a record carrying a `schema_version` and
+content-matched on `message_id` + `receiver` + `message_sha256` (an
+unbound record is left untouched and the compile warns): `hooks` for a
+`resolved` adapter, with no reason; otherwise `none` plus
+`envelope_enforcement_reason` naming the state —
+`adapter_unsupported` (a runtime with no adapter by design, `codex`
+today), `adapter_expected_missing` (an adapter-capable runtime whose
+console or registration did not resolve), or
+`adapter_detection_failed` (the runtime or a probe could not be
+determined). Degradation must never be silent: `none` always carries
+its reason — `public_visibility_admission_approved` for the
+admitted-public branch above, one of the adapter reasons for a compiled
+envelope — and `none` means pickup-gate-only enforcement whatever the
+reason. A record still reading a bare `none` after pickup establishes
+only that no compiler stamp was recorded — the compile ran without
+`--audit`, or never ran — never that the runtime is adapterless.
 
 Enforcement boundary: hooks constrain every tool call inside the session,
 including subagent tool calls, and fire before sandbox/permission
@@ -1838,6 +1969,7 @@ Audit `result.final_state` is limited to:
 - `done` (terminal)
 - `superseded` (terminal; see "Terminal finalization and audit integrity")
 - `error` (terminal)
+- `cancelled` (terminal; admitted task stopped by the human or sender)
 
 `result.completion_kind` is separately pinned to the evaluation-shape enum
 above (see "Pinned completion_kind taxonomy"). Missing-profile messages that

{oacp_cli-0.5.0 → oacp_cli-0.5.1}/docs/protocol/inbox_outbox.md

@@ -327,41 +327,21 @@ replacement is a retained error, never permission to overwrite history.
 
 ## Message History Retention
 
-`oacp retention <project>` applies one non-recursive pass across every visible
-agent's `outbox/`, `dead_letter/`, and `inbox/archive/`. A direct regular file is
-eligible when it is older than `max_age_days` **or** falls outside the newest
-`max_count` files. Age uses filesystem mtime. Hidden entries, metadata markers,
-directories, and symlinks are ignored, and each candidate's identity is
-rechecked immediately before unlinking.
-
-The protocol defaults for all three targets are 30 days and 1,000 files per
-agent. Projects may deep-override either dimension in `workspace.json`; `null`
-disables that dimension, omitted targets or keys inherit the defaults, and
-values otherwise must be positive integers:
-
-```json
-{
-  "retention": {
-    "outbox": {"max_age_days": 30, "max_count": 1000},
-    "dead_letter": {"max_age_days": 30, "max_count": 1000},
-    "inbox_archive": {"max_age_days": 30, "max_count": 1000}
-  }
-}
-```
-
-Run `oacp retention <project> --dry-run --json` before an interactive cleanup;
-omit `--dry-run` to apply the exact reported policy.
-
-Quarantine evidence is outside automatic retention by construction. Files
-written by the intake quarantine format
-`<original>.<sha256-prefix>.<UTC-stamp>[.<counter>]` never count toward age or
-count pruning. A manually managed dead-letter fixture can opt into the same
-protection with an adjacent empty `<filename>.retain` marker. Retention never
-parses dead-letter contents and never bulk-cleans protected evidence.
-
-Dispatcher cleanup archives completed inbound dispatch traffic under the same
-rule. Intermediate WIP/ack notifications are ordinary archived messages and
-expire through `inbox_archive` retention rather than runtime-specific deletion.
+Pruning `outbox/`, `dead_letter/`, and `inbox/archive/` is an operator concern
+outside the kernel. Two invariants bind whatever does it, both scoped to
+`dead_letter/`: quarantine evidence written there by intake
+(`<original>.<sha256-prefix>.<UTC-stamp>[.<counter>]`) is outside automatic
+retention by construction, and a manually managed dead-letter file opts into
+the same protection with an adjacent empty `<filename>.retain` marker.
+Retention never parses dead-letter contents and never touches protected
+evidence.
+
+The reference engine (`<project> --dry-run --json`, workspace `retention`
+override) is parked, unwired to any runtime, at
+`shared/archive/oacp-retention/` in the agent-skills repository; `oacp
+retention` only points there until its removal in 0.5.3. Dispatcher cleanup
+archives completed inbound dispatch traffic like any other message, and
+intermediate WIP/ack notifications are ordinary archived messages.
 
 ## Conversation Threading
 

{oacp_cli-0.5.0 → oacp_cli-0.5.1}/docs/protocol/org_memory.md

@@ -396,8 +396,8 @@ verbatim. Syncing is opt-in, so scaffolding a home never creates the marker.
 ```gitignore
 *
 !*/
-!.gitignore
-!.oacp-memory-repo
+!/.gitignore
+!/.oacp-memory-repo
 !org-memory/**
 !projects/*/memory/**
 projects/*/memory/.cache/
@@ -409,7 +409,9 @@ Line by line:
 
 - **Deny everything, then re-allow directories** (`*`, `!*/`) so the tier
   patterns below can reach into the tree.
-- **The synced set** is the ignore file itself, the marker, `org-memory/**`
+- **The synced set** is the ignore file and the marker at the home root
+  (anchored: the two explicit name exceptions apply there only, and a deeper
+  file of either name follows the ordinary tier rules below), `org-memory/**`
   in full (the debrief store included), and `projects/*/memory/**` for every
   project.
 - **`projects/*/memory/.cache/` never syncs** — the one excluded subtree
@@ -424,7 +426,9 @@ Line by line:
 The allowlist is also a predicate over home-relative paths, and the predicate,
 not the ignore file, is what a sync engine trusts:
 
-- `.gitignore` and `.oacp-memory-repo` are allowed.
+- `.gitignore` and `.oacp-memory-repo` at the home root are allowed by name.
+  A deeper file of either name is admitted only when the tier rules below
+  admit it (`org-memory/.gitignore` is; `other/.gitignore` is not).
 - A path with any component named `keys` is denied, at any depth, whatever
   the ignore file says.
 - A path strictly inside a tier directory (`org-memory/…`,

{oacp_cli-0.5.0 → oacp_cli-0.5.1}/docs/protocol/session_init.md

@@ -193,8 +193,10 @@ Use this manual fallback when the project hook is unavailable or untrusted:
 oacp session-init --project <project>
 ```
 
-`--pull-memory` runs `agent-memory pull --home <hub_dir>` first when the tool is
-on PATH and reports the pull as `disabled` with the install hint when it is not.
+`--pull-memory` is retired: the flag is accepted as a no-op with a one-line note
+on stderr so a hook generated by an earlier kernel keeps starting, and is removed
+in 0.5.3. The memory pull is the memory tool's own SessionStart hook, installed
+by `agent-memory setup codex`.
 
 The script emits a deterministic acknowledgement payload suitable for first-response confirmation:
 

{oacp_cli-0.5.0 → oacp_cli-0.5.1}/oacp/cli.py

@@ -10,6 +10,7 @@ import os
 from pathlib import Path
 import runpy
 import shutil
+import subprocess
 import sys
 from typing import Dict, List, Optional, Sequence
 
@@ -26,7 +27,7 @@ Commands:
   agent          Manage global agent profiles (init, sync, show, list)
   inbox          List pending inbox messages
   watch          Emit inbox delta events for Monitor-friendly polling
-  retention      Prune project message history by age and count
+  retention      Parked: engine archived outside the kernel; advisory shim until 0.5.3
   memory         Run agent-memory (sync, archive, restore); shim until 0.5.2
   session-init   Verify Codex startup inputs and emit SessionStart context
   setup          Generate runtime-specific config files in a repo
@@ -48,7 +49,6 @@ Examples:
   oacp add-agent my-project alice --runtime claude
   oacp inbox my-project --agent claude
   oacp watch --agent claude --project my-project --json
-  oacp retention my-project --dry-run
   oacp memory archive my-project research_notes.md   # runs: agent-memory archive ...
   oacp session-init --project my-project
   oacp setup claude --project my-project
@@ -73,7 +73,6 @@ SCRIPT_NAMES = {
     "agent": "agent_profile.py",
     "inbox": "oacp_inbox.py",
     "watch": "oacp_watch.py",
-    "retention": "retention.py",
     "session-init": "codex_session_init.py",
     "setup": "setup_runtime.py",
     "send": "send_inbox_message.py",
@@ -136,6 +135,31 @@ DELEGATED_COMMANDS: Dict[str, Sequence[str]] = {
 _DELEGATED_VERBS: Dict[str, Dict[str, str]] = {"memory": {"init": "enable"}}
 _HOME_FLAG, _LEGACY_HOME_FLAG = "--home", "--oacp-dir"
 
+# `oacp write-event` execs `agent-memory event write` when the tool on PATH
+# serves the verb (agent-memory 0.1.1+) and runs the bundled script when the
+# tool is absent or predates it. argv passes through with the same rewrite as
+# the delegated verbs; the exec translates no output, so the verb's
+# `published:` / `idempotent: <path>` line stands where the script printed
+# `OK: <path>`, and its dry-run preview lands on stderr. This shim lasts
+# through 0.5.1 and is removed in 0.5.2.
+SHIMMED_COMMANDS: Dict[str, Sequence[str]] = {"write-event": ("event", "write")}
+VERB_PROBE_TIMEOUT_SECONDS = 10
+
+# `oacp retention` left the kernel in 0.5.1. The engine is parked, unwired to
+# any runtime, at `shared/archive/oacp-retention/retention.py` in the
+# agent-skills repository; the subcommand only says so and prunes nothing.
+# This shim lasts through 0.5.2 and is removed in 0.5.3.
+PARKED_COMMANDS: Dict[str, str] = {
+    "retention": (
+        "`oacp retention` is parked: the engine left the kernel in 0.5.1 and is "
+        "archived, unwired to any runtime, at shared/archive/oacp-retention/"
+        "retention.py in the agent-skills repository. Run it directly:\n"
+        "  python3 <agent-skills>/shared/archive/oacp-retention/retention.py "
+        "<project> --dry-run --json\n"
+        "Nothing was pruned. This shim is removed in 0.5.3."
+    ),
+}
+
 
 def delegated_argv(command: str, argv: Sequence[str]) -> List[str]:
     """Return the `agent-memory` argv for an `oacp <command> <argv>` call."""
@@ -151,7 +175,8 @@ def delegated_argv(command: str, argv: Sequence[str]) -> List[str]:
             rewritten.append(_HOME_FLAG + arg[len(_LEGACY_HOME_FLAG) :])
         else:
             rewritten.append(arg)
-    return [MEMORY_TOOL, *DELEGATED_COMMANDS[command], *rewritten]
+    verb = DELEGATED_COMMANDS[command] if command in DELEGATED_COMMANDS else SHIMMED_COMMANDS[command]
+    return [MEMORY_TOOL, *verb, *rewritten]
 
 
 def _delegate(command: str, argv: Sequence[str]) -> int:
@@ -163,15 +188,49 @@ def _delegate(command: str, argv: Sequence[str]) -> int:
             file=sys.stderr,
         )
         return 127
+    return _exec_memory_tool(tool, command, argv)
+
+
+def _exec_memory_tool(tool: str, command: str, argv: Sequence[str]) -> int:
     sys.stdout.flush()
     sys.stderr.flush()
     os.execvp(tool, delegated_argv(command, argv))
     return 0  # pragma: no cover - execvp does not return
 
 
+def _tool_serves(tool: str, verb: Sequence[str]) -> bool:
+    """Whether the memory tool at `tool` serves `verb`: its `--help` exits 0."""
+    try:
+        completed = subprocess.run(
+            [tool, *verb, "--help"],
+            capture_output=True,
+            timeout=VERB_PROBE_TIMEOUT_SECONDS,
+            check=False,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return False
+    return completed.returncode == 0
+
+
+def _shim(command: str, argv: Sequence[str]) -> int:
+    tool = shutil.which(MEMORY_TOOL)
+    if tool is None or not _tool_serves(tool, SHIMMED_COMMANDS[command]):
+        return _run_script(SCRIPT_NAMES[command], argv)
+    return _exec_memory_tool(tool, command, argv)
+
+
+def _parked(command: str) -> int:
+    print(f"ERROR: {PARKED_COMMANDS[command]}", file=sys.stderr)
+    return 2
+
+
 def _dispatch(command: str, argv: Sequence[str]) -> int:
+    if command in PARKED_COMMANDS:
+        return _parked(command)
     if command in DELEGATED_COMMANDS:
         return _delegate(command, argv)
+    if command in SHIMMED_COMMANDS:
+        return _shim(command, argv)
     script_name = SCRIPT_NAMES.get(command)
     if script_name is None:
         print(f"ERROR: unknown command '{command}'", file=sys.stderr)

{oacp_cli-0.5.0 → oacp_cli-0.5.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "oacp-cli"
-version = "0.5.0"
+version = "0.5.1"
 description = "Open Agent Coordination Protocol CLI for file-based multi-agent workflows"
 readme = "README.md"
 license = "Apache-2.0"
@@ -14,7 +14,7 @@ authors = [
   { name = "Kiloloop" },
 ]
 dependencies = [
-  "PyYAML>=6.0",
+  "PyYAML>=6.0.1",
 ]
 keywords = ["agents", "cli", "coordination", "oacp", "workflow"]
 classifiers = [
@@ -50,7 +50,7 @@ dev = [
   "build==1.5.0",
   "hatchling==1.27.0",
   "pytest==9.1.1",
-  "ruff==0.16.2",
+  "ruff==0.16.6",
 ]
 
 [tool.hatch.build.targets.sdist]
@@ -86,7 +86,6 @@ packages = ["oacp"]
 "scripts/agent_profile.py" = "oacp/_scripts/agent_profile.py"
 "scripts/oacp_inbox.py" = "oacp/_scripts/oacp_inbox.py"
 "scripts/oacp_watch.py" = "oacp/_scripts/oacp_watch.py"
-"scripts/retention.py" = "oacp/_scripts/retention.py"
 "scripts/setup_runtime.py" = "oacp/_scripts/setup_runtime.py"
 "scripts/write_event.py" = "oacp/_scripts/write_event.py"
 "scripts/check_quality_gate.py" = "oacp/_scripts/check_quality_gate.py"

{oacp_cli-0.5.0 → oacp_cli-0.5.1}/scripts/_oacp_constants.py

@@ -17,7 +17,7 @@ REPO_SLUG_RE = re.compile(r"^[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+$")
 # names the contract it was produced under. Moves only under the
 # contract-version rule (docs/protocol/autonomy.md, "Contract version");
 # the spec's own literals must agree (tests/test_spec_version.py).
-SPEC_VERSION = "0.4.5"
+SPEC_VERSION = "0.5.1"
 CREATABLE_RUNTIMES = ("claude", "codex", "cursor", "gemini")
 ALL_RUNTIMES = ("claude", "codex", "cursor", "gemini", "human", "unknown")
 CODEX_SESSION_START_CONTEXT_LIMIT = 2_500

{oacp_cli-0.5.0 → oacp_cli-0.5.1}/scripts/autonomy_gate.py

@@ -113,7 +113,7 @@ DECLARED_RISK_REASONS = (
     ("public_visibility", "public_visibility_pause"),
 )
 
-FINAL_STATES = {"done", "paused", "blocked", "superseded", "error"}
+FINAL_STATES = {"done", "paused", "blocked", "superseded", "error", "cancelled"}
 # `result.completion_kind` names the terminal shape of the EVALUATION only —
 # one axis, enumerated. The pause cause lives in `reason_codes` (already
 # pinned), the run state in `result.final_state`, and human decisions in

{oacp_cli-0.5.0 → oacp_cli-0.5.1}/scripts/claude_envelope_hook.py

@@ -135,7 +135,7 @@ OACP_ALWAYS_ALLOWED = {"send", "inbox", "validate", "doctor", "watch", "help", "
 # `result.final_state` values that mark the task lifecycle over. `paused`
 # is deliberately absent: a checkpoint-paused task keeps its envelope and
 # re-authorizes via the §E flow (recompile with --extend), never via clear.
-TERMINAL_AUDIT_STATES = {"done", "error"}
+TERMINAL_AUDIT_STATES = {"done", "error", "cancelled"}
 # Receiver-workspace directories that are protocol bookkeeping, not task
 # scope: audit records, inbox claims, outbox copies. Deliberately NOT the
 # receiver's state/ (the active envelope is the policy object — direct
@@ -1094,7 +1094,7 @@ def _classify_envelope_clear(
             "oacp envelope clear before any audit record matches "
             f"message_id {context.message_id!r} and receiver "
             f"{context.receiver!r}; the completion clear is sanctioned once "
-            "the record's result.final_state is terminal (done/error)"
+            "the record's result.final_state is terminal (done/error/cancelled)"
         )
     record = max(matches, key=lambda item: item[0])[1]
     result = record.get("result")
@@ -1104,7 +1104,7 @@ def _classify_envelope_clear(
     return _deny(
         f"oacp envelope clear while the audit record for "
         f"{context.message_id} shows result.final_state {state!r}; the "
-        "envelope stays active until the task completes (done/error) — a "
+        "envelope stays active until the task completes (done/error/cancelled) — a "
         "paused task re-authorizes via the §E checkpoint, and completion "
         "requires the audit record update first"
     )