@staix/agent-mem 0.8.0 → 0.10.0

package/src/memory/shard-sync.ts

@@ -1,5 +1,5 @@
 import { randomBytes, createHash } from "node:crypto";
-import { constants, closeSync, existsSync, fstatSync, fsyncSync, linkSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, readSync, rmSync, writeSync } from "node:fs";
+import { constants, closeSync, existsSync, fstatSync, fsyncSync, linkSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, readSync, renameSync, rmSync, writeSync } from "node:fs";
 import { join } from "node:path";
 import { canonicalJSON, fsyncDirectory, hashJSON, readProfileJSON } from "./generation.ts";
 import { generationSyncLock } from "./generation-sync.ts";
@@ -14,8 +14,14 @@ import type { Entry, MemoryStore } from "./store.ts";
 const OID = /^[a-f0-9]{40}$/, PACK = /^rows\/[a-f0-9]{64}\/[a-f0-9]{64}\.jsonl$/;
 const digest = (bytes: string | Uint8Array): string => createHash("sha256").update(bytes).digest("hex");
 const zero = "0".repeat(40);
+// The descriptor is at most 64 KiB and an original prune at most 16 KiB; keep receipt parsing bounded.
+const HOLD_MAX_BYTES = 128 * 1024;
 type PendingPrune = { plan: PrunePlan; row: PruneRow; line: string; offset: number; prefixHash: string };
-type Target = { store: MemoryStore; realm: ShardSyncRealm; rows: Map<string, ShardSyncRow>; fetched: Set<string>; sources: PruneSourceRow[]; pending: PendingPrune[]; generation: string; local?: string; remote?: string; commit?: string };
+type HoldSource = { ref: string; commit: string; pack: string; blob: string };
+type HoldReceipt = { schema: "agent-mem.prune-hold/v1"; remote: string; realm: ShardSyncRealm; receivingGeneration: string; row: PruneRow; payloadHash: string; source: HoldSource };
+type Hold = { file: string; bytes: Buffer };
+type SyncPhase = "published" | "hold-written" | "hold-installed" | "imported";
+type Target = { store: MemoryStore; realm: ShardSyncRealm; rows: Map<string, ShardSyncRow>; fetched: Set<string>; sources: PruneSourceRow[]; pending: PendingPrune[]; origins: Map<string, HoldSource>; holds: Hold[]; generation: string; local?: string; remote?: string; commit?: string };
 class SyncRefusal extends Error {}
 function refuse(reason: string): never { throw new SyncRefusal(reason); }
 function directory(path: string): void {
@@ -146,8 +152,10 @@ function provePrunes(targets: readonly Target[]): void {
     }
     const snapshot: PruneSnapshot = { rows: [...sources.values()], expiries: [] };
     const prunes = [...target.rows.values()].filter((row): row is PruneRow => row.op === "prune");
-    const proof = reducePruneRows(prunes.map(row => ({ row, placement: "synced" as const })), snapshot, target.generation);
-    if (proof.invalid || proof.pending.length) refuse(`${shardSyncLabel(target.realm)}: prune lacks complete public witnesses`);
+    for (const generation of new Set(prunes.map(row => row.generation))) {
+      const proof = reducePruneRows(prunes.filter(row => row.generation === generation).map(row => ({ row, placement: "synced" as const })), snapshot, generation);
+      if (proof.invalid || proof.pending.length) refuse(`${shardSyncLabel(target.realm)}: prune lacks complete public witnesses`);
+    }
   }
 }
 function installPack(store: MemoryStore, bytes: Buffer): void {
@@ -176,7 +184,7 @@ function importRows(target: Target): void {
   for (const pending of target.pending) {
     port.persistPrunePlan(pending.plan); port.appendPrune(pending.row, pending.line, pending.plan.seal); resumed.add(pending.row.id);
   }
-  for (const row of target.rows.values()) if (row.op === "prune") {
+  for (const row of target.rows.values()) if (row.op === "prune" && row.generation === target.generation) {
     if (resumed.has(row.id)) continue;
     // A transport imports an already-authored person row without changing its author or generation.
     // Native durable-plan append confirms fsync even for an already parsed id after a crash.
@@ -186,8 +194,104 @@ function importRows(target: Target): void {
   port.refresh();
 }
 
-/** Sync only the borrowed canonical project and user targets. The internal third argument is a test-only observer, never a CLI/SyncOptions port. */
-export async function syncShardedMemory(store: MemoryStore, opts: SyncOptions = {}, testOnlyUnexpectedError?: (error: unknown) => void): Promise<SyncResult> {
+/** Receipts are private, immutable transport metadata, outside every native generation reducer.
+ * ponytail: foreign targets remain visible; an explicit cross-generation apply protocol must
+ * re-prove witnesses and establish a compatible reader floor before lifting this hold ceiling. */
+const hasHoldPath = (file: string): boolean => lstatSync(file, { throwIfNoEntry: false }) !== undefined;
+function privateHoldPath(file: string, folder: boolean): void {
+  if (folder) directory(file); else regular(file);
+  if (lstatSync(file).mode & 0o077) refuse("shard sync prune holds require private permissions");
+}
+function checkPendingHold(file: string, bytes: Buffer): void {
+  privateHoldPath(file, false);
+  if (lstatSync(file).size > bytes.length || !readFileSync(file).equals(bytes.subarray(0, lstatSync(file).size))) refuse("shard sync partial prune hold conflicts with verified receipt");
+}
+function installHold(root: string, hold: Hold, phase?: (phase: SyncPhase) => void): void {
+  const parts = hold.file.slice(root.length + 1).split("/"), name = parts.pop()!;
+  let folder = root;
+  for (const part of parts) {
+    const parent = folder; folder = join(folder, part);
+    if (!hasHoldPath(folder)) mkdirSync(folder, { mode: 0o700 });
+    privateHoldPath(folder, true); fsyncDirectory(parent);
+  }
+  const file = join(folder, name), pending = file + ".pending";
+  if (hasHoldPath(file)) {
+    privateHoldPath(file, false);
+    if (!readFileSync(file).equals(hold.bytes)) refuse("shard sync immutable prune hold conflict");
+    const fd = openSync(file, constants.O_RDONLY | constants.O_NOFOLLOW); try { fsyncSync(fd); } finally { closeSync(fd); }
+    fsyncDirectory(folder); return;
+  }
+  if (hasHoldPath(pending)) checkPendingHold(pending, hold.bytes);
+  const fd = openSync(pending, constants.O_WRONLY | constants.O_CREAT | constants.O_NOFOLLOW, 0o600);
+  try {
+    // Interrupted private staging bytes may be completed; committed receipts are never rewritten.
+    let offset = 0; while (offset < hold.bytes.length) { const n = writeSync(fd, hold.bytes, offset, hold.bytes.length - offset, offset); if (n <= 0) refuse("shard sync prune hold write unavailable"); offset += n; }
+    fsyncSync(fd);
+  } finally { closeSync(fd); }
+  phase?.("hold-written");
+  // The transport mutation lock serializes this create-once rename. Unlike hard-link installation,
+  // a crash cannot leave a committed receipt with a second link that later fails validation.
+  if (hasHoldPath(file)) refuse("shard sync prune hold changed concurrently");
+  renameSync(pending, file); fsyncDirectory(folder); phase?.("hold-installed");
+}
+function holdWarning(targets: readonly Target[], root: string): string | undefined {
+  const warnings: string[] = [];
+  for (const target of targets) if (target.holds.length) {
+    const rows = [...target.rows.values()].filter((row): row is PruneRow => row.op === "prune" && row.generation !== target.generation);
+    const ids = [...new Set(rows.flatMap(row => row.targets.map(item => item.id)))].sort(), shown = ids.slice(0, 10);
+    const location = target.holds[0]!.file.slice(root.length + 1).split("/").slice(0, -2).join("/");
+    warnings.push(`${shardSyncLabel(target.realm)}: ${rows.length} foreign-generation prune(s) held, not applied; targets ${shown.join(",")}${ids.length > shown.length ? ` (+${ids.length - shown.length} more)` : ""} may remain visible; receipts shard-sync/${location}; bring this machine to the origin generation, or prune the entry here as the person`);
+  }
+  return warnings.length ? warnings.join("; ") : undefined;
+}
+
+type ProveHoldSource = (target: Target, receipt: HoldReceipt) => Promise<void>;
+async function prepareHold(root: string, url: string, target: Target, row: PruneRow, proveSource: ProveHoldSource): Promise<Hold> {
+  const source = target.origins.get(row.id);
+  if (!source || !target.remote || !target.fetched.has(row.id)) refuse(`${shardSyncLabel(target.realm)}: foreign prune has no fetched provenance`);
+  const receipt: HoldReceipt = { schema: "agent-mem.prune-hold/v1", remote: digest(url), realm: target.realm,
+    receivingGeneration: target.generation, row, payloadHash: hashJSON(row), source };
+  const folders = ["prune-holds", receipt.remote, digest(shardSyncRef(target.realm)), target.generation, row.generation];
+  let folder = root;
+  for (const name of folders) { folder = join(folder, name); if (hasHoldPath(folder)) privateHoldPath(folder, true); }
+  const file = join(folder, `${row.id}-${receipt.payloadHash}.json`);
+  let selected = receipt;
+  if (hasHoldPath(file)) {
+    privateHoldPath(file, false);
+    const value = readProfileJSON(file, HOLD_MAX_BYTES) as HoldReceipt | undefined;
+    if (!value || !value.source || Object.keys(value.source).length !== 4 || !OID.test(value.source.commit)
+      || !OID.test(value.source.blob) || !PACK.test(value.source.pack)
+      || canonicalJSON({ ...value, source }) !== canonicalJSON(receipt)) refuse(`${shardSyncLabel(target.realm)}: invalid prune hold receipt`);
+    // A receipt is evidence of a hold, never application authority. Recheck its original
+    // immutable source against this invocation's fully audited selected remote history.
+    await proveSource(target, value);
+    selected = value;
+  }
+  const bytes = Buffer.from(canonicalJSON(selected) + "\n");
+  if (bytes.length > HOLD_MAX_BYTES) refuse("shard sync prune hold exceeds metadata bound");
+  if (hasHoldPath(file) && !readFileSync(file).equals(bytes)) refuse("shard sync prune hold is not canonical");
+  if (hasHoldPath(file + ".pending")) checkPendingHold(file + ".pending", bytes);
+  return { file, bytes };
+}
+async function prepareHolds(targets: readonly Target[], root: string, url: string, proveSource: ProveHoldSource): Promise<void> {
+  for (const target of targets) {
+    target.holds = [];
+    for (const row of target.rows.values()) if (row.op === "prune" && row.generation !== target.generation) {
+      target.holds.push(await prepareHold(root, url, target, row, proveSource));
+    }
+  }
+}
+function mergePackOrigins(into: Map<string, HoldSource>, byRealm: Map<string, Map<string, HoldSource>>, rows: readonly ShardSyncRow[], source: HoldSource): void {
+  const first = byRealm.get(source.ref) ?? new Map<string, HoldSource>(); byRealm.set(source.ref, first);
+  // Oldest-first history keeps a receipt's source stable across tip advancement and partial-write retry.
+  for (const row of rows) {
+    if (!first.has(row.id)) first.set(row.id, source);
+    if (!into.has(row.id)) into.set(row.id, first.get(row.id)!);
+  }
+}
+
+/** Sync only borrowed canonical project/user targets. Internal error/phase observers are test-only, never CLI/SyncOptions ports. */
+export async function syncShardedMemory(store: MemoryStore, opts: SyncOptions = {}, testOnlyUnexpectedError?: (error: unknown) => void, testOnlyPhase?: (phase: SyncPhase) => void): Promise<SyncResult> {
   let pushed = false, releaseTransport: (() => void) | undefined, releaseSync: (() => void) | undefined;
   const releases: (() => void)[] = [], transient: string[] = [], temporary: string[] = [];
   const fail = (error: string): SyncResult => ({ ok: false, pushed, entries: 0, error });
@@ -216,7 +320,7 @@ export async function syncShardedMemory(store: MemoryStore, opts: SyncOptions =
     targets = borrowed.map(opened => {
       const profile = opened.profile;
       if (!profile.sharded || profile.kind !== "generation" || !profile.generation || !profile.shardUser && !profile.shardKey) refuse("shard sync target identity unavailable");
-      return { store: opened, realm: profile.shardUser ? { scope: "user" as const } : { scope: "project" as const, key: profile.shardKey! }, rows: new Map<string, ShardSyncRow>(), fetched: new Set<string>(), sources: [], pending: [], generation: profile.generation };
+      return { store: opened, realm: profile.shardUser ? { scope: "user" as const } : { scope: "project" as const, key: profile.shardKey! }, rows: new Map<string, ShardSyncRow>(), fetched: new Set<string>(), sources: [], pending: [], origins: new Map<string, HoldSource>(), holds: [], generation: profile.generation };
     });
     if (!targets.length || targets.length > 2 || targets.some(target => target.store.profile.home !== store.profile.home)
       || new Set(targets.map(target => shardSyncRef(target.realm))).size !== targets.length
@@ -280,12 +384,13 @@ export async function syncShardedMemory(store: MemoryStore, opts: SyncOptions =
       if (identity !== object) refuse("shard sync public blob identity mismatch");
       blobCache.set(object, bytes); return bytes;
     };
-    type History = { rows: Map<string, ShardSyncRow>; files: Map<string, Buffer> };
+    type History = { rows: Map<string, ShardSyncRow>; files: Map<string, Buffer>; origins: Map<string, HoldSource> };
     // Keep only requested tips. Per-commit full row maps would make append-only history quadratic in memory.
     const histories = new Map<string, History>(), audited = new Set<string>();
+    const firstOrigins = new Map<string, Map<string, HoldSource>>();
     const treeState = async (commit: string, target: Target): Promise<History> => {
       const entries = (await required(["ls-tree", "-r", "-z", commit], "shard sync tree unavailable")).split("\0").filter(Boolean);
-      const rows = new Map<string, ShardSyncRow>(), files = new Map<string, Buffer>();
+      const rows = new Map<string, ShardSyncRow>(), files = new Map<string, Buffer>(), origins = new Map<string, HoldSource>();
       for (const entry of entries) {
         const match = /^100644 blob ([a-f0-9]{40})\t(.+)$/.exec(entry);
         if (!match || match[2] !== "shard.json" && !PACK.test(match[2]!)) refuse(`${shardSyncLabel(target.realm)}: forbidden historical tree entry`);
@@ -298,10 +403,11 @@ export async function syncShardedMemory(store: MemoryStore, opts: SyncOptions =
           if (!pack) { pack = decodeShardPack(path, bytes, target.realm, target.generation); decoded.set(key, pack); }
           else if (!path.endsWith(`/${digest(bytes)}.jsonl`) || pack.some(row => path !== `rows/${digest(row.machine)}/${digest(bytes)}.jsonl`)) refuse(`${shardSyncLabel(target.realm)}: immutable pack path changed`);
           mergeRows(rows, pack, target.realm);
+          mergePackOrigins(origins, firstOrigins, pack, { ref: shardSyncRef(target.realm), commit, pack: path, blob: object });
         }
       }
       if (!files.has("shard.json")) refuse(`${shardSyncLabel(target.realm)}: historical descriptor missing`);
-      return { rows, files };
+      return { rows, files, origins };
     };
     const history = async (tip: string, target: Target): Promise<History> => {
       const key = `${shardSyncRef(target.realm)}:${tip}`, cached = histories.get(key); if (cached) return cached;
@@ -345,7 +451,7 @@ export async function syncShardedMemory(store: MemoryStore, opts: SyncOptions =
         if (target.local) await required(["merge-base", "--is-ancestor", target.local, tip], `${shardSyncLabel(target.realm)}: remote history is not fast-forward`);
         const remote = await history(tip, target); target.remote = tip;
         mergeRows(target.rows, Array.from(remote.rows.values()), target.realm);
-        for (const row of remote.rows.values()) target.fetched.add(row.id);
+        for (const row of remote.rows.values()) { target.fetched.add(row.id); target.origins.set(row.id, remote.origins.get(row.id)!); }
       }
     };
     const localTargets = () => {
@@ -385,10 +491,17 @@ export async function syncShardedMemory(store: MemoryStore, opts: SyncOptions =
         await history(target.commit, target);
       }
     };
-    localTargets(); await fetchTargets(); localTargets(); provePrunes(targets); check();
+    const proveHoldSource: ProveHoldSource = async (target, value) => {
+      await required(["merge-base", "--is-ancestor", value.source.commit, target.remote!], "shard sync prune hold source is not remote history");
+      const original = await history(value.source.commit, target), bytes = original.files.get(value.source.pack);
+      if (!bytes || createHash("sha1").update(`blob ${bytes.length}\0`).update(bytes).digest("hex") !== value.source.blob
+        || !decodeShardPack(value.source.pack, bytes, target.realm, target.generation).some(item => canonicalJSON(item) === canonicalJSON(value.row))
+        || value.source.ref !== shardSyncRef(target.realm)) refuse(`${shardSyncLabel(target.realm)}: prune hold source mismatch`);
+    };
+    localTargets(); await fetchTargets(); localTargets(); provePrunes(targets); await prepareHolds(targets, root, url, proveHoldSource); check();
     // Every selected realm, including its complete remote history/prunes, is preflighted before the first append or publication.
     for (let attempt = 0; attempt < 2; attempt++) {
-      if (attempt) { await fetchTargets(); localTargets(); provePrunes(targets); check(); }
+      if (attempt) { await fetchTargets(); localTargets(); provePrunes(targets); await prepareHolds(targets, root, url, proveHoldSource); check(); }
       await buildTargets(); check();
       const sent = await git(["push", "--atomic", "--no-follow-tags", "-q", "origin", ...targets.map(target => `${target.commit!}:${shardSyncRef(target.realm)}`)]);
       if (sent.code === 0) pushed = true;
@@ -396,13 +509,18 @@ export async function syncShardedMemory(store: MemoryStore, opts: SyncOptions =
       if (sent.code === 0) {
         pushed = true;
         // No local append before a successful atomic publication: a raced foreign prune can still refuse the entire retry safely.
-        localTargets(); provePrunes(targets); check();
+        localTargets(); provePrunes(targets); check(); testOnlyPhase?.("published");
+        // No selected ordinary/native imports can precede durable receipts for every foreign prune.
+        for (const target of targets) for (const hold of target.holds) installHold(root, hold, testOnlyPhase);
+        check();
         for (const target of targets) {
           assertCuratedShardPaths(target.store.profile.home, target.realm.scope === "user" ? { user: true } : { project: target.realm.key });
-          importRows(target);
+          importRows(target); testOnlyPhase?.("imported");
         }
         for (const target of targets) await required(["update-ref", "--no-deref", shardSyncRef(target.realm), target.commit!, target.local ?? zero], "shard sync cached ref changed concurrently");
-        return { ok: true, pushed, entries: targets.reduce((n, target) => n + [...target.rows.values()].filter(row => row.op === "note").length, 0) };
+        const warning = holdWarning(targets, root);
+        return { ok: true, pushed, entries: targets.reduce((n, target) => n + [...target.rows.values()].filter(row => row.op === "note").length, 0),
+          ...(warning ? { warning } : {}) };
       }
       if (opts.signal?.aborted) return fail("stopped");
     }

package/src/session-brief-worker.ts

@@ -50,7 +50,11 @@ if (import.meta.main) {
     if (!(HOOK_EVENTS as readonly string[]).includes(event)) stop();
     const expectedScope = hookCaptureScope(options.cwd, options.base!);
     let project: string;
-    try { project = resolveAlias(options.base!, await resolveHookProjectAsync({ cwd: options.cwd, base: options.base!, scope: expectedScope, timeRemaining: remaining, maintainCache: event !== "SessionStart" }, nativeUsage)); }
+    // Overlap the shared resolver's existing origin/metadata reads on a cold cache;
+    // serial native launches can exhaust every hook before any binding or replay is published.
+    // ponytail: cold identity must still fit one hook deadline. Revalidated durable
+    // identity progress is the upgrade if slower native reads keep exhausting that slice.
+    try { project = resolveAlias(options.base!, await resolveHookProjectAsync({ cwd: options.cwd, base: options.base!, scope: expectedScope, timeRemaining: remaining, maintainCache: event !== "SessionStart", prefetch: true }, nativeUsage)); }
     catch {
       if (expectedScope !== undefined) quarantineHookScope({ cwd: options.cwd, base: options.base!, scope: expectedScope });
       project = stop();

package/src/setup-agy.ts

@@ -0,0 +1,9 @@
+import type { ConfigImage } from "./setup-owned.ts";
+import { createJsonMcpCodec } from "./setup-json.ts";
+
+// ponytail: Antigravity setup supports strict JSON only. JSONC needs a comment-aware
+// lexical view and trailing-comma ownership before byte-preserving edits can support it.
+const codec = createJsonMcpCodec({ canonicalKey: "mcpServers", label: "Antigravity strict JSON" });
+export function readAgyMcp(image: ConfigImage): unknown { return codec.read(image); }
+export function putAgyMcp(image: ConfigImage, value: unknown): ConfigImage { return codec.put(image, value); }
+export function restoreAgyMcp(before: ConfigImage, after: ConfigImage, current: ConfigImage): ConfigImage { return codec.restore(before, after, current); }

package/src/setup-jcode.ts

@@ -0,0 +1,7 @@
+import type { ConfigImage } from "./setup-owned.ts";
+import { createJsonMcpCodec } from "./setup-json.ts";
+
+const codec = createJsonMcpCodec({ canonicalKey: "servers", aliases: ["mcpServers"], label: "Jcode" });
+export function readJcodeMcp(image: ConfigImage): unknown { return codec.read(image); }
+export function putJcodeMcp(image: ConfigImage, value: unknown): ConfigImage { return codec.put(image, value); }
+export function restoreJcodeMcp(before: ConfigImage, after: ConfigImage, current: ConfigImage): ConfigImage { return codec.restore(before, after, current); }

package/src/setup-json.ts

@@ -0,0 +1,151 @@
+import { isDeepStrictEqual } from "node:util";
+import type { ConfigImage } from "./setup-owned.ts";
+import { SETUP_CONFIG_BYTES } from "./setup-toml.ts";
+
+interface Member { key: string; keyStart: number; keyEnd: number; valueStart: number; valueEnd: number; comma?: number }
+interface ObjectSpan { close: number; members: Member[] }
+interface Document { text: string; root: ObjectSpan; container?: Member; servers?: ObjectSpan; owned?: Member }
+interface Edit { start: number; end: number; text: string }
+const decode = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+const same = (a: ConfigImage, b: ConfigImage) => a.bytes === b.bytes && a.mode === b.mode;
+export interface JsonMcpCodecOptions { canonicalKey: string; aliases?: readonly string[]; label: string }
+
+/** Strict JSON only. Shared lexical edits never re-render unrelated configuration data. */
+export function createJsonMcpCodec(options: JsonMcpCodecOptions) {
+  const { canonicalKey, label } = options, keys = new Set([canonicalKey, ...(options.aliases ?? [])]);
+  const fail = (): never => { throw Error(`setup ${label} MCP configuration unavailable or ambiguous; no configuration changed`); };
+  const whitespace = (text: string, start: number) => { let at = start; while (at < text.length && /[ \t\r\n]/.test(text[at]!)) at++; return at; };
+  function stringEnd(text: string, start: number): number {
+    let at = start + 1;
+    while (at < text.length) { if (text[at] === "\\") at += 2; else if (text[at++] === '"') return at; }
+    return fail();
+  }
+  /** JSON.parse validates syntax first; this scanner retains only lexical edit boundaries. */
+  function valueEnd(text: string, start: number): number {
+    if (text[start] === '"') return stringEnd(text, start);
+    if (text[start] === "{" || text[start] === "[") {
+      let depth = 0, at = start;
+      while (at < text.length) {
+        const char = text[at]!;
+        if (char === '"') { at = stringEnd(text, at); continue; }
+        if (char === "{" || char === "[") depth++;
+        else if ((char === "}" || char === "]") && --depth === 0) return at + 1;
+        at++;
+      }
+      return fail();
+    }
+    let at = start; while (at < text.length && !/[ \t\r\n,}\]]/.test(text[at]!)) at++; return at;
+  }
+  function objectSpan(text: string, start: number): ObjectSpan {
+    if (text[start] !== "{") return fail();
+    const members: Member[] = []; let at = whitespace(text, start + 1);
+    while (text[at] !== "}") {
+      const keyStart = at, keyEnd = stringEnd(text, at), key: unknown = JSON.parse(text.slice(keyStart, keyEnd));
+      if (typeof key !== "string") return fail();
+      const valueStart = whitespace(text, whitespace(text, keyEnd) + 1), end = valueEnd(text, valueStart), next = whitespace(text, end);
+      const comma = text[next] === "," ? next : undefined;
+      members.push({ key, keyStart, keyEnd, valueStart, valueEnd: end, ...(comma === undefined ? {} : { comma }) });
+      at = comma === undefined ? next : whitespace(text, comma + 1);
+    }
+    return { close: at, members };
+  }
+  /** Only the owned value requires recursive key uniqueness; unrelated JSON stays opaque. */
+  function uniqueOwnedKeys(text: string, member: Member): void {
+    const objects: (Set<string> | null)[] = [];
+    let at = member.valueStart;
+    while (at < member.valueEnd) {
+      const char = text[at]!;
+      if (char === '"') {
+        const end = stringEnd(text, at), current = objects.at(-1);
+        if (text[whitespace(text, end)] === ":" && current) {
+          const key = JSON.parse(text.slice(at, end)) as string;
+          if (current.has(key)) return fail();
+          current.add(key);
+        }
+        at = end;
+      } else {
+        if (char === "{") objects.push(new Set());
+        else if (char === "[") objects.push(null);
+        else if (char === "}" || char === "]") objects.pop();
+        at++;
+      }
+    }
+  }
+  function document(image: ConfigImage): Document {
+    let text = "{}";
+    if (image.bytes !== null) {
+      if (image.bytes.length > Math.ceil(SETUP_CONFIG_BYTES / 3) * 4) return fail();
+      const bytes = Buffer.from(image.bytes, "base64");
+      if (bytes.toString("base64") !== image.bytes || bytes.length > SETUP_CONFIG_BYTES) return fail();
+      try { text = decode.decode(bytes); } catch { return fail(); }
+    }
+    let value: unknown; try { value = JSON.parse(text); } catch { return fail(); }
+    if (!value || typeof value !== "object" || Array.isArray(value)) return fail();
+    const root = objectSpan(text, whitespace(text, 0));
+    const containers = root.members.filter(member => keys.has(member.key));
+    if (containers.length > 1) return fail();
+    const container = containers[0]; if (!container) return { text, root };
+    const servers = objectSpan(text, container.valueStart), owned = servers.members.filter(member => member.key === "amem");
+    if (owned.length > 1) return fail();
+    if (owned[0]) uniqueOwnedKeys(text, owned[0]);
+    return { text, root, container, servers, ...(owned[0] ? { owned: owned[0] } : {}) };
+  }
+  const entry = (doc: Document): unknown => doc.owned ? JSON.parse(doc.text.slice(doc.owned.valueStart, doc.owned.valueEnd)) : undefined;
+  function readMcp(image: ConfigImage): unknown { return entry(document(image)); }
+
+  function insert(object: ObjectSpan, text: string): Edit {
+    const last = object.members.at(-1);
+    const at = last?.valueEnd ?? object.close;
+    return { start: at, end: at, text: `${last ? "," : ""}${text}` };
+  }
+  function remove(object: ObjectSpan, member: Member): Edit {
+    if (member.comma !== undefined) return { start: member.keyStart, end: member.comma + 1, text: "" };
+    const previous = object.members[object.members.indexOf(member) - 1];
+    return { start: previous?.comma ?? member.keyStart, end: member.valueEnd, text: "" };
+  }
+  function publish(image: ConfigImage, doc: Document, edits: Edit[]): ConfigImage {
+    let text = doc.text;
+    for (const edit of edits.sort((a, b) => b.start - a.start)) text = text.slice(0, edit.start) + edit.text + text.slice(edit.end);
+    if (text === doc.text) return image;
+    if (Buffer.byteLength(text) > SETUP_CONFIG_BYTES) return fail();
+    const result = { bytes: Buffer.from(text).toString("base64"), mode: image.mode };
+    document(result); return result;
+  }
+  function put(image: ConfigImage, value: unknown, options: { key?: string; keepEmpty?: boolean; rawValue?: string; emptyContainer?: string } = {}): ConfigImage {
+    const doc = document(image), edits: Edit[] = [], key = options.key ?? canonicalKey;
+    if (!doc.container) {
+      if (value === undefined && !options.keepEmpty) return image;
+      const body = value === undefined ? options.emptyContainer ?? "{}" : `{"amem":${options.rawValue ?? JSON.stringify(value)}}`;
+      edits.push(insert(doc.root, `${JSON.stringify(key)}:${body}`));
+    } else if (value === undefined && !options.keepEmpty && doc.servers!.members.every(member => member.key === "amem")) {
+      edits.push(remove(doc.root, doc.container));
+    } else {
+      if (doc.container.key !== key) edits.push({ start: doc.container.keyStart, end: doc.container.keyEnd, text: JSON.stringify(key) });
+      if (value === undefined && doc.owned) edits.push(remove(doc.servers!, doc.owned));
+      else if (value !== undefined && !isDeepStrictEqual(entry(doc), value)) {
+        const rendered = options.rawValue ?? JSON.stringify(value); if (rendered === undefined) return fail();
+        edits.push(doc.owned ? { start: doc.owned.valueStart, end: doc.owned.valueEnd, text: rendered } : insert(doc.servers!, `"amem":${rendered}`));
+      }
+    }
+    return publish(image, doc, edits);
+  }
+  /** Canonicalize only the owned container key; all unrelated bytes remain untouched. */
+  function putMcp(image: ConfigImage, value: unknown): ConfigImage { return put(image, value); }
+
+  /** Restore the owned entry (and our alias rename), preserving unrelated lexical edits. */
+  function restoreMcp(before: ConfigImage, after: ConfigImage, current: ConfigImage): ConfigImage {
+    const original = document(before), installed = document(after), live = document(current);
+    if (same(current, after)) return before;
+    if (same(current, before)) return current;
+    const previous = entry(original), expected = entry(installed), present = entry(live);
+    const previousRestored = isDeepStrictEqual(present, previous);
+    const pendingLayout = !!original.container && !!installed.container && original.container.key !== installed.container.key && live.container?.key === installed.container.key;
+    if (previousRestored && !pendingLayout) return current;
+    if (!previousRestored && !isDeepStrictEqual(present, expected)) throw Error(`setup-owned ${label} MCP entry changed; refusing to overwrite it`);
+    const restored = put(current, previous, { key: original.container?.key ?? canonicalKey, keepEmpty: !!original.container && !original.servers!.members.length,
+      ...(original.owned ? { rawValue: original.text.slice(original.owned.valueStart, original.owned.valueEnd) } : {}),
+      ...(original.container && !original.servers!.members.length ? { emptyContainer: original.text.slice(original.container.valueStart, original.container.valueEnd) } : {}) });
+    return before.bytes === null && !document(restored).root.members.length ? { bytes: null, mode: current.mode } : restored;
+  }
+  return { read: readMcp, put: putMcp, restore: restoreMcp };
+}

package/src/setup-owned.ts

@@ -1,5 +1,7 @@
 import { isDeepStrictEqual } from "node:util";
 import { SETUP_CONFIG_BYTES, setTomlPath, updateTomlArray } from "./setup-toml.ts";
+import { readJcodeMcp, putJcodeMcp, restoreJcodeMcp } from "./setup-jcode.ts";
+import { readAgyMcp, putAgyMcp, restoreAgyMcp } from "./setup-agy.ts";
 export interface ConfigImage { bytes: string | null; mode: number }
 export const sameImage = (a: ConfigImage, b: ConfigImage): boolean => a.bytes === b.bytes && a.mode === b.mode;
 const text = (image: ConfigImage) => image.bytes === null ? "" : new TextDecoder("utf-8", { fatal: true }).decode(Buffer.from(image.bytes, "base64"));
@@ -15,10 +17,14 @@ function finishJson(value: Record<string, unknown>, current: ConfigImage, origin
   return rendered(output, current);
 }
 export function mcpRecord(target: string, image: ConfigImage): unknown {
+  if (target === "agy") return readAgyMcp(image);
+  if (target === "jcode") return readJcodeMcp(image);
   const doc = target === "codex" ? toml(image) : json(image), servers = doc[target === "codex" ? "mcp_servers" : "mcpServers"];
   return servers === undefined ? undefined : object(servers).amem;
 }
 export function putMcpRecord(target: string, current: ConfigImage, value: unknown): ConfigImage {
+  if (target === "agy") return putAgyMcp(current, value);
+  if (target === "jcode") return putJcodeMcp(current, value);
   if (target === "codex") return rendered(setTomlPath(text(current), ["mcp_servers", "amem"], value), current);
   const doc = json(current), servers = { ...object(doc.mcpServers ?? {}) };
   if (value === undefined) delete servers.amem; else servers.amem = value;
@@ -26,19 +32,24 @@ export function putMcpRecord(target: string, current: ConfigImage, value: unknow
   return finishJson(doc, current, { bytes: null, mode: current.mode });
 }
 interface Hook { event: string; matcher: string; core: Record<string, unknown>; id: string; command: string }
+// QwenLM/qwen-code 1ce1731 packages/core/src/hooks/types.ts HOOKS_CONFIG_FIELDS.
+// These are user-owned controls, not event groups; setup never enables or restores them.
+const qwenHookControls = new Set(["enabled", "disabled", "notifications"]);
 const matcher = (value: unknown) => value === undefined || value === "" || value === "*" ? "*" : String(value);
-function hook(event: string, group: Record<string, unknown>, value: unknown): Hook | undefined {
+function hook(event: string, group: Record<string, unknown>, value: unknown, strict = false): Hook | undefined {
   const h = object(value);
-  const core = h.type === "command" ? { type: h.type, command: h.command, ...(h.timeout !== undefined ? { timeout: h.timeout } : {}) }
+  const core = h.type === "command" && !strict ? { type: h.type, command: h.command, ...(h.timeout !== undefined ? { timeout: h.timeout } : {}) }
     : Object.fromEntries(Object.entries(h).filter(([key]) => !["trusted_hash", "trustedHash"].includes(key)).sort(([a], [b]) => a.localeCompare(b)));
   const match = matcher(group.matcher);
-  return { event, matcher: match, core, command: typeof h.command === "string" ? h.command : "", id: JSON.stringify([event, match, core]) };
+  const groupCore = strict ? Object.fromEntries(Object.entries(group).filter(([key]) => !["matcher", "hooks"].includes(key)).sort(([a], [b]) => a.localeCompare(b))) : undefined;
+  return { event, matcher: match, core, command: typeof h.command === "string" ? h.command : "", id: JSON.stringify([event, match, core, ...(strict ? [groupCore] : [])]) };
 }
-function hooks(doc: Record<string, unknown>): Hook[] {
+function hooks(doc: Record<string, unknown>, strict = false): Hook[] {
   const out: Hook[] = [];
   for (const [event, raw] of Object.entries(object(doc.hooks ?? {}))) {
+    if (strict && qwenHookControls.has(event)) continue;
     if (!Array.isArray(raw)) throw Error("setup hook groups must be arrays");
-    for (const value of raw) { const group = object(value); if (!Array.isArray(group.hooks)) throw Error("setup hook handlers must be arrays"); for (const h of group.hooks) { const row = hook(event, group, h); if (row) out.push(row); } }
+    for (const value of raw) { const group = object(value); if (!Array.isArray(group.hooks)) throw Error("setup hook handlers must be arrays"); for (const h of group.hooks) { const row = hook(event, group, h, strict); if (row) out.push(row); } }
   }
   return out;
 }
@@ -46,8 +57,8 @@ function added<T>(before: T[], after: T[], key: (value: T) => string): T[] {
   const counts = new Map<string, number>(); for (const row of before) counts.set(key(row), (counts.get(key(row)) ?? 0) + 1);
   return after.filter(row => { const id = key(row), n = counts.get(id) ?? 0; if (!n) return true; counts.set(id, n - 1); return false; });
 }
-function restoreJsonHooks(before: ConfigImage, after: ConfigImage, current: ConfigImage): ConfigImage {
-  const b = json(before), a = json(after), c = json(current), original = hooks(b), installed = hooks(a), live = hooks(c);
+function restoreJsonHooks(before: ConfigImage, after: ConfigImage, current: ConfigImage, strict = false): ConfigImage {
+  const b = json(before), a = json(after), c = json(current), original = hooks(b, strict), installed = hooks(a, strict), live = hooks(c, strict);
   const ours = added(original, installed, row => row.id), remaining = new Map<string, number>();
   for (const row of ours) {
     const count = live.filter(value => value.id === row.id).length;
@@ -56,11 +67,12 @@ function restoreJsonHooks(before: ConfigImage, after: ConfigImage, current: Conf
   }
   const groups = object(c.hooks ?? {});
   for (const [event, raw] of Object.entries(groups)) {
+    if (strict && qwenHookControls.has(event)) continue;
     const next: unknown[] = [];
     for (const value of raw as unknown[]) {
       const group = object(value); let removed = false;
       const handlers = (group.hooks as unknown[]).filter(h => {
-        const row = hook(event, group, h), n = row && (remaining.get(row.id) ?? 0);
+        const row = hook(event, group, h, strict), n = row && (remaining.get(row.id) ?? 0);
         if (!row || !n) return true; remaining.set(row.id, n - 1); removed = true; return false;
       });
       if (handlers.length || !removed) next.push({ ...group, hooks: handlers });
@@ -88,21 +100,26 @@ function restoreKimi(before: ConfigImage, after: ConfigImage, current: ConfigIma
   if (before.bytes === null && Object.keys(object(Bun.TOML.parse(result))).length === 0) return { ...before, mode: current.mode };
   return rendered(result, current);
 }
+function restoreMcpOwned(target: string, before: ConfigImage, after: ConfigImage, current: ConfigImage): ConfigImage {
+  const b = mcpRecord(target, before), a = mcpRecord(target, after), c = mcpRecord(target, current);
+  if (isDeepStrictEqual(c, b) && !(target === "codex" && b === undefined && toml(before).mcp_servers === undefined && toml(current).mcp_servers !== undefined && Object.keys(object(toml(current).mcp_servers)).length === 0)) return current;
+  if (c !== undefined && !isDeepStrictEqual(c, a)) throw Error("setup-owned MCP entry changed; refusing to overwrite it");
+  let result = putMcpRecord(target, current, b);
+  if (target === "codex" && b === undefined && toml(before).mcp_servers === undefined && Object.keys(object(toml(result).mcp_servers ?? {})).length === 0) result = rendered(setTomlPath(text(result), ["mcp_servers"], undefined), current);
+  if (target !== "codex" && json(before).mcpServers !== undefined && json(result).mcpServers === undefined) { const value = json(result); value.mcpServers = {}; result = rendered(JSON.stringify(value, null, 2) + "\n", current); }
+  if (result.bytes === null && before.bytes !== null) return target === "codex" ? rendered("", current) : finishJson({}, current, before);
+  if (before.bytes === null && Object.keys(target === "codex" ? toml(result) : json(result)).length === 0) return { ...before, mode: current.mode };
+  return result;
+}
 /** Exact restore when untouched; otherwise reverse only this receipt's managed entry/rows. */
 export function restoreOwned(target: string, index: number, before: ConfigImage, after: ConfigImage, current: ConfigImage): ConfigImage {
+  if (target === "agy" && index === 0) return restoreAgyMcp(before, after, current);
+  if (target === "jcode" && index === 0) return restoreJcodeMcp(before, after, current);
   if (sameImage(current, after)) return before;
   if (sameImage(current, before)) return current;
-  if (index === 0) {
-    const b = mcpRecord(target, before), a = mcpRecord(target, after), c = mcpRecord(target, current);
-    if (isDeepStrictEqual(c, b) && !(target === "codex" && b === undefined && toml(before).mcp_servers === undefined && toml(current).mcp_servers !== undefined && Object.keys(object(toml(current).mcp_servers)).length === 0)) return current;
-    if (c !== undefined && !isDeepStrictEqual(c, a)) throw Error("setup-owned MCP entry changed; refusing to overwrite it");
-    let result = putMcpRecord(target, current, b);
-    if (target === "codex" && b === undefined && toml(before).mcp_servers === undefined && Object.keys(object(toml(result).mcp_servers ?? {})).length === 0) result = rendered(setTomlPath(text(result), ["mcp_servers"], undefined), current);
-    if (target !== "codex" && json(before).mcpServers !== undefined && json(result).mcpServers === undefined) { const value = json(result); value.mcpServers = {}; result = rendered(JSON.stringify(value, null, 2) + "\n", current); }
-    if (result.bytes === null && before.bytes !== null) return target === "codex" ? rendered("", current) : finishJson({}, current, before);
-    if (before.bytes === null && Object.keys(target === "codex" ? toml(result) : json(result)).length === 0) return { ...before, mode: current.mode };
-    return result;
-  }
+  // Qwen keeps both managed surfaces in one settings file and one receipt image.
+  if (target === "qwen" && index === 0) return restoreJsonHooks(before, after, restoreMcpOwned(target, before, after, current), true);
+  if (index === 0) return restoreMcpOwned(target, before, after, current);
   if (target === "claude" || target === "codex") return restoreJsonHooks(before, after, current);
   if (target === "kimi") return restoreKimi(before, after, current);
   if (current.bytes === after.bytes) return { ...before, mode: current.mode };
@@ -110,6 +127,10 @@ export function restoreOwned(target: string, index: number, before: ConfigImage,
   throw Error("setup-owned Pi extension changed; refusing to overwrite it");
 }
 export function managedAfter(target: string, index: number, before: ConfigImage, after: ConfigImage, current: ConfigImage): boolean {
+  if (target === "qwen" && index === 0) {
+    const needed = added(hooks(json(before), true), hooks(json(after), true), row => row.id), live = hooks(json(current), true);
+    return isDeepStrictEqual(mcpRecord(target, after), mcpRecord(target, current)) && needed.every(row => live.some(value => value.id === row.id));
+  }
   if (index === 0) return isDeepStrictEqual(mcpRecord(target, after), mcpRecord(target, current));
   if (target === "claude" || target === "codex") {
     const needed = added(hooks(json(before)), hooks(json(after)), row => row.id), live = hooks(json(current));