granttap-mcp 0.8.5 → 0.8.7

package/README.md

@@ -55,6 +55,15 @@ Mesh resource. Full transcripts and hidden reasoning are never mesh payloads.
 Claims have TTLs; a colliding claim is rejected before it is recorded so agents
 can choose different work or contact the owner before escalating to Needs You.
 
+<p align="center">
+  <img src="docs/images/iphone-projects-shared.png" width="200" alt="Projects: one owned by this phone, one shared by another">
+  <img src="docs/images/iphone-project-mesh.png" width="200" alt="A Project: Governance, members and computers, Mesh status, repositories, Tasks">
+  <img src="docs/images/iphone-task-route.png" width="200" alt="A Task: its executions, its claims, and who else is in its files">
+  <img src="docs/images/iphone-handoff.png" width="200" alt="Task handoff: destination, push, and readiness checks">
+</p>
+
+<p align="center"><em>Projects, one of them shared by another phone · a Project with its Governance, members, computers, repositories, and Tasks · a Task with its executions and claims · a handoff with its readiness checks</em></p>
+
 For Claude Code, Codex, and Cursor, the provider hook runs inside the agent's
 own session and sees the exact call. GrantTap attributes every `notify` to the
 session that really made it and publishes the event only for that execution —
@@ -124,6 +133,59 @@ of a topic it produces, the caller of an API it changes), and the scoped
 `granttap://mesh/{capability}` resource gives the agent the same `peers`,
 `otherSide`, and `neighbours` so it can coordinate before it commits.
 
+### Members, roles, and computers of their own
+
+A Project is shared from the phone that owns it, and that phone stays the
+hub: nothing a member does reaches a computer without passing through it.
+*Invite a person* makes a one-time code, good for fifteen minutes; the other
+phone scans it under *Projects → Join a Project*, and the Project arrives
+there with the role the owner chose — Viewer, Member, or Admin — and the four
+answers under it: see the Project's chats, write to them, post to the
+Project, edit Governance. Each answer is checked on the owner's phone before
+a message, a pause, a handoff, or a release is forwarded, and a refusal comes
+back to the member's phone as a message of its own, naming the rule. Changing
+a role takes effect at once; removing a member stops the forwarding at once,
+though nothing already seen can be recalled.
+
+<p align="center">
+  <img src="docs/images/iphone-members.png" width="200" alt="Members and computers of a Project, seen by its owner">
+  <img src="docs/images/iphone-invite.png" width="200" alt="Invite a person: name, role, and the four answers under it">
+  <img src="docs/images/iphone-join-project.png" width="200" alt="Join a Project from another phone: scan the invite or paste it">
+  <img src="docs/images/iphone-members-shared.png" width="200" alt="A shared Project on the member's phone, with a computer of their own to add">
+</p>
+
+<p align="center"><em>The owner's members and computers · an invite with its role · joining from another phone · the shared Project as the member sees it, with a computer of their own to add</em></p>
+
+A member works in the Project with computers of their own. Adding one hands
+it the Project's mesh key over the pairing the member's phone already trusts,
+and from then on that computer takes part in the mesh like any other: its
+chats are the Project's, its claims are seen by every other computer, and a
+Task can be handed to it.
+
+### A claim released by the person
+
+A claim outlives an agent that crashed or was closed, and the files it names
+stay fenced off until it expires. Touch and hold a claim on the Task screen
+to release it yourself. The phone tells the computer that holds the claim,
+and the computer answers with a result of its own: released, or refused with
+the reason — no such claim on this computer, a claim that belongs to another
+Project, a role that does not allow it, or no computer to ask. A refusal puts
+the claim back on the phone with that reason beside it, so what the phone
+shows is what the mesh holds. A release is written to the store as a
+tombstone, so a snapshot or a late event from a computer that was away cannot
+bring the claim back.
+
+### Task reports
+
+<p align="center">
+  <img src="docs/images/iphone-report.png" width="200" alt="A Task report: figures first, then every table, as PDF or CSV">
+</p>
+
+A Task is reported from the phone as a PDF to read and forward, or a CSV with
+every table: tokens, tool calls, wrong turns, CPU time, peak memory, and wall
+time, by tool and by execution. Nothing leaves the phone until you choose
+where it goes.
+
 ### Grok Bot as a scoped Mesh participant
 
 Grok Bot is a persistent agent, not a coding-agent integration. The iPhone
@@ -145,6 +207,28 @@ history stays on the device.
 Installation and production use require Authorized Access under the
 [GrantTap Commercial Source License](LICENSE).
 
+Install the GrantTap plugin directly from this repository's marketplace:
+
+```bash
+# Codex
+codex plugin marketplace add sergii-ziborov/granttap-mcp
+codex plugin add granttap@granttap
+
+# Claude Code
+claude plugin marketplace add sergii-ziborov/granttap-mcp
+claude plugin install granttap@granttap
+```
+
+Open GrantTap from the plugin page or ask `Show my GrantTap pairing QR.` Codex
+renders an interactive connection card with pairing status, a one-time QR,
+copy-link fallback, and confirmed reconnect controls. The same tools still
+return readable MCP content in clients that do not render app UI. Detailed
+plugin instructions are in
+[`plugins/granttap/README.md`](plugins/granttap/README.md).
+
+For the full background helper and provider hooks, install the CLI and run
+setup:
+
 ```bash
 npm install -g granttap-mcp
 granttap setup
@@ -188,16 +272,19 @@ trust.
 
 ## MCP contract
 
-`tools/list` returns exactly four public tools:
+`tools/list` returns exactly five public tools:
 
 | Tool | Contract |
 | --- | --- |
 | `connect` | Reuse the existing production pairing or return a one-time QR |
+| `reconnect` | Replace the pairing after explicit confirmation and return a fresh one-time QR |
 | `notify` | Send a non-blocking status update of at most 2,000 characters |
 | `ask_yes_no` | Ask a yes/no question and wait for the explicit answer |
 | `ask` | Ask an open question and wait for typed or spoken text |
 
 MCP `connect` accepts no custom routing, replacement, or key-rotation input.
+`reconnect` is declared destructive and requires `confirmed: true`; relay
+acceptance happens before the working local pairing is replaced.
 Setup is CLI-only because it changes provider configuration and must not be
 available to a model through prompt injection.
 
@@ -205,6 +292,14 @@ available to a model through prompt injection.
 not add a fifth MCP tool or grant any global setup capability, and it publishes
 only for the execution whose provider hook attributed the call.
 
+`notify`, `ask_yes_no`, and `ask` accept an `operationId`. A named call is
+remembered for fifteen minutes under the chat that made it, the tool, and the
+arguments: a retry returns the answer already given instead of asking again,
+a retry that arrives while the first call is still waiting waits for the same
+answer, and the same name used for other arguments is refused. One chat's
+name is never another's — the ledger is keyed by the execution the provider
+hook attributed, and the hook carries the `operationId` with the call.
+
 Provider-native approvals and mobile continuation require the matching local
 adapter. MCP registration alone is never reported as proof that an integration
 is ready.
@@ -331,6 +426,13 @@ Legacy custom levels remain compatible but are not part of the primary flow.
 
 ## Project Governance
 
+<p align="center">
+  <img src="docs/images/iphone-governance.png" width="200" alt="Project Governance: one answer per kind of capability, and the enforcement it reached">
+  <img src="docs/images/iphone-member-detail.png" width="200" alt="A member: role, answers, and removal">
+</p>
+
+<p align="center"><em>Governance for the whole Project · a member's answers, changed at once</em></p>
+
 Capabilities are decided per Project, not per task. A policy names an effect —
 `allow`, `ask`, or `deny` — for each kind (skills, MCP servers, shell and
 scripts, file writes, deploy, network), and may name one capability alone: one

package/apps/bridge/src/attachment-store.ts

@@ -13,6 +13,9 @@ import type { UserAttachment, UserAttachmentUpload } from "../../../packages/pro
 import { configDir } from "./config";
 
 export const ATTACHMENT_TTL_MS = 2 * 60 * 60_000;
+/** How many attachments may wait for their messages at once, and how much disk they may take. */
+export const MAX_STAGED_ATTACHMENTS = 32;
+export const MAX_STAGED_BYTES = 48 * 1_024 * 1_024;
 
 function directory(): string {
   const dir = join(configDir(), "attachments");
@@ -39,10 +42,45 @@ export function storeAttachment(upload: UserAttachmentUpload, room?: string, now
     name: upload.name, mimeType: upload.mimeType, data: upload.data, receivedAt: now,
     ...(room ? { room } : {}),
   };
-  writeFileSync(join(dir, `${id}.json`), JSON.stringify(record), { mode: 0o600 });
+  const body = JSON.stringify(record);
+  // The staging area is bounded. One attachment too large for it is refused
+  // (the message that names it is rejected and the phone sends it inline);
+  // otherwise the oldest waiting ones make room, since a message that never
+  // came is the likeliest reason they are still here.
+  const bytes = Buffer.byteLength(body, "utf8");
+  if (bytes > MAX_STAGED_BYTES) return false;
+  makeRoom(dir, bytes, id);
+  writeFileSync(join(dir, `${id}.json`), body, { mode: 0o600 });
   return true;
 }
 
+function makeRoom(dir: string, incoming: number, incomingId: string): void {
+  let staged: Array<{ path: string; size: number; mtimeMs: number }> = [];
+  try {
+    staged = readdirSync(dir)
+      .filter((name) => name.endsWith(".json") && name !== `${incomingId}.json`)
+      .flatMap((name) => {
+        try {
+          const stat = statSync(join(dir, name));
+          return [{ path: join(dir, name), size: stat.size, mtimeMs: stat.mtimeMs }];
+        } catch {
+          return [];
+        }
+      })
+      .sort((left, right) => left.mtimeMs - right.mtimeMs);
+  } catch {
+    return;
+  }
+  let count = staged.length;
+  let bytes = staged.reduce((total, item) => total + item.size, 0);
+  for (const item of staged) {
+    if (count < MAX_STAGED_ATTACHMENTS && bytes + incoming <= MAX_STAGED_BYTES) break;
+    rmSync(item.path, { force: true });
+    count -= 1;
+    bytes -= item.size;
+  }
+}
+
 /** The attachment the message named, taken off disk; nothing when it never came. */
 export function takeAttachment(attachmentId: string, room?: string, now = Date.now()): UserAttachment | undefined {
   const id = safeId(attachmentId);

package/apps/bridge/src/mesh/admin.ts

@@ -0,0 +1,65 @@
+/**
+ * What the person may do to the mesh that no agent may.
+ *
+ * A claim is released by its owner, and only its owner: that is what keeps
+ * one agent from clearing another's hold on a file. It also means a claim
+ * whose owner died, or will not let go, stays until it expires. The person
+ * is not an owner and is not bound by that rule; they are the authority the
+ * rule protects. A release from the phone is therefore a command of its
+ * own, checked against the Project it names, and written down.
+ */
+import type {
+  MeshClaimRelease,
+  MeshClaimReleaseResult,
+  ResourceClaim,
+} from "../../../../packages/protocol/schema";
+import type { MeshStore } from "./store";
+
+export type PersonRelease =
+  | { released: true; claim: ResourceClaim }
+  | { released: false; reason: "unknown_claim" | "other_project" };
+
+/** The answer the phone that asked is given, done or refused and why. */
+export function releaseResult(
+  request: MeshClaimRelease,
+  outcome: PersonRelease,
+  now = Date.now(),
+): MeshClaimReleaseResult {
+  return {
+    type: "mesh.claim.release.result",
+    sessionId: request.projectId,
+    projectId: request.projectId,
+    claimId: request.claimId,
+    ok: outcome.released,
+    ...(outcome.released ? {} : { reason: outcome.reason, detail: describe(outcome.reason) }),
+    ...(request.requestId ? { requestId: request.requestId } : {}),
+    generatedAt: now,
+  };
+}
+
+function describe(reason: "unknown_claim" | "other_project"): string {
+  return reason === "unknown_claim"
+    ? "No such claim on this computer; it may already be gone."
+    : "That claim belongs to another Project.";
+}
+
+export function releaseClaimByPerson(
+  store: MeshStore,
+  request: MeshClaimRelease,
+  log: (line: string) => void = (line) => process.stderr.write(`[monitor] mesh: ${line}\n`),
+): PersonRelease {
+  // The claim must be one of this Project's: a claim id is not a secret, and
+  // a Project's person does not reach into another Project with it.
+  const inProject = store.snapshot(request.projectId)?.claims.find((item) => item.claimId === request.claimId);
+  if (!inProject) {
+    const elsewhere = store.activeClaims().some((item) => item.claimId === request.claimId);
+    log(`release of ${request.claimId} refused: ${elsewhere ? "not in this Project" : "no such claim"}`);
+    return { released: false, reason: elsewhere ? "other_project" : "unknown_claim" };
+  }
+  store.releaseClaim(request.claimId);
+  log(
+    `claim ${request.claimId} on ${inProject.resource} held by ${inProject.ownerSessionId} `
+    + `released by the person${request.reason ? `: ${request.reason}` : ""}`,
+  );
+  return { released: true, claim: inProject };
+}

package/apps/bridge/src/mesh/store-state.ts

@@ -39,6 +39,19 @@ export const CapsuleMigration = z.object({
 }).strict();
 export type CapsuleMigration = z.infer<typeof CapsuleMigration>;
 
+/**
+ * A claim that was released, on record until the claim itself would have
+ * expired. Snapshots merge claims by id, so a computer that was away, or a
+ * copy that came round through another phone, would otherwise bring a
+ * released claim back as if nothing had happened.
+ */
+export const ReleasedClaim = z.object({
+  claimId: z.string().min(1).max(128),
+  releasedAt: z.number().nonnegative(),
+  expiresAt: z.number().positive(),
+}).strict();
+export type ReleasedClaim = z.infer<typeof ReleasedClaim>;
+
 export type StoreState = {
   version: 1;
   projects: ProjectValue[];
@@ -51,15 +64,17 @@ export type StoreState = {
   events: MeshEventValue[];
   receipts: ReceiptValue[];
   migrations: CapsuleMigration[];
+  releasedClaims: ReleasedClaim[];
 };
 
 const EMPTY: StoreState = {
   version: 1, projects: [], bindings: [], peers: [], tasks: [], executions: [], claims: [],
-  dependencies: [], events: [], receipts: [], migrations: [],
+  dependencies: [], events: [], receipts: [], migrations: [], releasedClaims: [],
 };
 
 export const MAX_STORE_PEERS = 256;
 export const MAX_STORE_MIGRATIONS = 64;
+export const MAX_RELEASED_CLAIMS = 256;
 
 function parsedArray<T>(value: unknown, schema: { safeParse: (input: unknown) => { success: boolean; data?: T } }): T[] {
   if (!Array.isArray(value)) return [];
@@ -117,6 +132,7 @@ export function readStoreState(path: string): StoreLoad {
         events: parsedArray(value.events, MeshEvent),
         receipts: parsedArray(value.receipts, HandoffReceipt),
         migrations: parsedArray(value.migrations, CapsuleMigration).slice(-MAX_STORE_MIGRATIONS),
+        releasedClaims: parsedArray(value.releasedClaims, ReleasedClaim).slice(-MAX_RELEASED_CLAIMS),
       }),
     };
   } catch {
@@ -224,6 +240,7 @@ function collapseSplitChats(state: StoreState): StoreState {
     // A receipt decides who owns a chat, so it must name the surviving Task and its capsule.
     receipts: state.receipts.map((item) => ({ ...scoped(item), capsuleHash: rehash(item.capsuleHash) })),
     migrations: [...migrations.values()].slice(-MAX_STORE_MIGRATIONS),
+    releasedClaims: state.releasedClaims,
   };
 }
 

package/apps/bridge/src/mesh/store-sync.ts

@@ -21,18 +21,25 @@ import type {
 } from "../../../../packages/protocol/schema";
 import { preferExecution, preferTask } from "./convergence";
 import { integrationPeerKey } from "./other-side";
-import { MAX_STORE_MIGRATIONS, MAX_STORE_PEERS, type StoreState } from "./store-state";
+import {
+  MAX_RELEASED_CLAIMS, MAX_STORE_MIGRATIONS, MAX_STORE_PEERS, type StoreState,
+} from "./store-state";
 
 type Collection = Exclude<keyof StoreState, "version">;
 
 const COLLECTIONS: Collection[] = [
   "projects", "bindings", "peers", "tasks", "executions", "claims", "dependencies", "events",
-  "receipts", "migrations",
+  "receipts", "migrations", "releasedClaims",
 ];
 const BOUNDS: Partial<Record<Collection, number>> = {
   peers: MAX_STORE_PEERS, events: 512, receipts: 256, migrations: MAX_STORE_MIGRATIONS,
+  releasedClaims: MAX_RELEASED_CLAIMS,
 };
-export const LOCK_WAIT_MS = 8_000;
+/**
+ * A write takes milliseconds, so a lock held for seconds belongs to a
+ * process that is stuck; waiting longer than this only stalls this one.
+ */
+export const LOCK_WAIT_MS = 2_000;
 const LOCK_POLL_MS = 5;
 
 function rowKey(name: Collection, item: unknown): string {
@@ -48,6 +55,7 @@ function rowKey(name: Collection, item: unknown): string {
     case "events": return row.eventId ?? "";
     case "receipts": return row.capsuleHash ?? "";
     case "migrations": return row.capsuleHashFrom ?? "";
+    case "releasedClaims": return row.claimId ?? "";
   }
 }
 

package/apps/bridge/src/mesh/store.ts

@@ -96,27 +96,63 @@ export class MeshStore {
    */
   private save(): boolean {
     try {
-      withStoreLock(this.path, () => {
-        const delta = storeDelta(this.baseline, this.state);
-        let merged = this.state;
+      withStoreLock(this.path, () => this.syncAndWriteUnderLock(), { waitMs: this.lockWaitMs });
+      return true;
+    } catch (error) {
+      if (!(error instanceof StoreLockError)) throw error;
+      this.unsaved = true;
+      return false;
+    }
+  }
+
+  /**
+   * Lay what this process changed over what is on disk, under the lock the
+   * caller already holds, and write the result.
+   */
+  private syncAndWriteUnderLock(): void {
+    const delta = storeDelta(this.baseline, this.state);
+    let merged = this.state;
+    if (storeFingerprint(this.path) !== this.synced) {
+      const disk = readStoreState(this.path);
+      if (disk.status === "ok") {
+        merged = deltaIsEmpty(delta) ? disk.state : applyStoreDelta(disk.state, delta);
+      } else if (disk.status === "corrupt" || disk.status === "too_large") {
+        setAsideStore(this.path, this.now());
+      }
+    }
+    writeStoreState(this.path, merged);
+    this.state = merged;
+    this.baseline = structuredClone(merged);
+    this.synced = storeFingerprint(this.path);
+  }
+
+  /**
+   * Check and change as one: what `run` reads is what it changes, and the
+   * change is on disk before anyone is told. Under the lock the file is
+   * read again first, so another process's write between this process's
+   * last look and now is seen. When the lock cannot be taken in time nothing
+   * is changed, and the caller says so instead of answering as if it were.
+   */
+  transact<T>(run: () => T): { applied: true; value: T } | { applied: false } {
+    try {
+      return withStoreLock(this.path, () => {
+        // Take in the disk as it is now, with what this process still owes laid over.
         if (storeFingerprint(this.path) !== this.synced) {
-          const disk = readStoreState(this.path);
-          if (disk.status === "ok") {
-            merged = deltaIsEmpty(delta) ? disk.state : applyStoreDelta(disk.state, delta);
-          } else if (disk.status === "corrupt" || disk.status === "too_large") {
-            setAsideStore(this.path, this.now());
+          const loaded = readStoreState(this.path);
+          if (loaded.status === "ok" || loaded.status === "missing") {
+            const pending = storeDelta(this.baseline, this.state);
+            this.state = deltaIsEmpty(pending) ? loaded.state : applyStoreDelta(loaded.state, pending);
+            this.baseline = structuredClone(loaded.state);
+            this.synced = storeFingerprint(this.path);
           }
         }
-        writeStoreState(this.path, merged);
-        this.state = merged;
-        this.baseline = structuredClone(merged);
-        this.synced = storeFingerprint(this.path);
+        const value = run();
+        this.syncAndWriteUnderLock();
+        return { applied: true as const, value };
       }, { waitMs: this.lockWaitMs });
-      return true;
     } catch (error) {
       if (!(error instanceof StoreLockError)) throw error;
-      this.unsaved = true;
-      return false;
+      return { applied: false };
     }
   }
 
@@ -339,41 +375,99 @@ export class MeshStore {
   claim(input: ResourceClaimValue): void {
     this.sync();
     const claim = ResourceClaim.parse(input);
+    if (this.isReleased(claim.claimId)) return;
     this.state.claims = this.state.claims.filter((item) => item.claimId !== claim.claimId);
     this.state.claims.push(claim);
     this.save();
   }
 
+  /**
+   * Whether a claim was released and is still remembered as such: a copy of
+   * it arriving late, from a computer that was away or a phone that carried
+   * it round, is not the claim coming back.
+   */
+  private isReleased(claimId: string, at = this.now()): boolean {
+    return this.state.releasedClaims.some((item) => item.claimId === claimId && item.expiresAt > at);
+  }
+
+  /** Write a release down, for as long as the claim itself would have lasted. */
+  private remember(released: ResourceClaimValue[]): void {
+    const at = this.now();
+    const kept = this.state.releasedClaims.filter((item) =>
+      item.expiresAt > at && !released.some((claim) => claim.claimId === item.claimId));
+    this.state.releasedClaims = [
+      ...kept,
+      ...released.map((claim) => ({ claimId: claim.claimId, releasedAt: at, expiresAt: Math.max(claim.expiresAt, at + 1) })),
+    ].slice(-256);
+  }
+
   releaseClaim(claimId: string, ownerSessionId?: string): boolean {
     this.sync();
-    const before = this.state.claims.length;
-    this.state.claims = this.state.claims.filter((claim) =>
-      claim.claimId !== claimId || (ownerSessionId != null && claim.ownerSessionId !== ownerSessionId));
-    if (this.state.claims.length === before) return false;
+    const released = this.state.claims.filter((claim) =>
+      claim.claimId === claimId && (ownerSessionId == null || claim.ownerSessionId === ownerSessionId));
+    if (released.length === 0) return false;
+    this.state.claims = this.state.claims.filter((claim) => !released.includes(claim));
+    this.remember(released);
     this.save();
     return true;
   }
 
   releaseClaimsByOwners(ownerSessionIds: ReadonlySet<string>): number {
     this.sync();
-    const before = this.state.claims.length;
-    this.state.claims = this.state.claims.filter((claim) =>
-      !ownerSessionIds.has(claim.ownerSessionId));
-    const removed = before - this.state.claims.length;
-    if (removed > 0) this.save();
-    return removed;
+    const released = this.state.claims.filter((claim) => ownerSessionIds.has(claim.ownerSessionId));
+    if (released.length === 0) return 0;
+    this.state.claims = this.state.claims.filter((claim) => !released.includes(claim));
+    this.remember(released);
+    this.save();
+    return released.length;
   }
 
   activeClaims(at = this.now()): ResourceClaimValue[] {
     this.sync();
-    const active = this.state.claims.filter((claim) => claim.expiresAt > at);
-    if (active.length !== this.state.claims.length) {
+    const active = this.liveClaims(at);
+    const tombstones = this.state.releasedClaims.filter((item) => item.expiresAt > at);
+    if (active.length !== this.state.claims.length || tombstones.length !== this.state.releasedClaims.length) {
       this.state.claims = active;
+      this.state.releasedClaims = tombstones;
       this.save();
     }
     return [...active];
   }
 
+  /** The claims that hold at `at`, read without writing anything. */
+  private liveClaims(at: number): ResourceClaimValue[] {
+    return this.state.claims.filter((claim) => claim.expiresAt > at);
+  }
+
+  /**
+   * A claim event from an agent, checked and recorded as one step under the
+   * store's lock: the conflict it is checked against is the state it is
+   * written into, so two agents claiming one file at once cannot both be
+   * told the file was free. Not applied at all when the lock is not taken
+   * in time, and the caller says so.
+   */
+  acceptClaimEvent(input: MeshEventValue): { applied: false } | { applied: true; accepted: boolean; conflict?: ResourceClaimValue } {
+    const parsed = MeshEvent.safeParse(input);
+    if (!parsed.success || parsed.data.eventType !== "RESOURCE_CLAIM" || !parsed.data.payload.claim) {
+      return { applied: true, accepted: false };
+    }
+    const event = parsed.data;
+    const claim = event.payload.claim!;
+    const result = this.transact((): { accepted: boolean; conflict?: ResourceClaimValue } => {
+      const conflict = this.liveClaims(this.now()).find((item) =>
+        item.projectId === event.projectId
+        && item.ownerSessionId !== event.sourceSessionId
+        && resourceOverlap(item.resource, claim.resource));
+      if (conflict) return { accepted: false, conflict };
+      if (this.state.events.some((item) => item.eventId === event.eventId)) return { accepted: false };
+      this.state.events.push(event);
+      this.state.events = this.state.events.slice(-512);
+      this.applyEvent(event);
+      return { accepted: true };
+    });
+    return result.applied ? { applied: true, ...result.value } : { applied: false };
+  }
+
   conflicts(projectId: string, ownerSessionId: string, resource: string): ResourceClaimValue[] {
     this.sync();
     return this.activeClaims().filter((claim) =>
@@ -407,6 +501,7 @@ export class MeshStore {
   observeClaim(input: ResourceClaimValue): boolean {
     this.sync();
     const claim = ResourceClaim.parse(input);
+    if (this.isReleased(claim.claimId)) return false;
     const previous = this.state.claims.find((item) => item.claimId === claim.claimId);
     if (previous && previous.ownerSessionId === claim.ownerSessionId
       && previous.expiresAt >= claim.expiresAt) return false;
@@ -450,18 +545,22 @@ export class MeshStore {
   }
 
   private applyEvent(event: MeshEventValue): void {
-    if (event.eventType === "RESOURCE_CLAIM" && event.payload.claim) {
+    if (event.eventType === "RESOURCE_CLAIM" && event.payload.claim && !this.isReleased(event.payload.claim.claimId)) {
       this.state.claims = mergeBy(this.state.claims, [event.payload.claim], (item) => item.claimId);
     }
     if (event.eventType === "RESOURCE_RELEASE" && event.payload.claimId) {
       // Only the owner releases its claim, and only from inside the claim's
       // own Task and Project: a claim id is not a secret, and a chat that
       // learned one must not be able to clear someone else's hold on a file.
-      this.state.claims = this.state.claims.filter((item) =>
-        item.claimId !== event.payload.claimId
-        || item.ownerSessionId !== event.sourceSessionId
-        || item.projectId !== event.projectId
-        || item.taskId !== event.taskId);
+      const released = this.state.claims.filter((item) =>
+        item.claimId === event.payload.claimId
+        && item.ownerSessionId === event.sourceSessionId
+        && item.projectId === event.projectId
+        && item.taskId === event.taskId);
+      if (released.length > 0) {
+        this.state.claims = this.state.claims.filter((item) => !released.includes(item));
+        this.remember(released);
+      }
     }
     if (event.eventType === "DEPENDENCY" && event.payload.dependsOnTaskId) {
       this.state.dependencies = mergeBy(this.state.dependencies, [{
@@ -559,6 +658,9 @@ export class MeshStore {
   mergeSnapshot(input: SnapshotValue): void {
     this.sync();
     mergeSnapshotState(this.state, input);
+    // A released claim does not come back with a snapshot that still has it.
+    const at = this.now();
+    this.state.claims = this.state.claims.filter((claim) => !this.isReleased(claim.claimId, at));
     this.save();
   }
 }

package/apps/bridge/src/monitor.ts

@@ -50,9 +50,10 @@ import { noteDeliveredRun } from "./mesh/run-digest";
 const DELIVERY_TIMEOUT_MS = 10 * 60_000;
 import { refreshMcpLoad } from "./machine-load/mcp-load-refresh";
 import { approvalsStatus } from "./approval-state";
-import { primeSessionKeys, sendSessionPayload } from "./session-keys";
+import { primeSessionKeys, sendProjectPayload, sendSessionPayload } from "./session-keys";
 import { sendMeshPayload } from "./session-keys";
 import { handleMeshPayload, meshCatalog, meshSnapshots, prepareMeshHandoff } from "./mesh/runtime";
+import { releaseClaimByPerson, releaseResult } from "./mesh/admin";
 import { deriveObservedClaims } from "./mesh/observed-claims";
 import { localMeshStore } from "./mesh/local";
 import { cachedSessionActivity } from "./monitor-session-activity";
@@ -208,6 +209,8 @@ export function startSessionMonitor(client: RelayClient): SessionMonitor {
 
   const snapshot = (includeHistory: boolean, forceHistory = false): SessionsStatus => {
     sweepAttachments();
+    // A change the store's lock held back is written on the next tick.
+    if (loadRuntimeConfig().meshEnabled) localMeshStore().flush();
     const { sessions, tokensRecent } = scanSessions();
     const runtime = loadRuntimeConfig();
     return {
@@ -398,6 +401,14 @@ export function startSessionMonitor(client: RelayClient): SessionMonitor {
       const prepared = await prepareMeshHandoff(client, payload);
       if (prepared) void publish().catch(() => {});
       return prepared;
+    } else if (payload.type === "mesh.claim.release" && loadRuntimeConfig().meshEnabled) {
+      // The person's own authority, not an owner's event: written down, then
+      // applied, and answered either way, so a refusal is seen where it was asked.
+      const outcome = releaseClaimByPerson(localMeshStore(), payload);
+      await sendProjectPayload(client, releaseResult(payload, outcome), "phone", { ttlMs: 15 * 60_000 })
+        .catch(() => {});
+      if (outcome.released) void publish().catch(() => {});
+      return true;
     }
     return false;
   });