pm-brief 2026.10.24 → 2026.10.26

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 2026.10.26 - 2026-10-26
+
+### Added
+
+- Renew only affected handoff obligations after source revisions change ([pm-brief-03r3](https://github.com/unbraind/pm-brief/blob/main/.agents/pm/features/pm-brief-03r3.toon))
+
+## 2026.10.25 - 2026-10-25
+
+### Added
+
+- Render stakeholder briefs through explicit disclosure profiles ([pm-brief-nsks](https://github.com/unbraind/pm-brief/blob/main/.agents/pm/features/pm-brief-nsks.toon))
+
+### Fixed
+
+- Honor SDK blockers, lifecycle roles and UTF-8 brief budgets ([pm-brief-agze](https://github.com/unbraind/pm-brief/blob/main/.agents/pm/tasks/pm-brief-agze.toon))
+
+### Other
+
+- Reconcile stale in-progress tracker records (2026-10-23) ([pm-brief-reconcile-1023](https://github.com/unbraind/pm-brief/blob/main/.agents/pm/chores/pm-brief-reconcile-1023.toon))
+
 ## 2026.10.24 - 2026-10-24
 
 ### Added
@@ -7,6 +27,10 @@
 - Record acknowledged handoff contracts against item revisions ([pm-brief-cjxn](https://github.com/unbraind/pm-brief/blob/main/.agents/pm/features/pm-brief-cjxn.toon))
 - Compare recorded decision alternatives with cited evidence ([pm-brief-ktjl](https://github.com/unbraind/pm-brief/blob/main/.agents/pm/features/pm-brief-ktjl.toon))
 
+### Fixed
+
+- Daily Release workflow is failing ([pm-brief-github-7e06b2eb1b44-170](https://github.com/unbraind/pm-brief/blob/main/.agents/pm/issues/pm-brief-github-7e06b2eb1b44-170.toon))
+
 ### Other
 
 - Verify evidence for tracker reconciliation review ([pm-brief-review165](https://github.com/unbraind/pm-brief/blob/main/.agents/pm/chores/pm-brief-review165.toon))
@@ -28,13 +52,6 @@
 
 - Enable GitHub CodeQL code scanning ([pm-brief-1p5o](https://github.com/unbraind/pm-brief/blob/main/.agents/pm/chores/pm-brief-1p5o.toon))
 
-## 2026.10.21 - 2026-10-21
-
-### Fixed
-
-- Enforce the requested brief budget after the final compaction step ([pm-brief-github-7e06b2eb1b44-135](https://github.com/unbraind/pm-brief/blob/main/.agents/pm/issues/pm-brief-github-7e06b2eb1b44-135.toon))
-- Daily Release workflow is failing ([pm-brief-github-7e06b2eb1b44-84](https://github.com/unbraind/pm-brief/blob/main/.agents/pm/issues/pm-brief-github-7e06b2eb1b44-84.toon))
-
 ## 2026.10.14 - 2026-10-14
 
 ### Added
@@ -53,6 +70,10 @@
 
 - Enforce the chosen rendered brief token ceiling ([pm-brief-k8no](https://github.com/unbraind/pm-brief/blob/main/.agents/pm/features/pm-brief-k8no.toon))
 
+### Fixed
+
+- Enforce the requested brief budget after the final compaction step ([pm-brief-github-7e06b2eb1b44-135](https://github.com/unbraind/pm-brief/blob/main/.agents/pm/issues/pm-brief-github-7e06b2eb1b44-135.toon))
+
 ## 2026.10.5 - 2026-10-05
 
 ### Other
@@ -103,6 +124,7 @@
 
 ### Fixed
 
+- Daily Release workflow is failing ([pm-brief-github-7e06b2eb1b44-84](https://github.com/unbraind/pm-brief/blob/main/.agents/pm/issues/pm-brief-github-7e06b2eb1b44-84.toon))
 - Adopt pm CLI 2026.8.30 and stop pinning which way the SDK handles an incomplete merge receipt ([pm-brief-00tc](https://github.com/unbraind/pm-brief/blob/main/.agents/pm/issues/pm-brief-00tc.toon))
 
 ### Other

package/README.md

@@ -485,7 +485,7 @@ immutable protocol artifacts. Receipts are append-only native comments protected
 by the host's comment lock and author/text idempotency. Native lock contention
 is retried up to three times for reads and idempotent appends; creates are never
 automatically retried. Persistent contention refuses with a retry remedy. Do not edit contract bodies
-or receipt comments. Create a fresh packet after a revision changes. A receipt
+or receipt comments. Use repair/renew after source revisions change; create a fresh packet when the contract obligations change. A receipt
 racing a source edit is reassessed on return and every subsequent read. All source
 metadata, bodies and linked evidence contribute to content revisions, so even an
 unrelated source comment conservatively invalidates old understanding. Reads are
@@ -505,10 +505,92 @@ context delivery/usage receipts and the [since-delta candidate](https://github.c
 (`feat/since-delta-pack`)
 (`pm context-pack since --from <timestamp>` or `--cursor <cursor>`). That candidate
 owns cursor progress, changed-context selection and omission receipts. Use its delta to
-refresh changed context, then create a new handoff here. No history delta engine
+refresh changed context, then repair existing receiver understanding here. No history delta engine
 is duplicated. pm-memory continues to own standing knowledge; `brief prompt`
 continues to generate prose. See the [contract example](docs/examples/handoff.json).
 
+## Handoff repair deltas
+
+`brief handoff repair <packet-id> --receiver <agent>` returns only groups whose
+sources changed since that receiver's last acknowledgment. `--receiver` defaults
+to the active author. Each focus item is one obligation group, scoped to its
+transitive declared blockers. Evidence requirements belong to each focus closure
+that contains their item; evidence outside every focus closure gets its own group.
+The existing contract has no per-question scope, so questions and assumptions
+conservatively apply to every focus group. A shared blocker can affect several
+groups. A 50-row packet with 25 independent focus/dependency pairs returns one
+group when one dependency changes, preserving the other 24 acknowledgments.
+
+```sh
+PM_AUTHOR=receiver-a pm brief handoff repair <packet-id> --json
+PM_AUTHOR=receiver-a pm brief handoff renew <packet-id> --input renewal.json --json
+```
+
+The delta includes changed source coordinates, current obligation text, affected
+native evidence references, missing-link disclosure and exact group targets.
+Unchanged obligations are represented by `validAcknowledgments` and `totalGroups`.
+An empty `groups` array means that receiver has no pending repairs. Evidence link
+presence and receiver understanding retain their separate meanings from `show`.
+Legacy `show` continues to assess the original whole-packet acknowledgment;
+`repair` assesses the receiver's current understanding at group granularity.
+
+Renewal JSON supplies the immutable contract `digest` and a nonempty `groups`
+array: each row has `id`, `target`, `questions`, `assumptions` and `evidence` maps.
+Answer exactly that group's obligation keys. Partial group selection is supported.
+Targets bind the contract and SDK-read source revisions, including native update
+coordinates, so replaying older content does not renew a newer revision. Unchanged
+groups need no response. Matching retries and a peer's completed renewal return
+current validity without adding a duplicate receipt. Renewals append native comments
+to the existing contract; no contract copies, sources, claims or separate stores
+are written. Foreign or malformed receipt-shaped comments are skipped with an
+indexed reason by repair/renew and never edited or deleted.
+
+Each new acknowledgment stores `dependencies`, an array of per-group snapshots:
+`{ id, items, edges, evidenceLinks }`. Renewals store `items`, `edges` and
+`evidenceLinks` alongside that group's responses and revision target. `items`
+records every covered item id, full SDK-row revision (or null for a missing item),
+status, title and blocker edges. Native edge coordinates (`from`, `to`, `kind`)
+and native evidence-link coordinates (`item`, `kind`, optional `ref`) each carry
+SHA-256 revisions of their complete SDK-read metadata. These inventories come
+from the same certified source read that validates the acknowledgment or renewal.
+
+Repair compares the recorded dependency set plus newly reachable dependencies;
+it never drops an already covered item because today's blocker edge disappeared.
+Coverage identities persist across renewals, including transitive dependencies,
+missing items and evidence outside the current focus closure. For example,
+acknowledge A blocked by B with required evidence on B, remove A's blocker edge,
+and renew A: later edits, link removal or deletion of B still invalidate A's
+understanding. A new blocker can add further evidence obligations to a group.
+Known missing evidence remains distinct from readiness, as in the original
+handoff contract. The 64-item coverage limit and token refusal still apply;
+create a new focused contract when retained coverage outgrows that limit.
+
+Older acknowledgments without explicit inventories remain readable using the
+immutable contract's item snapshots. Older renewal snapshots are conservatively
+combined with prior coverage so they cannot erase previously covered identities.
+New acknowledgments and renewals append the full inventory; stored history is
+never rewritten to manufacture historical metadata. See the recorded-coverage
+regression and independent graph model in `test/handoff-coverage.test.ts`.
+
+The SDK exports `inspectHandoffRepair`, `renewHandoff`, `parseHandoffRenewal` and
+`HandoffRepair`, `HandoffRepairGroup`, `HandoffRepairChange`, `HandoffRenewal`,
+`HandoffRenewalGroup`, `HandoffDependencySet`, `HandoffAcknowledgedGroup`,
+`HandoffCoveredEdge` and `HandoffCoveredEvidence`. Use the existing `HandoffOptions` with `pmRoot`, `author`,
+optional native `client` and `tokenBudget`. Output uses native TOON/JSON and the
+same 4,000-token default ceiling (maximum 64,000). Oversized deltas refuse rather
+than discard obligations. An unacknowledged receiver gets `handoff_unacknowledged`
+and must first acknowledge a fresh contract. Other typed refusals retain the
+existing `HandoffError` codes and actionable remedies; stale renewal exits 3.
+
+Renewal holds an SDK token-owned lease from its initial read through append and
+verification, and uses native `comments({ ifAbsent: true })` for atomic append.
+The SDK releases only its owned lease, last. Arbitrary source writers do not join
+this lease: sources are rechecked after append, and a raced renewal refuses stale;
+its historical comment cannot validate the newer revision. A later edit after the
+final verified read appears on the next repair read. See the
+[complete example](docs/examples/handoff-repair.md) and
+[validation evidence](docs/handoff-repair-validation.md).
+
 ## Decision alternatives digest
 
 ```bash

package/dist/handoff.d.ts

@@ -61,6 +61,7 @@ export interface HandoffReceipt {
     id: string;
     receiver: string;
     response: HandoffResponse;
+    dependencies?: HandoffAcknowledgedGroup[];
     acknowledgedAt: string;
     valid: boolean;
     ready: boolean;
@@ -74,8 +75,73 @@ export interface HandoffStatus {
     receipts: HandoffReceipt[];
     estimatedTokenCeiling: number;
 }
+/** Receiver answers to one group, bound to its exact target source revision. */
+export interface HandoffRenewalGroup {
+    id: string;
+    target: string;
+    questions: Record<string, string>;
+    assumptions: Record<string, string>;
+    evidence: Record<string, string>;
+}
+/** Partial renewal input; only groups shown by repair need responses. */
+export interface HandoffRenewal {
+    digest: string;
+    groups: HandoffRenewalGroup[];
+}
+/** Changed source coordinate relative to the receiver's last acknowledgment. */
+export interface HandoffRepairChange {
+    id: string;
+    from: string | null;
+    to: string | null;
+}
+/** One focused obligation group requiring renewed receiver understanding. */
+export interface HandoffRepairGroup extends HandoffContract {
+    id: string;
+    target: string;
+    changes: HandoffRepairChange[];
+    missingEvidence: string[];
+}
+/** Compact receiver-specific delta; unchanged obligations are counted, never repeated. */
+export interface HandoffRepair {
+    protocol: "pm-brief.repair/v1";
+    id: string;
+    digest: string;
+    receiver: string;
+    groups: HandoffRepairGroup[];
+    validAcknowledgments: number;
+    totalGroups: number;
+    skippedReceipts: {
+        index: number;
+        reason: string;
+    }[];
+    estimatedTokenCeiling: number;
+}
+/** Exact native edge coordinate covered by one acknowledgment, including its metadata revision. */
+export interface HandoffCoveredEdge {
+    from: string;
+    to: string;
+    kind: string;
+    revision: string;
+}
+/** Exact native evidence-link coordinate; revision includes every SDK-read link field. */
+export interface HandoffCoveredEvidence {
+    item: string;
+    kind: "docs" | "files" | "tests";
+    ref?: string;
+    revision: string;
+}
+/** Recorded coverage is retained across graph edits; missing items keep a null revision. */
+export interface HandoffDependencySet {
+    items: HandoffRevision[];
+    edges: HandoffCoveredEdge[];
+    evidenceLinks: HandoffCoveredEvidence[];
+}
+/** One initial acknowledgment's exact per-group dependency set. */
+export interface HandoffAcknowledgedGroup extends HandoffDependencySet {
+    id: string;
+}
 /** Stable refusal categories callers can branch on without parsing prose. */
-export type HandoffRefusalCode = "invalid" | "missing" | "identity" | "stale" | "responses" | "integrity" | "budget" | "tracker";
+export type HandoffRefusalCode = "invalid" | "missing" | "identity" | "stale" | "responses" | "integrity" | "budget" | "tracker" | "unacknowledged";
 /** Expected failure with a concrete recovery action; tracker writes never precede validation. */
 export declare class HandoffError extends Error {
     /** Machine-readable reason for refusing an operation. */
@@ -97,6 +163,12 @@ export declare function createHandoff(input: HandoffContract, options: HandoffOp
 export declare function inspectHandoff(id: string, options: HandoffOptions, receiver?: string): Promise<HandoffStatus>;
 /** Append an idempotent receiver receipt under the native comment lock; concurrent receivers never overwrite. */
 export declare function acknowledgeHandoff(id: string, input: HandoffResponse, options: HandoffOptions): Promise<HandoffStatus>;
+/** Parse revision-bound partial responses without accepting duplicate group keys. */
+export declare function parseHandoffRenewal(value: unknown): HandoffRenewal;
+/** Read a receiver-specific repair delta without writing or repeating unaffected obligations. */
+export declare function inspectHandoffRepair(id: string, options: HandoffOptions, receiver?: string): Promise<HandoffRepair>;
+/** Serialize renewal planning through verification and let native ifAbsent perform the atomic append. */
+export declare function renewHandoff(id: string, input: HandoffRenewal, options: HandoffOptions): Promise<HandoffRepair>;
 /** Register native structured TOON/JSON commands; expected refusals carry code and remedy at nonzero exit. */
 export declare function registerHandoffCommands(api: ExtensionApi): void;
 //# sourceMappingURL=handoff.d.ts.map

package/dist/handoff.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"handoff.d.ts","sourceRoot":"","sources":["../handoff.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"handoff.d.ts","sourceRoot":"","sources":["../handoff.ts"],"names":[],"mappings":"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"}

package/dist/handoff.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { open } from "node:fs/promises";
-import { PmClient, certifyCompleteListResult, createPmCliExpectedError, estimatePmOutputTokens, isPmCliExpectedError } from "@unbrained/pm-cli/sdk";
+import { PmClient, acquireLock, certifyCompleteListResult, createPmCliExpectedError, estimatePmOutputTokens, isPmCliExpectedError } from "@unbrained/pm-cli/sdk";
 /** Expected failure with a concrete recovery action; tracker writes never precede validation. */
 export class HandoffError extends Error {
     /** Machine-readable reason for refusing an operation. */
@@ -17,6 +17,7 @@ export class HandoffError extends Error {
 }
 const PROTOCOL = "pm-brief.handoff/v1";
 const ACK_PREFIX = "pm-brief.ack/v1 ";
+const RENEW_PREFIX = "pm-brief.renew/v1 ";
 const TAG = "pm-brief-handoff";
 const KEY = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
 /** Refuse malformed or excessive agent input without leaking its raw value. */
@@ -241,9 +242,12 @@ function requireResponses(response, contract) {
 }
 /** Read all receipts and recompute validity; receiver filters affect output only, never stored data. */
 export async function inspectHandoff(id, options, receiver) {
+    return handoffStatus(id, await corpus(options), options, receiver);
+}
+/** Assess receipts using the same certified source snapshot used for recording coverage. */
+function handoffStatus(id, items, options, receiver) {
     if (receiver !== undefined)
         key(receiver);
-    const items = await corpus(options);
     const { packet, source } = readPacket(id, items);
     const stale = staleItems(packet, items);
     packet.missingEvidence = missingEvidence(packet.contract, items);
@@ -261,7 +265,8 @@ export async function inspectHandoff(id, options, receiver) {
                 throw new Error();
             if (receiver !== undefined && who !== receiver)
                 continue;
-            receipts.push({ id: digest(raw), receiver: who, response, acknowledgedAt: comment.created_at, valid: stale.length === 0, ready: stale.length === 0 && packet.missingEvidence.length === 0, staleItems: stale, missingEvidence: packet.missingEvidence });
+            const dependencies = readAcknowledgedGroups(raw.dependencies, packet, source);
+            receipts.push({ id: digest(raw), receiver: who, response, ...(dependencies === undefined ? {} : { dependencies }), acknowledgedAt: comment.created_at, valid: stale.length === 0, ready: stale.length === 0 && packet.missingEvidence.length === 0, staleItems: stale, missingEvidence: packet.missingEvidence });
         }
         catch {
             throw new HandoffError("integrity", "A handoff receipt is malformed or belongs to another contract", "Inspect the native packet comments; preserve history and create a fresh packet");
@@ -273,16 +278,18 @@ export async function inspectHandoff(id, options, receiver) {
 export async function acknowledgeHandoff(id, input, options) {
     const receiver = author(options);
     const response = parseHandoffResponse(input);
-    const before = await inspectHandoff(id, options, receiver);
+    const items = await corpus(options);
+    const before = handoffStatus(id, items, options, receiver);
     if (response.digest !== before.packet.digest || before.staleItems.length > 0)
         throw new HandoffError("stale", "The handoff no longer matches the receiver's snapshot", "Create and read a fresh packet, then respond against its digest and current blocker revisions");
     requireResponses(response, before.packet.contract);
     // Reserve the full receipt before mutation so a small budget never leaves an unseen write.
-    const raw = { receiver, response };
+    const dependencies = obligationGroups(before.packet).map(group => ({ id: group.id, ...dependencySet(group, groupItems(group.id, before.packet.contract.items), items) }));
+    const raw = { receiver, response, dependencies };
     const text = ACK_PREFIX + canonical(raw);
     if (before.receipts.some(receipt => receipt.id === digest(raw)))
         return before;
-    bounded({ ...before, receipts: [...before.receipts, { id: digest(raw), receiver, response, acknowledgedAt: new Date().toISOString(), valid: true, ready: before.packet.missingEvidence.length === 0, staleItems: [], missingEvidence: before.packet.missingEvidence }] }, options);
+    bounded({ ...before, receipts: [...before.receipts, { id: digest(raw), receiver, response, dependencies, acknowledgedAt: new Date().toISOString(), valid: true, ready: before.packet.missingEvidence.length === 0, staleItems: [], missingEvidence: before.packet.missingEvidence }] }, options);
     try {
         await retryLocked(() => client(options).comments(id, { add: text, author: receiver, ifAbsent: true }));
     }
@@ -292,6 +299,270 @@ export async function acknowledgeHandoff(id, input, options) {
     // A source edit racing the append is reported stale, never upgraded into a valid receipt.
     return inspectHandoff(id, options, receiver);
 }
+/** Parse revision-bound partial responses without accepting duplicate group keys. */
+export function parseHandoffRenewal(value) {
+    const input = record(value);
+    const digest = parseHandoffResponse({ digest: input.digest, questions: {}, assumptions: {}, evidence: {} }).digest;
+    if (!Array.isArray(input.groups) || input.groups.length < 1 || input.groups.length > 64)
+        return invalid();
+    const groups = input.groups.map(value => {
+        const row = record(value);
+        const response = parseHandoffResponse({ digest: row.target, questions: row.questions, assumptions: row.assumptions, evidence: row.evidence });
+        return { id: key(row.id, Infinity), target: response.digest, questions: response.questions, assumptions: response.assumptions, evidence: response.evidence };
+    });
+    unique(groups.map(group => group.id));
+    return { digest, groups };
+}
+/** Traverse a saved or current blocker graph without introducing another dependency model. */
+function groupItems(root, items) {
+    const pending = [root];
+    const found = new Map();
+    for (const id of pending) {
+        const item = items.find(item => item.id === id);
+        if (!item || found.has(id))
+            continue;
+        found.set(id, item);
+        pending.push(...item.blockers);
+    }
+    return [...found.values()].sort((a, b) => a.id.localeCompare(b.id, "en"));
+}
+/** Bind a group to the immutable contract and full current SDK-read source coordinates. */
+function groupTarget(digestValue, id, items) { return digest({ digest: digestValue, id, items }); }
+/** Partition the existing contract by focus closure; evidence outside every focus gets its own root. */
+function obligationGroups(packet) {
+    const contract = packet.contract;
+    const roots = [...contract.focus];
+    const covered = new Set(roots.flatMap(id => groupItems(id, contract.items).map(row => row.id)));
+    for (const evidence of contract.requiredEvidence)
+        if (!covered.has(evidence.item) && !roots.includes(evidence.item))
+            roots.push(evidence.item);
+    return roots.map(id => {
+        const ids = new Set(groupItems(id, contract.items).map(row => row.id));
+        const focused = contract.focus.includes(id);
+        return { id, focus: [id], questions: focused ? contract.questions : [], assumptions: focused ? contract.assumptions : [], requiredEvidence: contract.requiredEvidence.filter(row => ids.has(row.item)) };
+    });
+}
+/** Read every previously covered identity plus its live blockers and required evidence; never prune on edge removal. */
+function dependencySet(group, recorded, items) {
+    const snapshots = revisions({ ...group, focus: [...new Set([...group.focus, ...recorded.map(row => row.id)])] }, items);
+    const ids = new Set(snapshots.map(row => row.id));
+    const edges = [];
+    const evidenceLinks = [];
+    for (const item of items) {
+        if (!ids.has(item.id))
+            continue;
+        for (const edge of item.dependencies ?? [])
+            edges.push({ from: item.id, to: edge.id, kind: edge.kind, revision: digest(edge) });
+        if (item.blocked_by)
+            edges.push({ from: item.id, to: item.blocked_by, kind: "blocked_by", revision: digest({ blocked_by: item.blocked_by }) });
+        for (const kind of ["docs", "files", "tests"])
+            for (const link of item[kind] ?? [])
+                evidenceLinks.push({ item: item.id, kind, ref: "command" in link && typeof link.command === "string" ? link.command : link.path, revision: digest(link) });
+    }
+    const order = (a, b) => canonical(a).localeCompare(canonical(b), "en");
+    return { items: snapshots, edges: edges.sort(order), evidenceLinks: evidenceLinks.sort(order) };
+}
+/** Decode recorded revisions with the existing immutable artifact validator; old receipts remain readable. */
+function recordedItems(value, packet, source) {
+    const document = { ...packet.contract, items: value };
+    const body = JSON.stringify({ document, digest: digest(document) });
+    return readPacket(packet.id, [{ ...source, body }]).packet.contract.items;
+}
+/** Validate explicit edge/link inventories without manufacturing historical data for legacy receipts. */
+function readInventory(raw, snapshots) {
+    if (raw.edges === undefined && raw.evidenceLinks === undefined)
+        return undefined;
+    if (!Array.isArray(raw.edges) || !Array.isArray(raw.evidenceLinks))
+        return invalid();
+    const ids = new Set(snapshots.map(row => row.id));
+    const hash = (value) => parseHandoffResponse({ digest: value, questions: {}, assumptions: {}, evidence: {} }).digest;
+    const edges = raw.edges.map(value => {
+        const edge = record(value);
+        const from = key(edge.from, Infinity);
+        if (!ids.has(from))
+            return invalid();
+        return { from, to: string(edge.to, Infinity), kind: string(edge.kind, Infinity), revision: hash(edge.revision) };
+    });
+    const evidenceLinks = raw.evidenceLinks.map((value) => {
+        const link = record(value);
+        const item = key(link.item, Infinity);
+        if (!ids.has(item) || (link.kind !== "docs" && link.kind !== "files" && link.kind !== "tests"))
+            return invalid();
+        return { item, kind: link.kind, ref: link.ref === undefined ? undefined : string(link.ref, Infinity), revision: hash(link.revision) };
+    });
+    return { edges, evidenceLinks };
+}
+/** Validate an initial acknowledgment's complete group coverage, allowing older records without inventories. */
+function readAcknowledgedGroups(value, packet, source) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value))
+        return invalid();
+    const groups = obligationGroups(packet);
+    const dependencies = value.map(value => {
+        const row = record(value);
+        const id = key(row.id, Infinity);
+        const items = recordedItems(row.items, packet, source);
+        const inventory = readInventory(row, items);
+        if (!inventory || !groups.some(group => group.id === id))
+            return invalid();
+        return { id, items, ...inventory };
+    });
+    unique(dependencies.map(row => row.id));
+    if (dependencies.length !== groups.length)
+        return invalid();
+    return dependencies;
+}
+/** Preserve all coverage identities while advancing their last recorded revisions after renewal. */
+function previousCoverage(packet, group, initial, records) {
+    const baseline = groupItems(group.id, packet.contract.items);
+    const saved = [baseline, ...initial.filter(row => row.id === group.id).map(row => row.items), ...records.flatMap(row => row.groups).filter(row => row.id === group.id).map(row => row.items)];
+    const byId = new Map();
+    for (const items of saved)
+        for (const item of items)
+            byId.set(item.id, item);
+    return [...byId.values()].sort((a, b) => a.id.localeCompare(b.id, "en"));
+}
+/** Decode only attributable complete protocol records; foreign comments remain untouched and disclosed. */
+function repairReceipts(source, packet, groups, receiver) {
+    let acknowledged = false;
+    const initial = [];
+    const records = [];
+    const skipped = [];
+    for (const [index, comment] of (source.comments ?? []).entries()) {
+        if (!comment.text.startsWith(ACK_PREFIX) && !comment.text.startsWith(RENEW_PREFIX))
+            continue;
+        try {
+            const renewal = comment.text.startsWith(RENEW_PREFIX);
+            const raw = record(JSON.parse(comment.text.slice(renewal ? RENEW_PREFIX.length : ACK_PREFIX.length)));
+            const who = key(raw.receiver);
+            if (who !== comment.author)
+                throw new Error();
+            if (!renewal) {
+                const response = parseHandoffResponse(raw.response);
+                requireResponses(response, packet.contract);
+                if (response.digest !== packet.digest)
+                    throw new Error();
+                const dependencies = readAcknowledgedGroups(raw.dependencies, packet, source);
+                if (who === receiver && !acknowledged) {
+                    initial.push(...(dependencies ?? []));
+                    acknowledged = true;
+                }
+                continue;
+            }
+            const parsed = parseHandoffRenewal(raw);
+            if (parsed.digest !== packet.digest)
+                throw new Error();
+            const persisted = raw.groups.map((value, i) => {
+                const row = record(value);
+                const group = parsed.groups[i];
+                const obligation = groups.find(candidate => candidate.id === group.id);
+                if (!obligation || !Array.isArray(row.items) || row.items.length > 64)
+                    throw new Error();
+                // Reuse the immutable packet decoder for structural and canonical revision validation.
+                const items = recordedItems(row.items, packet, source);
+                const inventory = readInventory(row, items);
+                const covered = new Set(items.map(row => row.id));
+                requireResponses({ digest: packet.digest, ...group }, { ...obligation, requiredEvidence: packet.contract.requiredEvidence.filter(row => covered.has(row.item)) });
+                if (group.target !== groupTarget(packet.digest, group.id, items))
+                    throw new Error();
+                return { ...group, items, ...inventory };
+            });
+            if (who === receiver)
+                records.push({ receiver: who, digest: parsed.digest, groups: persisted });
+        }
+        catch {
+            skipped.push({ index: index + 1, reason: "Foreign or malformed receipt: protocol, attribution, contract or group binding does not match" });
+        }
+    }
+    return { acknowledged, initial, records, skipped };
+}
+/** Compute only pending groups from one certified SDK snapshot, preserving unrelated understanding. */
+function repairSnapshot(id, items, options, receiver) {
+    const { packet, source } = readPacket(id, items);
+    const groups = obligationGroups(packet);
+    const receipts = repairReceipts(source, packet, groups, receiver);
+    if (!receipts.acknowledged)
+        throw new HandoffError("unacknowledged", "Receiver has not acknowledged this contract", "Use handoff ack against a fresh contract first; repair only renews an existing receiver acknowledgment");
+    const current = new Map();
+    const pending = [];
+    for (const group of groups) {
+        const previous = previousCoverage(packet, group, receipts.initial, receipts.records);
+        const coverage = dependencySet(group, previous, items);
+        current.set(group.id, coverage);
+        const targetItems = coverage.items;
+        // Newly reachable evidence requirements become part of this group's existing contract obligations.
+        const covered = new Set(targetItems.map(row => row.id));
+        const requiredEvidence = packet.contract.requiredEvidence.filter(row => covered.has(row.item));
+        const target = groupTarget(packet.digest, group.id, targetItems);
+        if (target === groupTarget(packet.digest, group.id, previous))
+            continue;
+        const ids = [...new Set([...previous, ...targetItems].map(row => row.id))].sort();
+        const changes = ids.filter(id => previous.find(row => row.id === id)?.revision !== targetItems.find(row => row.id === id)?.revision).map(id => ({ id, from: previous.find(row => row.id === id)?.revision ?? null, to: targetItems.find(row => row.id === id)?.revision ?? null }));
+        pending.push({ ...group, requiredEvidence, target, changes, missingEvidence: missingEvidence({ ...group, requiredEvidence }, items) });
+    }
+    const repair = { protocol: "pm-brief.repair/v1", id, digest: packet.digest, receiver, groups: pending, validAcknowledgments: groups.length - pending.length, totalGroups: groups.length, skippedReceipts: receipts.skipped, estimatedTokenCeiling: 0 };
+    return { repair: bounded(repair, options), current };
+}
+/** Read a receiver-specific repair delta without writing or repeating unaffected obligations. */
+export async function inspectHandoffRepair(id, options, receiver = author(options)) {
+    return repairSnapshot(key(id, Infinity), await corpus(options), options, key(receiver)).repair;
+}
+/** Serialize renewal planning through verification and let native ifAbsent perform the atomic append. */
+export async function renewHandoff(id, input, options) {
+    key(id, Infinity);
+    const receiver = author(options);
+    const renewal = parseHandoffRenewal(input);
+    let release;
+    try {
+        release = await acquireLock(options.pmRoot, `brief-renew-${digest(id)}`, 300, receiver, false, true, 1000);
+    }
+    catch {
+        throw new HandoffError("tracker", "Another receiver renewal holds the tracker lease", "Retry after the current writer finishes; inspect pm health if lease contention persists");
+    }
+    try {
+        const items = await corpus(options);
+        const { repair, current } = repairSnapshot(id, items, options, receiver);
+        const { packet, source } = readPacket(id, items);
+        const obligations = obligationGroups(packet);
+        const records = repairReceipts(source, packet, obligations, receiver).records;
+        if (renewal.digest !== repair.digest)
+            throw new HandoffError("stale", "Renewal belongs to an old contract", "Read handoff repair again and answer against its digest and group targets");
+        const storedGroups = renewal.groups.map(group => {
+            const obligation = obligations.find(row => row.id === group.id);
+            const snapshot = current.get(group.id);
+            if (!obligation || !snapshot || group.target !== groupTarget(repair.digest, group.id, snapshot.items))
+                throw new HandoffError("stale", "Renewal targets an old source revision or unknown group", "Read handoff repair again and use its current target for each affected group");
+            const covered = new Set(snapshot.items.map(row => row.id));
+            requireResponses({ digest: repair.digest, ...group }, { ...obligation, requiredEvidence: packet.contract.requiredEvidence.filter(row => covered.has(row.item)) });
+            const pending = repair.groups.some(row => row.id === group.id);
+            const peerSuccess = records.some(record => record.groups.some(row => row.id === group.id && row.target === group.target));
+            if (!pending && !peerSuccess)
+                throw new HandoffError("responses", "Renewal includes an unaffected group", "Answer only groups returned by handoff repair; unchanged acknowledgments remain valid");
+            return { ...group, ...snapshot };
+        });
+        const raw = { receiver, digest: repair.digest, groups: storedGroups };
+        const text = RENEW_PREFIX + canonical(raw);
+        // Check the output with the added receipt before any durable write, including foreign disclosures.
+        repairSnapshot(id, items.map(row => row.id === id ? { ...row, comments: [...(row.comments ?? []), { author: receiver, text, created_at: new Date().toISOString() }] } : row), options, receiver);
+        if (storedGroups.some(group => repair.groups.some(row => row.id === group.id))) {
+            try {
+                await retryLocked(() => client(options).comments(id, { add: text, author: receiver, ifAbsent: true }));
+            }
+            catch {
+                throw new HandoffError("tracker", "Renewal could not be appended", "Retry the same renewal after the current writer finishes; inspect handoff repair and pm health if contention persists");
+            }
+        }
+        const latest = repairSnapshot(id, await corpus(options), options, receiver);
+        const after = latest.repair;
+        if (renewal.groups.some(group => group.target !== groupTarget(after.digest, group.id, latest.current.get(group.id).items)))
+            throw new HandoffError("stale", "Sources changed while renewal was being recorded", "Read handoff repair again; the raced receipt remains historical and cannot validate the new revision");
+        return after;
+    }
+    finally {
+        await release();
+    }
+}
 /** Read a bounded JSON input file; parsing failures give agents a typed remedy. */
 async function inputFile(value) {
     try {
@@ -324,15 +595,19 @@ function commandOptions(ctx) {
 /** Register native structured TOON/JSON commands; expected refusals carry code and remedy at nonzero exit. */
 export function registerHandoffCommands(api) {
     const budget = { long: "--token-budget", type: "string", value_name: "n", description: "Conservative output token ceiling (default 4000, maximum 64000); refuses instead of dropping obligations" };
-    for (const action of ["create", "show", "ack", "preview"]) {
+    for (const action of ["create", "show", "ack", "preview", "repair", "renew"]) {
         api.registerCommand({
             name: `brief handoff ${action}`,
-            description: action === "preview" ? "Preview a revision-bound handoff without writing" : action === "create" ? "Create a revision-bound handoff contract" : action === "ack" ? "Record explicit receiver understanding against a handoff digest" : "Inspect current handoff revisions, evidence gaps and receiver receipts",
-            read_output: action === "show" ? { row_keys: ["receipts"] } : action === "preview" ? { row_keys: ["contract.items"] } : undefined,
-            flags: [budget, ...(action === "show" ? [{ long: "--receiver", type: "string", value_name: "id", description: "Show one receiver without omitting that receiver's receipts" }] : [{ long: "--input", type: "string", value_name: "json-file", description: "Contract JSON for create; explicit response JSON for ack" }])],
+            description: action === "repair" ? "Read only affected obligations for one acknowledged receiver" : action === "renew" ? "Renew affected obligations against exact current source revisions" : action === "preview" ? "Preview a revision-bound handoff without writing" : action === "create" ? "Create a revision-bound handoff contract" : action === "ack" ? "Record explicit receiver understanding against a handoff digest" : "Inspect current handoff revisions, evidence gaps and receiver receipts",
+            read_output: action === "repair" ? { row_keys: ["groups"] } : action === "show" ? { row_keys: ["receipts"] } : action === "preview" ? { row_keys: ["contract.items"] } : undefined,
+            flags: [budget, ...((action === "show" || action === "repair") ? [{ long: "--receiver", type: "string", value_name: "id", description: "Show one receiver without omitting that receiver's receipts" }] : [{ long: "--input", type: "string", value_name: "json-file", description: "Contract JSON for create/preview; response JSON for ack; group renewal JSON for renew" }])],
             async run(ctx) {
                 try {
                     const options = commandOptions(ctx);
+                    if (action === "repair")
+                        return await inspectHandoffRepair(key(ctx.args[0], Infinity), options, ctx.options.receiver === undefined ? author(options) : key(ctx.options.receiver));
+                    if (action === "renew")
+                        return await renewHandoff(key(ctx.args[0], Infinity), parseHandoffRenewal(await inputFile(ctx.options.input)), options);
                     if (action === "preview")
                         return await previewHandoff(parseHandoffContract(await inputFile(ctx.options.input)), options);
                     if (action === "create")