@staix/agent-hub 0.12.24 → 0.12.26

package/src/hub/tasks.ts

@@ -564,6 +564,10 @@ export class Tasks {
   private plannerPullRecord(task: Task): HistoryEntry["planning"] {
     return task.history.findLast(entry => entry.event === "backlog pulled" || entry.event === "backlog returned")?.planning;
   }
+  private hasPersonReservation(task: Task): boolean {
+    const reservation = task.history.findLast(entry => entry.event === "reserved" || entry.planning?.fields.includes("reserved") && !["backlog pulled", "backlog returned"].includes(entry.event)) ?? (task.history[0]?.event === "backlogged" ? task.history[0] : undefined);
+    return !!task.reserved && reservation?.by === USER;
+  }
   wip(peer: PeerId, except?: number): number {
     return this.d.board.plannerWip(peer, except);
   }
@@ -604,8 +608,7 @@ export class Tasks {
       }
       const assignment = this.plannerAssignment(task);
       if (!assignment.owner) throw new PreEffectToolRefusal("no peer has eligible planner WIP capacity");
-      const reservation = task.history.findLast(entry => entry.event === "reserved" || entry.planning?.fields.includes("reserved") && !["backlog pulled", "backlog returned"].includes(entry.event)) ?? (task.history[0]?.event === "backlogged" ? task.history[0] : undefined);
-      if (task.reserved && reservation?.by === USER && assignment.owner !== task.reserved) throw new PreEffectToolRefusal("a person's reservation is retained");
+      if (this.hasPersonReservation(task) && assignment.owner !== task.reserved) throw new PreEffectToolRefusal("a person's reservation is retained");
       return { task, owner: assignment.owner };
     };
     const initial = validate(), withheld = await this.withholds("note", input.reason, initial.task);
@@ -723,6 +726,7 @@ export class Tasks {
       if (task.state === "approved") throw new PreEffectToolRefusal("approved work is final");
       if (by !== USER && (task.state !== "backlog" || taskHasStarted(task) || task.pinned || Object.hasOwn(patch, "pinned"))) throw new PreEffectToolRefusal("planner changes only unpinned backlog work");
       if (by !== USER && patch.rank !== undefined && task.history.some(entry => entry.by === USER && entry.planning?.fields.includes("rank"))) throw new PreEffectToolRefusal("a person's backlog order is retained");
+      if (by !== USER && Object.hasOwn(patch, "reserved") && this.hasPersonReservation(task)) throw new PreEffectToolRefusal("a person's reservation is retained");
       if (Object.hasOwn(patch, "deps") || Object.hasOwn(patch, "reserved")) {
         if (task.state !== "backlog" || taskHasStarted(task) || task.owner) throw new PreEffectToolRefusal("dependency and reservation changes require unstarted backlog work");
         if (patch.reserved && !(SUPPORTED_PEERS as readonly string[]).includes(patch.reserved) && !this.d.bus.knownPeers().includes(patch.reserved) && !this.d.routing().classes[task.class]?.peers.includes(patch.reserved)) throw new PreEffectToolRefusal("reserved owner is not a supported or configured peer");
@@ -1611,7 +1615,11 @@ export class Tasks {
       if (next.phase && !this.isPii(task) && !this.nameable(JSON.stringify(next.phase))) throw new PreEffectToolRefusal("phase metadata matches a PII pattern; use private work");
       if (next.phase) validatePhaseLinks(task, next.phase, id => this.d.board.get(id), t => this.isPii(t));
     }
-    if (next.reviewedHead !== task.sdlc?.reviewedHead) this.mine(task, by, "reviewer", true);
+    // Recording a head is the reviewer's; a head dropped because the repo or PR changed is not a recording, and a
+    // head supplied with a new PR identity is one even when its value is unchanged (#382).
+    const suppliedHead = !!input && typeof input === "object" && (input as { reviewedHead?: unknown }).reviewedHead !== undefined;
+    const artifactChanged = next.repo !== task.sdlc?.repo || next.pr !== task.sdlc?.pr;
+    if (next.reviewedHead !== undefined && (next.reviewedHead !== task.sdlc?.reviewedHead || (suppliedHead && artifactChanged))) this.mine(task, by, "reviewer", true);
     return this.d.board.update(task.id, by, "lifecycle", { sdlc: next });
   }
 
@@ -1816,7 +1824,7 @@ export class Tasks {
     }
     if (task.state === "proposed" || task.state === "changes_requested") task = this.d.board.update(task.id, by, "accepted", { state: "in_progress" }, WITH_DONE); // done without a separate accept
     const command = this.d.runCheck ? this.d.check?.(task.class, task) : undefined;
-    if (!command) return this.complete(task, by, summary, refs, "", withheld);
+    if (!command) return this.complete(task, by, summary, refs, "", withheld, "review");
     // The tool call returns now; a check can outlast an agent's tool timeout. The result decides what comes next.
     this.checking.set(task.id, task.owner);
     const pending = this.d.board.update(task.id, by, "done (checking)", { refs: cleanRefs(refs) }, summary, { withheld: withheld || undefined });
@@ -1942,12 +1950,15 @@ export class Tasks {
     this.tell(task, `Task #${id}: its check failed.\n$ ${outcome}${result.tail ? `\n${result.tail}` : ""}\nFix it and call hub_task_done again.`, pii);
   }
 
-  private async complete(task: Task, by: PeerId, summary?: string, refs?: TaskRefs, checkOutput = "", withheld = false): Promise<Task> {
+  /** `gated`: the transition `done()` already gated with no await since, so it is not read back twice (#382). */
+  private async complete(task: Task, by: PeerId, summary?: string, refs?: TaskRefs, checkOutput = "", withheld = false, gated?: "review"): Promise<Task> {
     let reviewer = task.reviewer;
-    if (this.d.sdlc && this.d.sdlc.config().mode !== "off") {
+    if (this.d.sdlc && this.d.sdlc.config().mode !== "off" && gated !== (reviewer ? "review" : "approval")) {
       await this.lifecycleGate(task, reviewer ? "review" : "approval");
       task = this.need(task.id, false, true);
       this.mine(task, by, "owner", true);
+      // In every mode: another done may have landed during the readback.
+      if (task.state === "in_review" || task.state === "approved") throw new Error(`task #${task.id} is already ${task.state}`);
       reviewer = task.reviewer;
     }
     const next = this.d.board.update(task.id, by, "done", { state: reviewer ? "in_review" : "approved", ...(task.sdlc ? { sdlc: { ...task.sdlc, stage: lifecycleStage(this.d.sdlc?.config() ?? sdlcConfig(undefined), reviewer ? "review" : "merge") } } : {}), refs: cleanRefs(refs) }, checkOutput ? `${summary ?? ""}\n${checkOutput}`.trim() : summary, { withheld: withheld || undefined });

package/src/hub/text-projection.ts

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { closeSync, constants, fstatSync, mkdirSync, mkdtempSync, openSync, readSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { extname, isAbsolute, join, resolve } from "node:path";
+import { dirname, extname, isAbsolute, join, resolve } from "node:path";
 
 import { homedir, tmpdir } from "node:os";
 import { sbplString } from "../local/deny.ts";
@@ -8,6 +8,7 @@ import { spawnSync } from "node:child_process";
 import { realPath } from "./project.ts";
 import { profile, sandboxAvailable } from "../local/sandbox.ts";
 export type ProjectionConfig = Record<string, string[]>;
+const EMPTY_ROOT = "/var/empty";
 export const MAX_PROJECTION_INPUT = 16 * 1024 * 1024;
 const MAX_INPUT = MAX_PROJECTION_INPUT, MAX_TEXT = 256 * 1024;
 /** Only machine-local config chooses programs; no implicit shell or command-string parsing. */
@@ -23,14 +24,18 @@ export function projectionConfig(raw: unknown): ProjectionConfig {
 }
 export interface ProjectedText { inputHash: string; rawHash: string; rawBlob: string; configHash: string; text: string }
 const hash = (data: string | Buffer) => createHash("sha256").update(data).digest("hex");
-function commandFingerprint(cwd: string, argv: string[]): string {
-  const parts = [JSON.stringify(argv)];
+/** The program and script files an argv runs, resolved as the converter will see them. */
+function programFiles(cwd: string, argv: string[]): { index: number; file: string; size: number; mtimeMs: number; ctimeMs: number }[] {
+  const out: { index: number; file: string; size: number; mtimeMs: number; ctimeMs: number }[] = [];
   for (const [index, arg] of argv.entries()) {
-    if (index !== 0 && !/\.(?:sh|py|js|ts|rb)$/.test(arg)) continue;
+    if (index !== 0 && !/\.(?:sh|py|js|mjs|cjs|ts|rb|pl)$/.test(arg)) continue;
     const choices = isAbsolute(arg) ? [arg] : index === 0 && !arg.includes("/") ? (process.env.PATH ?? "/usr/bin:/bin").split(":").slice(0, 32).map(dir => join(dir, arg)) : [resolve(cwd, arg)];
-    for (const file of choices) try { const st = statSync(file); if (!st.isFile()) continue; parts.push(file, String(st.size), String(st.mtimeMs), String(st.ctimeMs)); break; } catch { /* another PATH entry */ }
+    for (const file of choices) try { const st = statSync(file); if (!st.isFile()) continue; out.push({ index, file, size: st.size, mtimeMs: st.mtimeMs, ctimeMs: st.ctimeMs }); break; } catch { /* another PATH entry */ }
   }
-  return hash(parts.join("\\n"));
+  return out;
+}
+function commandFingerprint(cwd: string, argv: string[]): string {
+  return hash([JSON.stringify(argv), ...programFiles(cwd, argv).flatMap(p => [p.file, String(p.size), String(p.mtimeMs), String(p.ctimeMs)])].join("\\n"));
 }
 function boundedCache(file: string): string {
   const fd = openSync(file, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
@@ -47,8 +52,14 @@ function boundedCache(file: string): string {
 export class TextProjections {
   private readonly sandbox: string;
   private readonly warned = new Set<string>();
+  /** Inputs whose full-budget conversion failed: the same bytes under the same command are not converted again. */
+  private readonly failed = new Set<string>();
   constructor(private readonly options: { cwd: string; stateDir: string; config: ProjectionConfig; deny?: string[]; readAllow?: string[]; log?: (line: string) => void }) {
-    this.sandbox = Object.keys(options.config).length ? profile(options.cwd, false, options.readAllow, options.deny, ["."]) : "";
+    // Rooted at an empty system directory, not the project. The project guarantee: project file data is denied, then the
+    // snapshot, the argv-named program/script files and the directory listings above an in-project script are granted, so
+    // no other project file is readable (system, toolchain, home and local.read_allow paths outside the project remain granted).
+    // Only where conversion can run: /var/empty is a macOS directory, and a host without the sandbox never converts.
+    this.sandbox = Object.keys(options.config).length && sandboxAvailable() ? profile(EMPTY_ROOT, false, options.readAllow, options.deny, ["."]) : "";
   }
   private warn(ext: string): void {
     if (this.warned.has(ext)) return;
@@ -103,17 +114,33 @@ export class TextProjections {
           if (value.inputHash === inputHash && value.rawHash === rawHash && value.rawBlob === rawBlob && value.configHash === configHash && typeof value.text === "string" && Buffer.byteLength(value.text) <= MAX_TEXT) return value;
         }
       } catch { /* missing/invalid cache is not evidence */ }
+      if (this.failed.has(key)) throw new Error("conversion failed before");
       if (!sandboxAvailable()) throw new Error("sandbox unavailable");
       scratch = realPath(mkdtempSync(join(tmpdir(), "ahub-projection-input-"))); const snapshot = join(scratch, "input" + ext);
       writeFileSync(snapshot, bytes, { mode: 0o400 });
+      // A read_allow entry may enclose the project. Seatbelt lets a later rule win only for the operation it names, so the
+      // deny and the literal grants after it both name file-read-data. The converter runs in its scratch directory (getcwd
+      // needs that directory's data), with its program and script arguments resolved to absolute paths.
+      const root = realPath(this.options.cwd), projectDeny = "\n(deny file-read-data (subpath " + sbplString(root) + "))";
+      const resolved = programFiles(this.options.cwd, argv);
+      // A module loader lists the directories above its script: grant those listings (not their files) up to the root.
+      const listings = new Set<string>();
+      for (const program of resolved) for (let dir = dirname(realPath(program.file)); dir.startsWith(root + "/") || dir === root; dir = dirname(dir)) { listings.add(dir); if (dir === root) break; }
+      const programs = resolved.map(p => "\n(allow file-read* file-read-data process-exec (literal " + sbplString(realPath(p.file)) + "))").join("")
+        + [...listings].map(dir => "\n(allow file-read-data (literal " + sbplString(dir) + "))").join("")
+        + "\n(allow file-read* file-read-data (literal " + sbplString(scratch) + "))";
+      const absolute = new Map(resolved.map(p => [p.index, p.file]));
       const result = spawnSync(process.execPath, [join(import.meta.dir, "projection-exec.ts")], {
-        cwd: this.options.cwd, timeout: deadline === undefined ? 8000 : Math.ceil(Math.max(1, Math.min(8000, deadline - performance.now()))), maxBuffer: MAX_TEXT * 2, encoding: "utf8",
-        input: JSON.stringify({ cwd: this.options.cwd, sandbox: this.sandbox + "\n(allow file-read* (literal " + sbplString(snapshot) + "))", argv: argv.map(arg => arg === "{input}" ? snapshot : arg), ...(deadline === undefined ? {} : { timeoutMs: Math.max(1, Math.min(5000, deadline - performance.now() - 100)) }) }),
+        cwd: scratch, timeout: deadline === undefined ? 8000 : Math.ceil(Math.max(1, Math.min(8000, deadline - performance.now()))), maxBuffer: MAX_TEXT * 2, encoding: "utf8",
+        input: JSON.stringify({ cwd: scratch, sandbox: this.sandbox + projectDeny + "\n(allow file-read* file-read-data (literal " + sbplString(snapshot) + "))" + programs, argv: argv.map((arg, index) => arg === "{input}" ? snapshot : absolute.get(index) ?? arg), ...(deadline === undefined ? {} : { timeoutMs: Math.max(1, Math.min(5000, deadline - performance.now() - 100)) }) }),
         env: { PATH: process.env.PATH ?? "/usr/bin:/bin", HOME: homedir(), LANG: "en_US.UTF-8", TERM: "dumb" },
       });
-      if (result.error || result.status !== 0) throw new Error("conversion failed");
+      // ponytail: in-memory for this process, cleared at 1024 keys; persist it if restarts make retries costly.
+      const failure = () => { if (deadline === undefined) { if (this.failed.size >= 1024) this.failed.clear(); this.failed.add(key); } return new Error("conversion failed"); };
+      if (result.error) throw new Error("conversion helper failed"); // a spawn or helper failure may be transient: not remembered
+      if (result.status !== 0) throw failure();
       const converted = JSON.parse(result.stdout) as { ok?: boolean; text?: string };
-      if (converted.ok !== true || typeof converted.text !== "string" || Buffer.byteLength(converted.text) > MAX_TEXT || converted.text.includes("\0")) throw new Error("conversion failed");
+      if (converted.ok !== true || typeof converted.text !== "string" || Buffer.byteLength(converted.text) > MAX_TEXT || converted.text.includes("\0")) throw failure();
       verify?.();
       const value = { inputHash, rawHash, rawBlob, configHash, text: converted.text };
       mkdirSync(cacheDir, { recursive: true });

package/src/hub/tooling.ts

@@ -1,5 +1,5 @@
 import { spawn, type ChildProcess } from "node:child_process";
-import { accessSync, constants, readdirSync, readFileSync, statSync } from "node:fs";
+import { accessSync, closeSync, constants, fstatSync, openSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { delimiter, join, relative, resolve, isAbsolute } from "node:path";
 import { realPath } from "./project.ts";
@@ -32,8 +32,18 @@ const PROBE_MS = 2000, PROBE_BYTES = 4096;
 /** `env` supplies CLAUDE_CONFIG_DIR and CODEX_HOME, the runtimes' own config roots (the hub's environment by default). */
 export interface ToolingSources { home?: string; cwd?: string; path?: string; env?: Record<string, string | undefined> }
 
+/** A regular file of at most 1 MiB, opened without blocking: a FIFO or device under a project's `.claude/` reads as absent. */
+const text = (file: string): string | undefined => {
+  let fd: number | undefined;
+  try {
+    fd = openSync(file, constants.O_RDONLY | constants.O_NONBLOCK);
+    const st = fstatSync(fd);
+    if (!st.isFile() || st.size > 1024 * 1024) return undefined;
+    return readFileSync(fd, "utf8");
+  } catch { return undefined; } finally { if (fd !== undefined) closeSync(fd); }
+};
 const json = (file: string): Record<string, unknown> | undefined => {
-  try { const v = JSON.parse(readFileSync(file, "utf8")); return v && typeof v === "object" ? v as Record<string, unknown> : undefined; } catch { return undefined; }
+  try { const v = JSON.parse(text(file) ?? ""); return v && typeof v === "object" ? v as Record<string, unknown> : undefined; } catch { return undefined; }
 };
 /** A version string as data, never anything longer or stranger. */
 const version = (v: unknown): string | null => typeof v === "string" && /^[0-9A-Za-z.+_-]{1,40}$/.test(v) ? v : null;
@@ -58,12 +68,13 @@ function claudePlugins(root: string, cwd: string | undefined): Addon[] {
 }
 
 function codexPlugins(root: string): Addon[] {
-  let text: string;
-  try { text = readFileSync(join(root, "config.toml"), "utf8"); } catch { return []; }
-  const found = new Map<string, string>(); // plugin name -> marketplace
-  // `[plugins."name@market"]` with no `enabled = false` below it, and plugins whose hooks Codex was told to trust.
-  for (const m of text.matchAll(/^\[plugins\."([^"@]+)@([^"]+)"\]\s*\n((?:(?!\[)[^\n]*\n?)*)/gm)) if (!/^\s*enabled\s*=\s*false\b/m.test(m[3] ?? "")) found.set(m[1]!, m[2]!);
-  for (const m of text.matchAll(/^\[hooks\.state\."([^"@]+)@([^":]+):/gm)) found.set(m[1]!, m[2]!);
+  const config = text(join(root, "config.toml"));
+  if (config === undefined) return [];
+  const found = new Map<string, string>(), disabled = new Set<string>(); // plugin name -> marketplace
+  // `[plugins."name@market"]` with no `enabled = false` below it, and plugins whose hooks Codex was told to trust
+  // unless their plugin entry disables them: a trust entry outlives the plugin's own switch.
+  for (const m of config.matchAll(/^\[plugins\."([^"@]+)@([^"]+)"\]\s*\n((?:(?!\[)[^\n]*\n?)*)/gm)) if (!/^\s*enabled\s*=\s*false\b/m.test(m[3] ?? "")) found.set(m[1]!, m[2]!); else disabled.add(m[1]! + "@" + m[2]!);
+  for (const m of config.matchAll(/^\[hooks\.state\."([^"@]+)@([^":]+):/gm)) if (!disabled.has(m[1]! + "@" + m[2]!)) found.set(m[1]!, m[2]!);
   const out: Addon[] = [];
   for (const [plugin, market] of found) {
     const name = PLUGINS.get(plugin);

package/src/memory/import.ts

@@ -1,5 +1,7 @@
 import { Database } from "bun:sqlite";
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { createHash, randomBytes } from "node:crypto";
+import { realPath } from "../hub/project.ts";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { KINDS, looksSecret, type Kind, type MemoryStore } from "./store.ts";
@@ -9,7 +11,24 @@ export const CLAUDE_MEM_BUSY_TIMEOUT_MS = 3000;
 /** Titles `ahub ask --remember` gives a model's answer (ask.ts ASK_NOTE_TITLE): never imported as a finding. */
 const MODEL_ANSWER = "ahub ask (model answer)";
 
-export interface ImportResult { read: number; added: number; skipped: { model: number; pii: number; secret: number; project: number } }
+export interface ImportResult { read: number; added: number; skipped: { model: number; pii: number; secret: number }; more: boolean; cursor: number }
+
+/** Machine-local progress is disposable; malformed/unreadable state simply replays the idempotent import. */
+function readCursors(file: string): Record<string, number> {
+  try {
+    const value: unknown = JSON.parse(readFileSync(file, "utf8"));
+    if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+    return Object.fromEntries(Object.entries(value).filter(([, id]) => Number.isSafeInteger(id) && id >= 0));
+  } catch { return {}; }
+}
+function writeCursor(file: string, key: string, cursor: number, log: (line: string) => void): void {
+  const temp = `${file}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
+  try {
+    writeFileSync(temp, JSON.stringify({ ...readCursors(file), [key]: cursor }) + "\n", { mode: 0o600, flag: "wx" });
+    renameSync(temp, file);
+  } catch { log("claude-mem import progress could not be saved; the next run may replay handled rows"); }
+  finally { try { rmSync(temp, { force: true }); } catch { /* disposable progress */ } }
+}
 
 /**
  * #258 phase 3: copy the hub's own notes from claude-mem (observations whose metadata names a `peer`: `hub_remember`
@@ -17,30 +36,38 @@ export interface ImportResult { read: number; added: number; skipped: { model: n
  * the projects in `chain` (claude-mem files them under the repository's basename). Model answers, PII-pattern text and secret-looking text are skipped.
  * Idempotent: an observation always maps to the same entry.
  */
-export function importClaudeMem(store: MemoryStore, opts: { project: string; chain: string[]; isPii: (text: string) => boolean; nodes?: (text: string) => string[]; db?: string; limit?: number }): ImportResult {
+export function importClaudeMem(store: MemoryStore, opts: { project: string; chain: string[]; isPii: (text: string) => boolean; nodes?: (text: string) => string[]; db?: string; limit?: number; restart?: boolean; log?: (line: string) => void }): ImportResult {
   const file = opts.db ?? join(homedir(), ".claude-mem", "claude-mem.db");
   if (!existsSync(file)) throw new Error(`no claude-mem store at ${file}`);
+  const limit = opts.limit ?? 10_000;
+  if (!Number.isSafeInteger(limit) || limit <= 0) throw new Error("--limit takes a positive integer");
+  const state = join(store.dir, "import-state.json");
+  const name = opts.chain.at(-1) ?? "";
+  const key = createHash("sha256").update(JSON.stringify([realPath(file), name, opts.project])).digest("hex");
+  let cursor = opts.restart ? 0 : readCursors(state)[key] ?? 0;
   const db = new Database(file, { readonly: true });
   db.run(`PRAGMA busy_timeout = ${CLAUDE_MEM_BUSY_TIMEOUT_MS}`);
-  const result: ImportResult = { read: 0, added: 0, skipped: { model: 0, pii: 0, secret: 0, project: 0 } };
+  const result: ImportResult = { read: 0, added: 0, skipped: { model: 0, pii: 0, secret: 0 }, more: false, cursor };
   try {
-    const rows = db.query("SELECT id, project, title, text, narrative, created_at_epoch, metadata FROM observations WHERE metadata LIKE '%\"peer\"%' ORDER BY id LIMIT ?")
-      .all(opts.limit ?? 10_000) as { id: number; project: string | null; title: string | null; text: string | null; narrative: string | null; created_at_epoch: number | null; metadata: string | null }[];
+    const max = db.query("SELECT MAX(id) AS id FROM observations WHERE project = ? AND metadata LIKE '%\"peer\"%'").get(name) as { id: number | null };
+    if ((max.id ?? 0) < cursor) cursor = 0;
+    const rows = db.query("SELECT id, project, title, text, narrative, created_at_epoch, metadata FROM observations WHERE project = ? AND id > ? AND metadata LIKE '%\"peer\"%' ORDER BY id LIMIT ?")
+      .all(name, cursor, limit) as { id: number; project: string | null; title: string | null; text: string | null; narrative: string | null; created_at_epoch: number | null; metadata: string | null }[];
     // The hub files its claude-mem notes under the repository's own name (the chain's last); the names above it are other
     // projects (a superproject) whose notes and privacy policy are not this one's. ponytail: claude-mem keys projects by
     // basename, so two unrelated repositories with one name still share it.
-    const project = opts.project, names = new Set(opts.chain.slice(-1));
-    for (const r of rows) {
-      result.read++;
+    const project = opts.project;
+    result.read = rows.length;
+    result.more = rows.length === limit;
+    const handle = (r: typeof rows[number]) => {
       let meta: Record<string, unknown>;
-      try { meta = JSON.parse(r.metadata ?? "{}"); } catch { continue; }
-      if (typeof meta.peer !== "string" || !meta.peer) continue;
-      if (!r.project || !names.has(r.project)) { result.skipped.project++; continue; }
+      try { meta = JSON.parse(r.metadata ?? "{}"); } catch { return; }
+      if (!meta || typeof meta !== "object" || typeof meta.peer !== "string" || !meta.peer) return;
       const title = r.title ?? "", text = (r.text ?? r.narrative ?? "").trim();
-      if (!text) continue;
-      if (meta.source === "ahub ask" || title.startsWith(MODEL_ANSWER)) { result.skipped.model++; continue; }
-      if (opts.isPii(`${title}\n${text}`)) { result.skipped.pii++; continue; }
-      if (looksSecret(`${title}\n${text}`)) { result.skipped.secret++; continue; }
+      if (!text) return;
+      if (meta.source === "ahub ask" || title.startsWith(MODEL_ANSWER)) { result.skipped.model++; return; }
+      if (opts.isPii(`${title}\n${text}`)) { result.skipped.pii++; return; }
+      if (looksSecret(`${title}\n${text}`)) { result.skipped.secret++; return; }
       const kind: Kind = KINDS.includes(meta.kind as Kind) ? meta.kind as Kind : "finding";
       const at = new Date(r.created_at_epoch ?? 0).toISOString();
       const { added } = store.importNote({ op: "note", project, scope: "project", tier: "long", kind, peer: meta.peer.slice(0, 32), ...(title ? { title } : {}), text,
@@ -48,8 +75,16 @@ export function importClaudeMem(store: MemoryStore, opts: { project: string; cha
         // own paths and symbols place the note in the graph.
         about: opts.nodes?.(`${title}\n${text}`) ?? [], source: "claude-mem" }, at);
       if (added) result.added++;
+    };
+    for (const row of rows) {
+      handle(row);
+      cursor = row.id; // only fully handled rows, including every skip
     }
-  } finally { db.close(); }
+  } finally {
+    db.close();
+    result.cursor = cursor;
+    writeCursor(state, key, cursor, opts.log ?? console.error);
+  }
   store.refresh();
   return result;
 }

package/src/memory/store.ts

@@ -78,10 +78,10 @@ const SECRETS = [/-----BEGIN [A-Z ]*PRIVATE KEY-----/, /\bAKIA[0-9A-Z]{16}\b/, /
 export const looksSecret = (text: string): boolean => SECRETS.some((re) => re.test(text));
 
 /** `task`: the board task's id and proposal time; its node carries both, so a task id reused after `ahub reset --all` is another node. */
-export interface Extract { cwd: string; project: string; repo: string; deny?: string[]; paths?: string[]; symbols?: string[]; task?: { id: number; created: number } }
+export interface Extract { cwd: string; project: string; repo: string; deny?: string[]; paths?: string[]; symbols?: string[]; task?: { id: number; created: number }; checkExists?: boolean }
 /**
  * Deterministic edges, fixed at write time so a rebuild never depends on the file system: the task's refs and plan
- * paths, plan symbols (with the path when the plan names exactly one), paths in the text that exist in the project then,
+ * paths, plan symbols (with the path when the plan names exactly one), paths in the text that exist in the project then (or text-only paths when checkExists is false),
  * `#N` as an issue of `repo`, and `task #N` as a board task. Paths stay relative to the project root; denylisted ones
  * are left out.
  */
@@ -99,7 +99,7 @@ export function extractNodes(text: string, x: Extract): Node[] {
   for (const m of text.matchAll(/(?:^|[\s(`'"])((?:[\w.-]+\/)*[\w.-]+\.[A-Za-z0-9]{1,8})(?=$|[\s)`'",:;])/g)) {
     const p = m[1]!;
     if (!p.includes("/") && !/\.(ts|js|tsx|jsx|py|rs|go|md|json|toml|yaml|yml|sh|html|css)$/.test(p)) continue;
-    try { if (!isAbsolute(p) && !p.startsWith("..") && existsSync(join(x.cwd, p))) path(p); } catch { /* unreadable: not an edge */ }
+    try { if (!isAbsolute(p) && !p.startsWith("..") && (x.checkExists === false || existsSync(join(x.cwd, p)))) path(p); } catch { /* unreadable: not an edge */ }
   }
   for (const m of text.matchAll(/\btask #(\d{1,9})\b/gi)) out.add(`task:${x.project}#${m[1]}`);
   for (const m of text.matchAll(/(?<![\w/]|task )#(\d{1,9})\b/gi)) out.add(`issue:${x.repo}#${m[1]}`);
@@ -244,7 +244,7 @@ export class MemoryStore {
     // A fixed machine: the same observation imported on two machines is one entry once they sync.
     const body = { schema: MEMORY_SCHEMA, at, machine: "claude-mem", ...n, text: n.text.slice(0, MAX_TEXT), ...(n.title ? { title: n.title.slice(0, MAX_TITLE) } : {}) } as Omit<Entry, "id">;
     const id = entryId(body);
-    // The observation, not the nodes derived from it (they follow the repository's files), says whether it is here already.
+    // The source tuple also recognizes legacy ids whose nodes depended on the checkout or extractor version.
     const known = this.db.query("SELECT id FROM entries WHERE id = ? OR (source = 'claude-mem' AND project = ? AND at = ? AND text = ?)").get(id, n.project, at, n.text.slice(0, MAX_TEXT)) as { id: string } | null;
     if (known) return { id: known.id, added: false };
     appendFileSync(join(this.dir, n.tier === "short" ? "local" : "log", `${this.machine.id}.jsonl`), JSON.stringify({ ...body, id }) + "\n", { mode: 0o600 });
@@ -255,7 +255,55 @@ export class MemoryStore {
   private op(op: OpEntry["op"], target: View, actor: string, by?: string): string {
     return this.append({ op, target: target.id, actor, ...(by ? { by } : {}) }, target.local);
   }
-  forget(id: string, actor: string, project?: string): View | undefined { const v = this.get(id, project); if (v) this.op("forget", v, actor); return v; }
+  forget(id: string, actor: string, project?: string): View | undefined {
+    const v = this.get(id, project);
+    if (!v) return undefined;
+    // Legacy imports may have different node-derived ids. Forget every known copy, including hidden ones.
+    const group = v.source === "claude-mem" ? this.live().filter(x => x.source === v.source && x.project === v.project && x.at === v.at && x.text === v.text) : [v];
+    for (const member of group) this.op("forget", member, actor);
+    return v;
+  }
+
+  /** Plan or append reconciliation of legacy imports, preserving every existing replacement relation. */
+  dedupe(project: string, apply = false): { groups: { members: View[]; heads: string[]; target: string }[]; applied: number } {
+    const rows = this.live(), byId = new Map(rows.map(v => [v.id, v]));
+    const tuples = new Map<string, View[]>();
+    for (const v of rows) {
+      if (v.project !== project || v.source !== "claude-mem") continue;
+      const key = JSON.stringify([v.at, v.text]);
+      const group = tuples.get(key) ?? []; group.push(v); tuples.set(key, group);
+    }
+    const groups: { members: View[]; heads: string[]; target: string }[] = [];
+    for (const members of tuples.values()) {
+      if (members.length < 2) continue;
+      members.sort((a, b) => a.id.localeCompare(b.id));
+      const heads = members.filter(v => !v.supersededBy);
+      if (!heads.length) continue;
+      const ids = new Set(members.map(v => v.id));
+      const terminals = new Map<string, View>();
+      for (const v of members) {
+        let terminal = v;
+        const seen = new Set<string>();
+        while (terminal.supersededBy && !seen.has(terminal.id)) {
+          seen.add(terminal.id);
+          const next = byId.get(terminal.supersededBy);
+          if (!next) break;
+          terminal = next;
+        }
+        if (!terminal.supersededBy && !ids.has(terminal.id) && !terminal.local && (terminal.project === project || terminal.scope === "shared") && heads.every(h => h.scope !== "shared" || terminal.scope === "shared")) terminals.set(terminal.id, terminal);
+      }
+      const outside = [...terminals.values()].sort((a, b) => b.at.localeCompare(a.at) || b.id.localeCompare(a.id))[0];
+      if (!outside && heads.length === 1) continue;
+      groups.push({ members, heads: heads.map(v => v.id), target: outside?.id ?? heads[0]!.id });
+    }
+    let applied = 0;
+    if (apply) for (const group of groups) for (const head of group.heads) {
+      if (head === group.target) continue;
+      if (!this.supersede(head, group.target, "user", project)) throw new Error("memory dedupe replacement refused; rerun to inspect current relations");
+      applied++;
+    }
+    return { groups, applied };
+  }
   /** A short-term note kept short-term: it expires like any other and is never promoted (its demote entry stays local). */
   keepShort(id: string, actor: string): void { const v = this.get(id); if (v?.tier === "short" && v.local && v.expiresAt === null) this.op("demote", v, actor, this.until()); } // once: a deadline is never pushed out
   demote(id: string, actor: string, project?: string): View | undefined { const v = this.get(id, project); if (v?.tier === "long") this.op("demote", v, actor, this.until()); return v; }
@@ -533,13 +581,18 @@ export class MemoryStore {
     return gone.size;
   }
 
+  /** Index deferred writes before any note, goal or suggestion read. */
+  private ensureFresh(): void {
+    // Another process (a CLI, another project's hub, a sync) may have written since this one last read the segments.
+    if (this.stale || this.shape() !== this.seen) try { this.stale = false; this.refresh(); } catch { this.stale = true; /* still busy: the next read tries again */ }
+  }
+
   /**
    * What a read sees: rows that expired and promotions that became due while the store sat idle are settled first, so a
    * read, and the index after it, never differ from a rebuild.
    */
   private live(): View[] {
-    // Another process (a CLI, another project's hub, a sync) may have written since this one last read the segments.
-    if (this.stale || this.shape() !== this.seen) try { this.stale = false; this.refresh(); } catch { this.stale = true; /* still busy: the next read tries again */ }
+    this.ensureFresh();
     this.prune(); this.promoteHeld(); return this.views();
   }
   /** A write whose index update failed: the next read refreshes first. */
@@ -677,6 +730,7 @@ export class MemoryStore {
 
   /** Every long-term task with its derived state, links and lease, newest first; `project` keeps its own and shared ones. */
   goals(project?: string): GoalView[] {
+    this.ensureFresh();
     const now = this.now();
     const rows = this.db.query("SELECT * FROM goals").all() as { id: string; at: string; machine: string; project: string; scope: string; title: string; milestones: string; depends: string }[];
     const ops = this.db.query("SELECT op, at, machine, target, by FROM ops WHERE op IN ('goal_state', 'goal_link', 'lease', 'lease_force') ORDER BY at, id").all() as { op: string; at: string; machine: string; target: string; by: string | null }[];
@@ -726,6 +780,7 @@ export class MemoryStore {
     return s;
   }
   suggestions(project?: string): Suggestion[] {
+    this.ensureFresh();
     const visible = project ? new Set(this.list({ project, limit: Number.MAX_SAFE_INTEGER, includeSuperseded: true }).map((v) => v.id)) : undefined;
     const ops = this.db.query("SELECT id, op, at, target, by FROM ops WHERE op IN ('suggest', 'confirm', 'reject') ORDER BY at, id").all() as { id: string; op: string; at: string; target: string; by: string | null }[];
     const verdict = new Map<string, "confirmed" | "rejected">();

package/src/pi/extension.ts

@@ -23,6 +23,9 @@ let shellSeq = 0;
 let forcedFailure = "";
 let turnGeneration = 0;
 let sessionId = "";
+let pendingPromptId: string | undefined;
+let activePromptId: string | undefined;
+let settlement: Promise<void> | undefined;
 const maxSteps = Number(process.env.AGENTHUB_PI_MAX_STEPS ?? 30);
 let shutdown: (() => void) | undefined;
 let runtimeCtx: any;
@@ -66,7 +69,30 @@ async function poll(pi: ExtensionAPI): Promise<void> {
       if (!command) continue;
       try {
         if (command.type === "prompt" || command.type === "steer") {
+          if (command.type === "prompt") {
+            // Let our settled callback return to native Pi before the normal queued successor starts.
+            if (settlement) {
+              let timer: ReturnType<typeof setTimeout> | undefined;
+              try { await Promise.race([settlement, new Promise<void>(resolve => { timer = setTimeout(resolve, 5_000); })]); }
+              finally { clearTimeout(timer); }
+            }
+            if (settlement || runtimeCtx?.isIdle?.() !== true || (command.sessionId !== undefined && command.sessionId !== sessionId) || (command.generation !== undefined && command.generation !== turnGeneration)) {
+              await post("/ack", { id: command.id, ok: false, error: "Pi prompt was not inserted because its native session is no longer idle at the expected generation", refusal: { kind: "prompt_not_started", promptId: command.id, sessionId, generation: turnGeneration } });
+              continue;
+            }
+            // Pinned Pi 1.0.1 starts _runAgentPrompt synchronously before its first await.
+            // Keep this check and insertion in one JS turn; snapshots cannot reserve native idleness.
+            pendingPromptId = command.id;
+          }
           pi.sendMessage({ customType: "agent-hub", content: String(command.message ?? ""), display: true }, { triggerTurn: command.type === "prompt", deliverAs: command.type === "steer" ? "steer" : "followUp" });
+          if (command.type === "prompt" && runtimeCtx?.isIdle?.() !== false) {
+            // Another extension's async settled hook can make native Pi defer this insertion.
+            // Our callback barrier is not an atomic native reservation: keep that effect uncertain.
+            if (pendingPromptId === command.id) pendingPromptId = undefined;
+            if (activePromptId === command.id) activePromptId = undefined;
+            await post("/ack", { id: command.id, ok: false, error: "Pi prompt insertion did not synchronously claim a native turn", refusal: { kind: "prompt_uncertain", promptId: command.id, sessionId, generation: turnGeneration } });
+            continue;
+          }
         } else if (command.type === "get_session_state") {
           const entries = runtimeCtx.sessionManager.getEntries();
           await post("/ack", { id: command.id, ok: true, result: {
@@ -94,7 +120,7 @@ async function poll(pi: ExtensionAPI): Promise<void> {
           }
         }
         await post("/ack", { id: command.id, ok: true });
-      } catch (error) { await post("/ack", { id: command.id, ok: false, error: (error as Error).message }); }
+      } catch (error) { if (pendingPromptId === command.id) pendingPromptId = undefined; await post("/ack", { id: command.id, ok: false, error: (error as Error).message }); }
     } catch { await new Promise((resolve) => setTimeout(resolve, 250)); }
   }
 }
@@ -117,7 +143,7 @@ export default function(pi: ExtensionAPI): void {
     const state = ctx.sessionManager.getHeader();
     sessionId = String(state?.id ?? "");
     try {
-      const claimed = await post("/event", { type: "session_start", ownerToken, pid: process.pid, signature: processSignature(process.pid), sessionId: state?.id, sessionFile: ctx.sessionManager.getSessionFile(), approvalTurnAbort: typeof ctx.abort === "function" });
+      const claimed = await post("/event", { type: "session_start", ownerToken, pid: process.pid, signature: processSignature(process.pid), sessionId: state?.id, sessionFile: ctx.sessionManager.getSessionFile(), approvalTurnAbort: typeof ctx.abort === "function", fencedPrompt: true });
       if (claimed?.ok === false) { ctx.shutdown?.(); return; }
     } catch (error) { ctx.shutdown?.(); throw error; }
     if (!pollStarted) { pollStarted = true; void poll(pi); }
@@ -127,7 +153,7 @@ export default function(pi: ExtensionAPI): void {
     const text = message?.content?.filter((c: any) => c?.type === "text").map((c: any) => c.text).join("")?.trim();
     const failed = !!forcedFailure || message?.stopReason === "error";
     const cancelled = !forcedFailure && message?.stopReason === "aborted";
-    await post("/event", { type: "agent_end", generation: turnGeneration, text: text ?? "", failed, cancelled, ...(failed ? { error: forcedFailure || message?.errorMessage || message?.stopReason } : {}) });
+    await post("/event", { type: "agent_end", generation: turnGeneration, ...(activePromptId ? { promptId: activePromptId } : {}), text: text ?? "", failed, cancelled, ...(failed ? { error: forcedFailure || message?.errorMessage || message?.stopReason } : {}) });
   });
   pi.on("message_end", async (event: any) => {
     const tokens = assistantTokens(event.message);
@@ -142,7 +168,8 @@ export default function(pi: ExtensionAPI): void {
     lastActivity = now;
     try { await post("/event", { type: "activity" }); } catch { /* shutdown owns bridge cleanup */ }
   });
-  pi.on("agent_start", async () => { toolSteps = 0; forcedFailure = ""; turnGeneration++; await post("/event", { type: "agent_start", generation: turnGeneration }); });
+  // Native retries/continuations emit more starts before the one logical agent_settled.
+  pi.on("agent_start", async () => { toolSteps = 0; forcedFailure = ""; turnGeneration++; activePromptId = pendingPromptId ?? activePromptId; pendingPromptId = undefined; await post("/event", { type: "agent_start", generation: turnGeneration, ...(activePromptId ? { promptId: activePromptId } : {}) }); });
   pi.on("model_select", async (_event: any, ctx: any) => { if (ctx.model?.provider && ctx.model.provider !== "agent-hub-local") ctx.shutdown?.(); });
   pi.on("before_agent_start", async (event: any, ctx: any) => {
     if (ctx.model?.provider && ctx.model.provider !== "agent-hub-local") { ctx.abort?.(); return { systemPrompt: event.systemPrompt }; }
@@ -157,10 +184,18 @@ export default function(pi: ExtensionAPI): void {
     return undefined;
   });
   pi.on("agent_settled", async (_event: any, ctx: any) => {
+    let release!: () => void;
+    const current = new Promise<void>(resolve => { release = resolve; });
+    settlement = current;
     const entries = ctx.sessionManager?.getEntries?.() ?? [];
     const message = entries.slice().reverse().find((entry: any) => entry.type === "message" && entry.message?.role === "assistant")?.message;
     const text = message?.content?.filter((c: any) => c?.type === "text").map((c: any) => c.text).join("")?.trim();
-    await post("/event", { type: "agent_settled", generation: turnGeneration, ...(text ? { text } : {}) });
+    try { await post("/event", { type: "agent_settled", generation: turnGeneration, ...(activePromptId ? { promptId: activePromptId } : {}), ...(text ? { text } : {}) }); }
+    finally {
+      activePromptId = undefined;
+      // Release after this callback returns, not inside its awaited POST continuation.
+      setTimeout(() => { if (settlement === current) settlement = undefined; release(); }, 0);
+    }
   });
   pi.on("user_bash", async (event: any) => {
     const generation = turnGeneration, callSessionId = sessionId;

package/src/ui/index.html

@@ -515,7 +515,7 @@ function dropTarget(node, accepted, payload) {
     void action({...payload, id:card.id});
   });
 }
-function taskCard(task, card, stage, ids) {
+function taskCard(task, card, stage, ids, overdue) {
   const row = el('article', undefined, 'task-card'), head = el('div', undefined, 'row-head');
   row.tabIndex = 0; taskRows.set(task.id,row);
   const trackCard = on => { const sceneCard=officeCards.get(task.id);if(sceneCard)sceneCard.classList.toggle('office-spotlight',on); };
@@ -539,7 +539,7 @@ function taskCard(task, card, stage, ids) {
   if(task.external?.provider==='github'){const source=el('a','GitHub #'+task.external.issue);source.href=task.external.url;source.rel='noreferrer';source.target='_blank';row.append(source);}
   if(task.pinned)row.append(el('p','Pinned','meta'));
   if(task.plannedStart != null || task.due != null)row.append(el('p','Planned '+dateText(task.plannedStart)+' / due '+dateText(task.due),'meta'));
-  if(task.due != null && task.due<Date.now() && task.state!=='approved')row.append(badge('Overdue','warn'));
+  if(overdue)row.append(badge('Overdue','warn'));
   if(task.actualDates)row.append(el('p','Actual start '+dateText(task.actualDates.startedAt)+' / review '+dateText(task.actualDates.reviewAt)+' / done '+dateText(task.actualDates.doneAt),'meta'));
 
   const controls = el('div', undefined, 'actions');
@@ -567,6 +567,7 @@ function renderBoard(snapshot, peers, ids) {
   renderTaskProgress(progress);
   const stages = new Map(progress.stages.map(stage=>[stage.id,stage])), byId = new Map(snapshot.tasks.map(task=>[task.id,task]));
   const cards = new Map(model.columns.flatMap(column=>[...column.ready,...column.waiting]).map(card=>[card.id,card]));
+  const now = Date.now(), overdue = new Set(snapshot.tasks.filter(task=>task.due != null && task.due<now && task.state!=='approved').map(task=>task.id));
   boardViewState={snapshot,peers,ids,cards};
   renderPlanning(snapshot);
   const staged=$('backlog-proposal');staged.disabled=snapshot.boardCapabilities?.backlog!==true || !sameBoardContext(boardContext());
@@ -589,7 +590,7 @@ function renderBoard(snapshot, peers, ids) {
     }
     if (!ids.length) empty(target,'No peer status available.');
   });
-  update('tasks',[snapshot.tasks,peers,snapshot.boardCapabilities,taskFilter,ownerFilter,releaseFilter,lanes,showAllDone],target=>{
+  update('tasks',[snapshot.tasks,peers,snapshot.boardCapabilities,taskFilter,ownerFilter,releaseFilter,lanes,showAllDone,[...overdue]],target=>{
     taskRows.clear();
     const visible=snapshot.tasks.filter(task=>(!taskFilter || (taskFilter==='work' ? ['in_progress','changes_requested'].includes(task.state) : task.state===taskFilter)) && (!ownerFilter || task.owner===ownerFilter || task.reviewer===ownerFilter) && (!releaseFilter || task.release===Number(releaseFilter)));
     const visibleIds=new Set(visible.map(task=>task.id));
@@ -614,7 +615,7 @@ function renderBoard(snapshot, peers, ids) {
         if(hidden) ready=ready.slice(0,10);
         for(const [label,list] of [['Ready',ready],['Waiting',waiting]]) {
           if(column.id==='todo') box.append(el('h4',label+' ('+list.length+')'));
-          for(const card of list) box.append(taskCard(byId.get(card.id),card,stages.get(card.id),eligible));
+          for(const card of list) box.append(taskCard(byId.get(card.id),card,stages.get(card.id),eligible,overdue.has(card.id)));
         }
         if(!ready.length && !waiting.length) empty(box,'No tasks');
         if(hidden){const more=el('button','Show '+hidden+' older Done tasks');more.type='button';more.addEventListener('click',()=>{if(!boardViewState)return;showAllDone=true;renderBoard(boardViewState.snapshot,boardViewState.peers,boardViewState.ids)});box.append(more)}