granttap-mcp 0.8.4 → 0.8.5

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

@@ -87,7 +87,9 @@ export function buildTaskCapsule(
   };
   // A checkpoint commit is the fact the capsule carries instead of the dirty
   // tree: it holds every change the tree had, so relative to it the tree is
-  // clean. Whether the destination has that commit is its own check.
+  // clean. Whether the destination has that commit is its own check. What
+  // the commit does not hold is said too, so the destination never takes a
+  // partial checkpoint for the whole of the work.
   const described = checkpoint
     ? {
       ...capsule,
@@ -99,13 +101,38 @@ export function buildTaskCapsule(
       remainingWork: [
         `Continue from checkpoint ${checkpoint.sha.slice(0, 12)} on ${checkpoint.branch}.`,
         `Push ${checkpoint.branch} from ${computerId} if the destination does not have it.`,
+        ...checkpointRemainingWork(checkpoint, computerId),
       ],
+      importantDecisions: checkpointDecisions(checkpoint),
+      checkpoint: {
+        status: checkpoint.status,
+        files: checkpoint.files,
+        excluded: checkpoint.excluded.slice(0, 32),
+      },
     }
     : capsule;
   const parsed = TaskCapsule.safeParse(described);
   return parsed.success ? parsed.data : undefined;
 }
 
+function checkpointRemainingWork(checkpoint: Checkpoint, computerId: string): string[] {
+  if (checkpoint.excluded.length === 0) return [];
+  return [
+    `Left on ${computerId}, not in the checkpoint: ${checkpoint.excluded.slice(0, 8).join(", ")}`
+    + `${checkpoint.excluded.length > 8 ? ` (+${checkpoint.excluded.length - 8})` : ""}. `
+    + "They look like secrets; recreate them there if the work needs them.",
+  ].map((line) => line.slice(0, 1_000));
+}
+
+function checkpointDecisions(checkpoint: Checkpoint): string[] {
+  switch (checkpoint.status) {
+    case "complete": return [];
+    case "partial": return ["Checkpoint is partial: files that look like secrets stayed on the source computer."];
+    case "requires_review":
+      return ["Checkpoint needs review: the checkout was shared with other work, so the commit may carry changes that are not this Task's."];
+  }
+}
+
 function changedFilesBetween(cwd: string, from: string, to: string): string[] {
   const listed = git(cwd, ["diff", "--name-only", `${from}..${to}`]) ?? "";
   return [...new Set(listed.split("\n").map((line) => line.trim()).filter(Boolean))].slice(0, 64);

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

@@ -2,7 +2,7 @@ import { execFileSync } from "node:child_process";
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { sensitivePath } from "../sessions/edit-stats";
+import { secretFilePath } from "../sessions/edit-stats";
 
 /**
  * Commit everything uncommitted to a checkpoint branch, touching nothing else.
@@ -14,12 +14,21 @@ import { sensitivePath } from "../sessions/edit-stats";
  * publishing a branch is the person's decision, and the destination says so
  * if the commit has not reached it yet.
  */
+export type CheckpointStatus = "complete" | "partial" | "requires_review";
+
 export type Checkpoint = {
   sha: string;
   branch: string;
   files: number;
-  /** Paths left out because they look like secrets; never part of a checkpoint. */
+  /** Paths left out because they are secrets by name; never part of a checkpoint. */
   excluded: string[];
+  /**
+   * complete: every uncommitted change is in the commit. partial: secrets
+   * stayed behind, named in `excluded`. requires_review: the checkout was
+   * shared with other work, so the commit may carry changes that are not
+   * this Task's; the person decides.
+   */
+  status: CheckpointStatus;
 };
 
 export const CHECKPOINT_BRANCH_PREFIX = "granttap/checkpoint/";
@@ -34,13 +43,16 @@ function git(cwd: string, args: string[], env: NodeJS.ProcessEnv = process.env):
 /**
  * One branch per checkpoint, not per Task. A Task handed off twice used to
  * force-move the same branch, and the first checkpoint's commit was left
- * unreachable; a stamp on the name keeps each one.
+ * unreachable. The name carries the moment to the millisecond: the same
+ * request tried again lands on the same branch, two requests never do.
  */
 export function checkpointBranchName(taskId: string, at?: number): string {
   const base = CHECKPOINT_BRANCH_PREFIX + taskId.replace(/[^A-Za-z0-9._-]/g, "-").slice(0, 64);
   if (at == null) return base;
-  const stamp = new Date(at).toISOString().replace(/[-:]/g, "").replace(/\.\d+Z$/, "");
-  return `${base}-${stamp}`;
+  const iso = new Date(at).toISOString();
+  const stamp = iso.slice(0, 19).replace(/[-:]/g, "");
+  const millis = iso.slice(20, 23);
+  return `${base}-${stamp}-${millis}`;
 }
 
 export function createCheckpoint(
@@ -58,9 +70,9 @@ export function createCheckpoint(
     git(cwd, ["add", "-A"], env);
     // A checkpoint is the whole checkout's uncommitted work, so an .env or a
     // key that happened to change in it would be committed and, when the
-    // person pushes, published. Those stay as HEAD has them.
+    // person pushes, published. Those stay as HEAD has them, and are named.
     const excluded = git(cwd, ["diff", "--cached", "--name-only"], env)
-      .split("\n").filter(Boolean).filter(sensitivePath);
+      .split("\n").filter(Boolean).filter(secretFilePath);
     if (excluded.length > 0) git(cwd, ["reset", "-q", "--", ...excluded], env);
     const tree = git(cwd, ["write-tree"], env);
     if (tree === git(cwd, ["rev-parse", "HEAD^{tree}"])) return undefined; // nothing to keep
@@ -69,7 +81,7 @@ export function createCheckpoint(
     const branch = checkpointBranchName(taskId, at);
     git(cwd, ["branch", "-f", branch, sha]);
     const files = git(cwd, ["diff", "--name-only", `${head}..${sha}`]).split("\n").filter(Boolean).length;
-    return { sha, branch, files, excluded };
+    return { sha, branch, files, excluded, status: excluded.length > 0 ? "partial" : "complete" };
   } catch {
     return undefined;
   } finally {

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

@@ -111,13 +111,20 @@ export function markRunsDelivered(sessionId: string, at: number, only?: readonly
   }
 }
 
+/** How much of a run one line may carry: fewer files, a shorter outcome, when room is short. */
+export type RunDescriptionLimits = { files?: number; outcome?: number };
+
 /** One line a person or a model can read: what was asked, what happened, what it touched. */
-export function describeRun(record: RunRecord): string {
-  const parts = [`«${record.prompt}» → ${record.ok ? "" : "failed: "}${record.outcome}`];
-  if (record.files.length > 0) {
-    const shown = record.files.slice(0, 6).join(", ");
-    const more = record.files.length > 6 ? ` (+${record.files.length - 6})` : "";
+export function describeRun(record: RunRecord, limits: RunDescriptionLimits = {}): string {
+  const outcome = limits.outcome == null ? record.outcome : compactText(record.outcome, limits.outcome);
+  const parts = [`«${record.prompt}» → ${record.ok ? "" : "failed: "}${outcome}`];
+  const files = limits.files ?? 6;
+  if (record.files.length > 0 && files > 0) {
+    const shown = record.files.slice(0, files).join(", ");
+    const more = record.files.length > files ? ` (+${record.files.length - files})` : "";
     parts.push(`wrote ${shown}${more}`);
+  } else if (record.files.length > 0) {
+    parts.push(`wrote ${record.files.length} file${record.files.length === 1 ? "" : "s"} (see the transcript)`);
   }
   if (record.tools > 0) parts.push(`${record.tools} tool call${record.tools === 1 ? "" : "s"}`);
   if (record.cutOff) {

package/apps/bridge/src/mesh/prompt-context.ts

@@ -7,17 +7,23 @@
  * `UserPromptSubmit` hook to add to the prompt — the unread journal first,
  * then the Mesh brief — so the model coordinates without being told to look.
  *
- * The text is bounded, and the bound is honoured by showing fewer runs, never
- * by cutting the text: a run is marked read only once it was actually shown,
- * so what did not fit this time comes on the next turn instead of vanishing.
+ * The text is bounded, and the bound is honoured by saying less, never by
+ * cutting: fewer runs, then fewer Mesh lines, then shorter run lines. The
+ * Project's name and the way to the full map are always kept. A run is
+ * marked read only once it was actually shown, whole or in its short form;
+ * what did not fit comes on the next turn instead of vanishing.
  */
 import { liveExecutionScope } from "./capability";
-import { describeRun, markRunsDelivered, unreadRuns, type RunRecord } from "./journal";
+import {
+  describeRun, markRunsDelivered, unreadRuns, type RunDescriptionLimits, type RunRecord,
+} from "./journal";
 import { meshBrief } from "./map";
 import type { MeshSnapshot } from "../../../../packages/protocol/schema";
 
 export const MAX_CONTEXT_CHARS = 2_400;
 const MAX_RUNS_SHOWN = 5;
+/** Ever shorter ways to say one run, tried in order when room is short. */
+const COMPACTIONS: RunDescriptionLimits[] = [{}, { files: 3, outcome: 300 }, { files: 0, outcome: 120 }];
 
 export type PromptContextDeps = {
   unread: (sessionId: string) => RunRecord[];
@@ -39,22 +45,30 @@ function clock(at: number): string {
   return new Date(at).toISOString().slice(11, 16);
 }
 
-function runLines(total: number, shown: RunRecord[]): string[] {
+function runLines(total: number, shown: RunRecord[], limits: RunDescriptionLimits): string[] {
   if (shown.length === 0) return [];
   const lines = [
     `GrantTap: ${total} message${total === 1 ? "" : "s"} from the phone ${total === 1 ? "was" : "were"} `
     + "handled in this chat by background runs since your last turn. Their turns are in the transcript but not in your context:",
   ];
   shown.forEach((run, index) => {
-    lines.push(`${index + 1}. [${clock(run.at)}] ${describeRun(run)}`);
+    lines.push(`${index + 1}. [${clock(run.at)}] ${describeRun(run, limits)}`);
   });
   if (total > shown.length) lines.push(`(+${total - shown.length} earlier; they follow on your next turn)`);
   lines.push("Continue from what they did; check the working tree before redoing or undoing it.");
   return lines;
 }
 
-function compose(runs: string[], brief: string[]): string {
-  return [...runs, ...(runs.length > 0 && brief.length > 0 ? [""] : []), ...brief].join("\n");
+/** The Mesh part of the prompt: the Project's name and the map are the envelope, the bullets can go. */
+type Brief = { head: string; bullets: string[]; map: string };
+
+function briefLines(brief: Brief | undefined): string[] {
+  return brief ? [brief.head, ...brief.bullets, brief.map] : [];
+}
+
+function compose(runs: string[], brief: Brief | undefined): string {
+  const mesh = briefLines(brief);
+  return [...runs, ...(runs.length > 0 && mesh.length > 0 ? [""] : []), ...mesh].join("\n");
 }
 
 /** The text to add to the next prompt of a chat, or nothing when there is nothing new. */
@@ -66,33 +80,44 @@ export function promptContext(
   if (!sessionId) return undefined;
   const runs = deps.unread(sessionId);
   const scope = deps.scope(sessionId);
-  let brief: string[] = [];
+  let brief: Brief | undefined;
   if (scope) {
     const lines = meshBrief(scope.snapshot, scope.taskId, now);
     if (lines.length > 0) {
-      brief = [
-        `Project Mesh «${scope.snapshot.project.name}»:`,
-        ...lines.map((line) => `- ${line}`),
+      brief = {
+        head: `Project Mesh «${scope.snapshot.project.name}»:`,
+        bullets: lines.map((line) => `- ${line}`),
         // Listed by name, not by token: Claude Code reads only listed resources,
         // and the server finds the chat from its own environment.
-        "Full map: read the granttap MCP resource granttap://mesh/map",
-      ];
+        map: "Full map: read the granttap MCP resource granttap://mesh/map",
+      };
     }
   }
-  if (runs.length === 0 && brief.length === 0) return undefined;
-  // The newest runs first, as many as fit; then the brief gives way, one line
-  // at a time, because it is rebuilt from the Mesh on every turn anyway.
+  if (runs.length === 0 && !brief) return undefined;
   let shown = runs.slice(-MAX_RUNS_SHOWN);
-  let text = compose(runLines(runs.length, shown), brief);
+  let limits = COMPACTIONS[0]!;
+  let text = compose(runLines(runs.length, shown, limits), brief);
+  // The newest runs first, as many as fit; then the Mesh bullets give way,
+  // because they are rebuilt from the Mesh on every turn; then each run is
+  // said more briefly. The envelope — the Project and the map — stays.
   while (text.length > MAX_CONTEXT_CHARS && shown.length > 1) {
     shown = shown.slice(1);
-    text = compose(runLines(runs.length, shown), brief);
+    text = compose(runLines(runs.length, shown, limits), brief);
+  }
+  while (text.length > MAX_CONTEXT_CHARS && brief && brief.bullets.length > 0) {
+    brief = { ...brief, bullets: brief.bullets.slice(0, -1) };
+    text = compose(runLines(runs.length, shown, limits), brief);
   }
-  while (text.length > MAX_CONTEXT_CHARS && brief.length > 2) {
-    brief = [...brief.slice(0, -2), brief[brief.length - 1]!];
-    text = compose(runLines(runs.length, shown), brief);
+  for (const compaction of COMPACTIONS.slice(1)) {
+    if (text.length <= MAX_CONTEXT_CHARS) break;
+    limits = compaction;
+    text = compose(runLines(runs.length, shown, limits), brief);
   }
-  if (text.length > MAX_CONTEXT_CHARS) text = `${text.slice(0, MAX_CONTEXT_CHARS - 1)}…`;
-  if (shown.length > 0) deps.markDelivered(sessionId, now, shown.map((run) => run.at));
+  // Bounded by construction; should a line still not fit, it is cut and the
+  // run it belongs to is left unread rather than marked as told.
+  const cut = text.length > MAX_CONTEXT_CHARS;
+  if (cut) text = `${text.slice(0, MAX_CONTEXT_CHARS - 1)}…`;
+  const told = cut ? shown.slice(0, -1) : shown;
+  if (told.length > 0) deps.markDelivered(sessionId, now, told.map((run) => run.at));
   return text;
 }

package/apps/bridge/src/mesh/runtime-handoff.ts

@@ -20,6 +20,15 @@ export function createHandoffFlow(deps: MeshRuntimeDependencies) {
       `Base SHA: ${capsule.baseSha}`,
     ];
     if (capsule.latestCommit) lines.push(`Latest commit: ${capsule.latestCommit}`);
+    if (capsule.checkpoint) {
+      const { status, files, excluded } = capsule.checkpoint;
+      const line = status === "complete"
+        ? `Checkpoint: complete (${files} file${files === 1 ? "" : "s"}).`
+        : status === "partial"
+          ? `Checkpoint: partial (${files} file${files === 1 ? "" : "s"}); left on the source computer as secrets: ${excluded.join(", ")}.`
+          : `Checkpoint: needs review (${files} file${files === 1 ? "" : "s"}); the checkout was shared with other work, so some changes may not be this task's.`;
+      lines.push(line);
+    }
     if (capsule.testsStatus) lines.push(`Tests: ${capsule.testsStatus}`);
     if (capsule.importantDecisions.length) {
       lines.push(`Important decisions:\n- ${capsule.importantDecisions.join("\n- ")}`);

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

@@ -110,10 +110,21 @@ export function createMeshRuntime(deps: MeshRuntimeDependencies) {
       }
       // Asked to checkpoint, uncommitted work is committed to a branch of its
       // own first, so the Task can leave without losing it. Nothing is pushed.
+      // The branch is named by the request's own moment, so the same request
+      // tried again lands on the same branch and two requests never do.
       const cwd = session.worktree ?? session.cwd;
-      const checkpoint = request.checkpoint && cwd && workingTreeState(cwd) === "dirty"
-        ? createCheckpoint(cwd, request.taskId, session.title ?? request.taskId, deps.now())
+      const made = request.checkpoint && cwd && workingTreeState(cwd) === "dirty"
+        ? createCheckpoint(cwd, request.taskId, session.title ?? request.taskId, request.createdAt)
         : undefined;
+      // A checkout other Tasks are working in at the same time holds their
+      // changes too; the commit cannot tell them apart, so it says so.
+      const shared = made && cwd
+        ? sessions.some((other) =>
+          other.sessionId !== session.sessionId
+          && other.taskId != null && other.taskId !== request.taskId
+          && (other.worktree ?? other.cwd) === cwd)
+        : false;
+      const checkpoint = made && shared ? { ...made, status: "requires_review" as const } : made;
       const capsule = buildTaskCapsule(deps.store(), session, request, deps.computer(), checkpoint);
       const readiness = handoffReadiness({
         capsule,

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

@@ -20,9 +20,25 @@ import {
   type TaskDependency as DependencyValue,
 } from "../../../../packages/protocol/schema";
 import { lstatSync, readFileSync } from "node:fs";
+import { z } from "zod";
+import { capsuleHash } from "./handoff";
 
 const MAX_STORE_BYTES = 4 * 1_024 * 1_024;
 
+/**
+ * A capsule rewritten when two Tasks were rejoined, on record: its hash
+ * changed with its Task id, and a receipt that names the old hash is still a
+ * receipt for it. Kept locally only; nothing on the wire carries it.
+ */
+export const CapsuleMigration = z.object({
+  at: z.number().nonnegative(),
+  taskIdFrom: z.string().min(1).max(128),
+  taskIdTo: z.string().min(1).max(128),
+  capsuleHashFrom: z.string().regex(/^[0-9a-f]{64}$/),
+  capsuleHashTo: z.string().regex(/^[0-9a-f]{64}$/),
+}).strict();
+export type CapsuleMigration = z.infer<typeof CapsuleMigration>;
+
 export type StoreState = {
   version: 1;
   projects: ProjectValue[];
@@ -34,14 +50,16 @@ export type StoreState = {
   dependencies: DependencyValue[];
   events: MeshEventValue[];
   receipts: ReceiptValue[];
+  migrations: CapsuleMigration[];
 };
 
 const EMPTY: StoreState = {
   version: 1, projects: [], bindings: [], peers: [], tasks: [], executions: [], claims: [],
-  dependencies: [], events: [], receipts: [],
+  dependencies: [], events: [], receipts: [], migrations: [],
 };
 
 export const MAX_STORE_PEERS = 256;
+export const MAX_STORE_MIGRATIONS = 64;
 
 function parsedArray<T>(value: unknown, schema: { safeParse: (input: unknown) => { success: boolean; data?: T } }): T[] {
   if (!Array.isArray(value)) return [];
@@ -98,6 +116,7 @@ export function readStoreState(path: string): StoreLoad {
         dependencies: parsedArray(value.dependencies, TaskDependency),
         events: parsedArray(value.events, MeshEvent),
         receipts: parsedArray(value.receipts, HandoffReceipt),
+        migrations: parsedArray(value.migrations, CapsuleMigration).slice(-MAX_STORE_MIGRATIONS),
       }),
     };
   } catch {
@@ -172,15 +191,39 @@ function collapseSplitChats(state: StoreState): StoreState {
     if (next.taskId === next.dependsOnTaskId) continue;
     dependencies.set(`${next.taskId}\0${next.dependsOnTaskId}`, next);
   }
+  // A capsule carries its Task id and is named by its hash; moving the id
+  // changes the hash, so every receipt that named the old hash names the new
+  // one, and the move itself is written down for a receipt still on its way.
+  const now = Date.now();
+  const migrations = new Map(state.migrations.map((item) => [item.capsuleHashFrom, item]));
+  const rehashed = new Map<string, string>();
+  const events = state.events.map((event) => {
+    const next = rescopedEvent(event, target);
+    const before = event.payload.capsule;
+    const after = next.payload.capsule;
+    if (before && after && event.taskId !== next.taskId) {
+      const from = capsuleHash(before);
+      const to = capsuleHash(after);
+      rehashed.set(from, to);
+      migrations.set(from, {
+        at: now, taskIdFrom: event.taskId, taskIdTo: next.taskId, capsuleHashFrom: from, capsuleHashTo: to,
+      });
+    }
+    return next;
+  });
+  const rehash = (hash: string): string => rehashed.get(hash) ?? hash;
   return {
     ...state,
     tasks: state.tasks.filter((task) => target(task.taskId) === task.taskId),
     executions: state.executions.map(scoped),
     claims: state.claims.map(scoped),
     dependencies: [...dependencies.values()],
-    events: state.events.map((item) => rescopedEvent(item, target)),
-    // A receipt decides who owns a chat, so it must name the surviving Task.
-    receipts: state.receipts.map(scoped),
+    events: events.map((event) => event.payload.receipt
+      ? { ...event, payload: { ...event.payload, receipt: { ...event.payload.receipt, capsuleHash: rehash(event.payload.receipt.capsuleHash) } } }
+      : event),
+    // 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),
   };
 }
 

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

@@ -6,11 +6,14 @@
  * the last writer replaced whatever the other had written since: a Task
  * linked by one process vanished when the other saved a claim. A store now
  * reloads the file whenever it has changed under it, and saves by merging
- * what it changed since the last sync into what is on disk, under a short
- * lock beside the file.
+ * what it changed since the last sync into what is on disk, under a lock
+ * beside the file that is held by a named, living process.
  */
-import { chmodSync, existsSync, mkdirSync, renameSync, rmdirSync, statSync, writeFileSync } from "node:fs";
-import { dirname } from "node:path";
+import { randomBytes } from "node:crypto";
+import {
+  chmodSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync,
+} from "node:fs";
+import { dirname, join } from "node:path";
 import type {
   ExecutionSessionLink as ExecutionValue,
   IntegrationPeer as IntegrationPeerValue,
@@ -18,16 +21,18 @@ import type {
 } from "../../../../packages/protocol/schema";
 import { preferExecution, preferTask } from "./convergence";
 import { integrationPeerKey } from "./other-side";
-import { MAX_STORE_PEERS, type StoreState } from "./store-state";
+import { 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",
+  "projects", "bindings", "peers", "tasks", "executions", "claims", "dependencies", "events",
+  "receipts", "migrations",
 ];
-const BOUNDS: Partial<Record<Collection, number>> = { peers: MAX_STORE_PEERS, events: 512, receipts: 256 };
-const LOCK_STALE_MS = 5_000;
-const LOCK_WAIT_MS = 2_000;
+const BOUNDS: Partial<Record<Collection, number>> = {
+  peers: MAX_STORE_PEERS, events: 512, receipts: 256, migrations: MAX_STORE_MIGRATIONS,
+};
+export const LOCK_WAIT_MS = 8_000;
 const LOCK_POLL_MS = 5;
 
 function rowKey(name: Collection, item: unknown): string {
@@ -42,27 +47,34 @@ function rowKey(name: Collection, item: unknown): string {
     case "dependencies": return [row.taskId, row.dependsOnTaskId].join("\0");
     case "events": return row.eventId ?? "";
     case "receipts": return row.capsuleHash ?? "";
+    case "migrations": return row.capsuleHashFrom ?? "";
   }
 }
 
 type Upsert = { item: unknown; before?: string };
-export type StoreDelta = Record<Collection, { upserts: Upsert[]; removed: string[] }>;
+/** A removal names the row as it was read, so a row changed meanwhile is kept. */
+type Removal = { key: string; before: string };
+export type StoreDelta = Record<Collection, { upserts: Upsert[]; removed: Removal[] }>;
 
 /** What this process changed since it last agreed with the disk. */
 export function storeDelta(baseline: StoreState, current: StoreState): StoreDelta {
   const delta = {} as StoreDelta;
   for (const name of COLLECTIONS) {
     const before = new Map<string, string>();
-    for (const item of baseline[name]) before.set(rowKey(name, item), JSON.stringify(item));
+    for (const item of baseline[name] ?? []) before.set(rowKey(name, item), JSON.stringify(item));
     const after = new Set<string>();
     const upserts: Upsert[] = [];
-    for (const item of current[name]) {
+    for (const item of current[name] ?? []) {
       const key = rowKey(name, item);
       after.add(key);
       const previous = before.get(key);
       if (previous !== JSON.stringify(item)) upserts.push({ item, before: previous });
     }
-    delta[name] = { upserts, removed: [...before.keys()].filter((key) => !after.has(key)) };
+    const removed: Removal[] = [];
+    for (const [key, previous] of before) {
+      if (!after.has(key)) removed.push({ key, before: previous });
+    }
+    delta[name] = { upserts, removed };
   }
   return delta;
 }
@@ -75,18 +87,22 @@ export function deltaIsEmpty(delta: StoreDelta): boolean {
 /**
  * This process's changes laid over what another process wrote meanwhile. A
  * row only we changed is ours; a row both changed is settled the way two
- * computers settle it, so every process converges on the same file.
+ * computers settle it, so every process converges on the same file. A row
+ * we removed is removed only as we read it: a claim renewed by another
+ * process since is not the claim we decided had expired.
  */
 export function applyStoreDelta(disk: StoreState, delta: StoreDelta): StoreState {
   const merged: Record<string, unknown> = { ...disk };
   for (const name of COLLECTIONS) {
     const { upserts, removed } = delta[name];
     if (upserts.length === 0 && removed.length === 0) continue;
-    const gone = new Set(removed);
+    const gone = new Map(removed.map((removal) => [removal.key, removal.before]));
     const rows = new Map<string, unknown>();
-    for (const item of disk[name]) {
+    for (const item of disk[name] ?? []) {
       const key = rowKey(name, item);
-      if (!gone.has(key)) rows.set(key, item);
+      const asRead = gone.get(key);
+      if (asRead != null && asRead === JSON.stringify(item)) continue;
+      rows.set(key, item);
     }
     for (const { item, before } of upserts) {
       const key = rowKey(name, item);
@@ -131,7 +147,7 @@ export function writeStoreState(path: string, state: StoreState): void {
 export function setAsideStore(path: string, now = Date.now()): boolean {
   try {
     let target = `${path}.unreadable-${now}`;
-    for (let attempt = 2; existsSync(target) && attempt < 100; attempt += 1) {
+    for (let attempt = 2; exists(target) && attempt < 100; attempt += 1) {
       target = `${path}.unreadable-${now}-${attempt}`;
     }
     renameSync(path, target);
@@ -141,49 +157,108 @@ export function setAsideStore(path: string, now = Date.now()): boolean {
   }
 }
 
+function exists(path: string): boolean {
+  try {
+    statSync(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 function pause(ms: number): void {
   Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 }
 
+/** The lock could not be taken in time. The write is kept in memory and tried again later. */
+export class StoreLockError extends Error {}
+
+type LockOwner = { pid: number; token: string };
+
+function lockOwner(lock: string): LockOwner | undefined {
+  try {
+    const [pid, token] = readFileSync(join(lock, "owner"), "utf8").trim().split(":");
+    const parsed = Number(pid);
+    return Number.isInteger(parsed) && parsed > 0 && token ? { pid: parsed, token } : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function processAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return (error as NodeJS.ErrnoException).code === "EPERM";
+  }
+}
+
+/** Take a lock whose owner is gone: moved aside first, so two waiters cannot both take it. */
+function takeOverStale(lock: string): void {
+  const aside = `${lock}.stale-${process.pid}-${Date.now()}`;
+  try {
+    renameSync(lock, aside);
+  } catch {
+    return; // Someone else took it over first.
+  }
+  rmSync(aside, { recursive: true, force: true });
+}
+
 /**
  * Run under the store's lock: a directory beside the file, the one thing a
- * file system creates atomically. A lock left by a process that died is
- * taken over after a few seconds; a lock that is merely slow is waited for,
- * briefly, and then the write goes ahead merged, which is still better than
- * a write that is lost.
+ * file system creates atomically, naming the process that holds it.
+ *
+ * A lock whose owner is no longer running is taken over at once; a lock whose
+ * owner is alive is waited for, and when the wait runs out the caller gets a
+ * StoreLockError instead of the critical section. A lock is released only by
+ * the process and token that took it, so an owner that finishes late never
+ * removes a lock taken over meanwhile.
  */
-export function withStoreLock<T>(path: string, run: () => T): T {
+export function withStoreLock<T>(path: string, run: () => T, options: { waitMs?: number } = {}): T {
   mkdirSync(dirname(path), { recursive: true });
   const lock = `${path}.lock`;
+  const token = randomBytes(8).toString("hex");
+  const waitMs = options.waitMs ?? LOCK_WAIT_MS;
   const started = Date.now();
-  let held = false;
-  while (!held) {
+  for (;;) {
     try {
       mkdirSync(lock);
-      held = true;
+      writeFileSync(join(lock, "owner"), `${process.pid}:${token}`, { mode: 0o600 });
+      break;
     } catch (error) {
-      if ((error as NodeJS.ErrnoException).code !== "EEXIST") break;
-      if (Date.now() - started > LOCK_WAIT_MS) break;
-      try {
-        if (Date.now() - statSync(lock).mtimeMs > LOCK_STALE_MS) {
-          rmdirSync(lock);
-          continue;
-        }
-      } catch {
+      const code = (error as NodeJS.ErrnoException).code;
+      if (code !== "EEXIST") throw new StoreLockError(`the store lock could not be taken (${code ?? String(error)})`);
+      const owner = lockOwner(lock);
+      if (owner && !processAlive(owner.pid)) {
+        takeOverStale(lock);
         continue;
       }
+      if (!owner && lockAge(lock) > waitMs) {
+        // A lock without an owner file for this long was never finished being taken.
+        takeOverStale(lock);
+        continue;
+      }
+      if (Date.now() - started > waitMs) {
+        throw new StoreLockError("the store lock is held by another running process");
+      }
       pause(LOCK_POLL_MS);
     }
   }
   try {
     return run();
   } finally {
-    if (held) {
-      try {
-        rmdirSync(lock);
-      } catch {
-        // Taken over as stale by a process that waited longer than we ran.
-      }
+    const owner = lockOwner(lock);
+    if (owner && owner.pid === process.pid && owner.token === token) {
+      rmSync(lock, { recursive: true, force: true });
     }
   }
 }
+
+function lockAge(lock: string): number {
+  try {
+    return Date.now() - statSync(lock).mtimeMs;
+  } catch {
+    return 0;
+  }
+}

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

@@ -25,6 +25,7 @@ import {
   setAsideStore,
   storeDelta,
   storeFingerprint,
+  StoreLockError,
   withStoreLock,
   writeStoreState,
 } from "./store-sync";
@@ -48,7 +49,15 @@ export class MeshStore {
   /** The file this process last read or wrote; another file under the path is news. */
   private synced: string | undefined;
 
-  constructor(private readonly path: string, private readonly now = Date.now) {
+  /** How long a write waits for the store's lock before it is kept for later. */
+  private readonly lockWaitMs: number | undefined;
+
+  constructor(
+    private readonly path: string,
+    private readonly now = Date.now,
+    options: { lockWaitMs?: number } = {},
+  ) {
+    this.lockWaitMs = options.lockWaitMs;
     const loaded = readStoreState(path);
     this.state = loaded.state;
     this.baseline = structuredClone(loaded.state);
@@ -62,14 +71,16 @@ export class MeshStore {
   /**
    * Take in what another process wrote since this one last looked. Called on
    * entry to every public method, never in the middle of one, so a change
-   * made and not yet saved is never thrown away.
+   * made and not yet saved is never thrown away: what this process changed
+   * and could not yet write is laid over what arrived.
    */
   private sync(): void {
     const current = storeFingerprint(this.path);
     if (current === this.synced) return;
     const loaded = readStoreState(this.path);
     if (loaded.status === "ok" || loaded.status === "missing") {
-      this.state = loaded.state;
+      const pending = storeDelta(this.baseline, this.state);
+      this.state = deltaIsEmpty(pending) ? loaded.state : applyStoreDelta(loaded.state, pending);
       this.baseline = structuredClone(loaded.state);
       this.synced = current;
       return;
@@ -78,24 +89,55 @@ export class MeshStore {
     this.synced = storeFingerprint(this.path);
   }
 
-  /** Write what changed here over what is on disk now, under the store's lock. */
-  private save(): void {
-    withStoreLock(this.path, () => {
-      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());
+  /**
+   * Write what changed here over what is on disk now, under the store's lock.
+   * A lock that cannot be taken in time is not a reason to write anyway: the
+   * change stays in memory, ahead of the baseline, and the next save carries it.
+   */
+  private save(): boolean {
+    try {
+      withStoreLock(this.path, () => {
+        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);
-    });
+        writeStoreState(this.path, merged);
+        this.state = merged;
+        this.baseline = structuredClone(merged);
+        this.synced = storeFingerprint(this.path);
+      }, { waitMs: this.lockWaitMs });
+      return true;
+    } catch (error) {
+      if (!(error instanceof StoreLockError)) throw error;
+      this.unsaved = true;
+      return false;
+    }
+  }
+
+  /** Whether the last write was held back by the lock; cleared by the next successful write. */
+  private unsaved = false;
+
+  /** Whether a change made here is still waiting for the lock to be written. */
+  get hasUnsavedChanges(): boolean {
+    return this.unsaved && !deltaIsEmpty(storeDelta(this.baseline, this.state));
+  }
+
+  /** Try again to write what the lock held back. */
+  flush(): boolean {
+    this.sync();
+    if (deltaIsEmpty(storeDelta(this.baseline, this.state))) {
+      this.unsaved = false;
+      return true;
+    }
+    const written = this.save();
+    if (written) this.unsaved = false;
+    return written;
   }
 
   upsertProject(input: ProjectValue): void {
@@ -396,8 +438,15 @@ export class MeshStore {
       && item.taskId === event.taskId
       && item.sourceSessionId === receipt.sourceSessionId
       && item.payload.capsule != null);
-    return request?.payload.capsule != null
-      && capsuleHash(request.payload.capsule) === receipt.capsuleHash;
+    if (request?.payload.capsule == null) return false;
+    const digest = capsuleHash(request.payload.capsule);
+    if (digest === receipt.capsuleHash) return true;
+    // A receipt written before this Task was rejoined names the capsule by
+    // the hash it had then; the move is on record, so the receipt still holds.
+    return this.state.migrations.some((item) =>
+      item.taskIdTo === event.taskId
+      && item.capsuleHashTo === digest
+      && item.capsuleHashFrom === receipt.capsuleHash);
   }
 
   private applyEvent(event: MeshEventValue): void {

package/apps/bridge/src/project-policy/runtime.ts

@@ -61,6 +61,11 @@ export function rejectionReason(error: unknown): ProjectPolicyRejectionReason {
 
 export function createProjectPolicyRuntime(deps: ProjectPolicyRuntimeDependencies) {
   async function apply(relay: RelayClient, request: ProjectPolicySet): Promise<boolean> {
+    // The phone's edit is itself the enrollment: from this moment the Project
+    // is governed on this computer, whether or not the engine can take the
+    // policy right now, so a hook that finds the engine silent asks the
+    // person instead of falling open.
+    rememberGovernedProject(request.projectId, request.policy.revision, deps.now());
     try {
       const applied = await deps.client.request({
         operation: "policy.apply",

package/apps/bridge/src/sessions/edit-stats.ts

@@ -112,6 +112,29 @@ export function sensitivePath(path: unknown): boolean {
   return typeof path === "string" && SENSITIVE_PATH.test(path.trim());
 }
 
+/**
+ * A file that is a secret by its name alone: an env file, a key, a
+ * credentials store. Narrower than `sensitivePath`, on purpose. Hiding a
+ * preview of `tokenizer.ts` costs a glance; leaving it out of a checkpoint
+ * loses the code, so a checkpoint excludes only what is a secret, not what
+ * merely sounds like one.
+ */
+const SECRET_FILE = new RegExp(
+  "(^|[\\/])("
+  + "\\.env([.-][^\\/]*)?|[^\\/]+\\.env"
+  + "|[^\\/]*\\.(pem|key|p12|pfx|jks|keystore|der|gpg|asc|kdbx|ovpn|tfstate|tfstate\\.backup)"
+  + "|id_(rsa|ed25519|ecdsa|dsa)(\\.pub)?"
+  + "|credentials(\\.json|\\.ya?ml)?|secrets?(\\.json|\\.ya?ml|\\.toml)|[^\\/]*\\.secrets?"
+  + "|service[-_]account[^\\/]*\\.json"
+  + "|\\.npmrc|\\.netrc|\\.pypirc|\\.htpasswd|\\.git-credentials|\\.docker[\\/]config\\.json"
+  + ")$",
+  "i",
+);
+
+export function secretFilePath(path: unknown): boolean {
+  return typeof path === "string" && SECRET_FILE.test(path.trim());
+}
+
 /** Bound the lines and their length, and say how many were left out. */
 function boundPreview(lines: string[], redact: (line: string) => string): string | undefined {
   const kept: string[] = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "granttap-mcp",
-  "version": "0.8.4",
+  "version": "0.8.5",
   "description": "Personal live control center runtime for local coding agents on iPhone and Apple Watch.",
   "type": "module",
   "bin": {

package/packages/protocol/messages/mesh.ts

@@ -131,6 +131,17 @@ export const TaskCapsule = z.object({
   resourceClaims: z.array(Path).max(64),
   remainingWork: z.array(Detail).max(32),
   importantDecisions: z.array(Detail).max(16),
+  /**
+   * What the checkpoint commit holds, when the capsule rides on one:
+   * complete, partial (secrets stayed on the source computer, named in
+   * `excluded`), or requires_review (the checkout was shared with other
+   * work, so the commit may carry changes that are not this Task's).
+   */
+  checkpoint: z.object({
+    status: z.enum(["complete", "partial", "requires_review"]),
+    files: z.number().int().nonnegative(),
+    excluded: z.array(Path).max(32),
+  }).strict().optional(),
   createdAt: z.number().nonnegative(),
 }).strict().superRefine((value, ctx) => {
   if ((value.sourceProvider === "grok_bot") !== (value.sourceActorId != null)) {