@staix/agent-mem 0.9.1 → 0.10.0

package/src/memory/eval.ts

@@ -88,7 +88,7 @@ export interface EvalQuestionResult {
 /** `recall` and `hit` are null when no question counts (no answerable question), never 0: an empty average is not a measured zero. */
 export interface EvalAggregate { questions: number; recall: Record<number, number | null>; hit: Record<number, number | null>; mrr: number | null }
 export interface EvalReport {
-  /** The search that was scored: the ranked, project-scoped `store.search` (BM25 with tier and recency weights) that MCP and hub recall use, NOT the `amem search` command's substring filter. */
+  /** Ranked project-scoped `store.search` (BM25 with tier and recency weights), the engine used by default current curated `amem search`; `--filter` keeps legacy substring matching. */
   engine: string;
   ks: number[];
   /** Every question. A question whose expected entry is not in the store scores 0, as a search that cannot find it would. */
@@ -142,7 +142,7 @@ const pct = (value: number | null): string => value === null ? "  n/a" : value.t
 export function evalText(report: EvalReport, label: string): string {
   const head = (name: string, row: EvalAggregate) => `${name.padEnd(11)} ${String(row.questions).padStart(4)}  ${report.ks.map(k => `${pct(row.recall[k] ?? null)}/${pct(row.hit[k] ?? null)}`.padStart(13)).join(" ")}  ${pct(row.mrr).padStart(6)}`;
   return [
-    `eval: ${label} (${report.engine === "substring" ? "substring fallback" : "ranked store.search, engine " + report.engine}; this is the ranking MCP and hub recall use, not the \`amem search\` filter)`,
+    `eval: ${label} (${report.engine === "substring" ? "substring fallback" : "ranked store.search, engine " + report.engine}; same ranked search path as default \`amem search\`; \`--filter\` keeps legacy substring matching)`,
     `${"".padEnd(11)} ${"n".padStart(4)}  ${report.ks.map(k => `@${k} recall/hit`.padStart(13)).join(" ")}  ${"MRR".padStart(6)}`,
     head("all", report.all),
     head("answerable", report.answerable),

package/src/memory/policy.ts

@@ -99,6 +99,7 @@ function literals(value: unknown, label: string): string[] {
 
 function defaultPii(text: string): boolean {
   if (/\b(?:\d{6}-\d{7}|\d{3}-\d{2}-\d{4})\b/.test(text)) return true;
+  if (!text.includes("@")) return false;
   // Bound each email candidate before matching; arbitrary user regexes are never run.
   for (const token of text.split(/[\s<>()\[\]{}",;:]+/)) if (token.includes("@")) {
     if (token.length > 320 || /[a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{2,}/i.test(token)) return true;
@@ -106,6 +107,51 @@ function defaultPii(text: string): boolean {
   return false;
 }
 
+interface DefaultPathProbe { names: string[]; segments: string[] }
+
+/** A mandatory literal, not a deny verdict. All other regex grammar uses the canonical checker. */
+function necessaryDenyLiteral(source: string): string | undefined {
+  if (source.length > 256) return;
+  let index = source.startsWith("^") ? 1 : 0, literal = "";
+  for (; index < source.length; index++) {
+    const character = source[index]!;
+    if (/^[A-Za-z0-9_-]$/.test(character)) literal += character;
+    else if (character === "\\" && source[index + 1] === ".") { literal += "."; index++; }
+    else break;
+  }
+  const rest = source.slice(index);
+  return literal && (rest === "" || rest === "$" || rest === "(\\.|$)") ? literal : undefined;
+}
+
+/** Do not add getter reads or assumptions about malformed/mutated exported defaults. */
+function plainDefaultStrings(values: readonly string[]): boolean {
+  if (types.isProxy(values) || !Array.isArray(values) || Object.getPrototypeOf(values) !== Array.prototype || values.length > 64 || Object.getOwnPropertySymbols(values).length || "toJSON" in values) return false;
+  if (Object.getOwnPropertyNames(values).length !== values.length + 1) return false;
+  for (let index = 0; index < values.length; index++) {
+    const descriptor = Object.getOwnPropertyDescriptor(values, String(index));
+    if (!descriptor || !("value" in descriptor) || typeof descriptor.value !== "string") return false;
+  }
+  return true;
+}
+
+function defaultPathProbe(): DefaultPathProbe | undefined {
+  const needles = DENY_NAMES.map(necessaryDenyLiteral);
+  return needles.every((value): value is string => value !== undefined) ? { names: needles, segments: [...DENY_SEGMENTS] } : undefined;
+}
+
+function containsPathLiteral(text: string, probe: DefaultPathProbe, deny: readonly string[]): boolean {
+  return text.includes("/.") || text.includes("//") || deny.some(entry => text.includes(entry))
+    || probe.segments.some(entry => text.includes(entry)) || probe.names.some(needle => text.includes(needle));
+}
+
+function mayNeedPathCheck(text: string, probe: DefaultPathProbe | undefined, deny: readonly string[]): boolean {
+  if (!probe || containsPathLiteral(text, probe, deny)) return true;
+  // Raw/node/token paths are substrings of text; pathCandidates takes substrings after NFC.
+  // Inspect both: removing ignorables or lowercasing after NFKC can leave a non-NFC result.
+  const canonical = text.normalize("NFC");
+  return canonical !== text && containsPathLiteral(canonical, probe, deny);
+}
+
 /** No filesystem, model, network or storage work occurs while constructing or screening this policy. */
 export function createStandalonePolicy(options: StandalonePolicyOptions = {}): StandalonePolicy {
   if (!options || typeof options !== "object" || types.isProxy(options) || Object.getPrototypeOf(options) !== Object.prototype || Object.getOwnPropertySymbols(options).length) throw new Error("invalid standalone policy options");
@@ -119,16 +165,23 @@ export function createStandalonePolicy(options: StandalonePolicyOptions = {}): S
   // Evict the batch when full; a measured need for better hit rates can upgrade this to an LRU.
   const textChecks = new Map<string, boolean>(); let textBytes = 0;
   let defaultDenyRevision = "";
+  // ponytail: the negative probe supports at most 64 dense default entries and 256-character simple name sources.
+  // Everything else falls back; extend the grammar only with differential proof, never an approximate verdict.
+  let pathProbe: DefaultPathProbe | undefined;
+  let defaultsWerePlain = false;
   const publicText = (text: string): boolean => {
     const cached = textChecks.get(text);
     if (cached !== undefined) return cached;
     const check = () => {
-      if (looksSecret(text) || looksSecret(text.replace(/["']/g, ""))) return false;
+      if (looksSecret(text)) return false;
+      const unquoted = text.replace(/["']/g, "");
+      if (unquoted !== text && looksSecret(unquoted)) return false;
       const normalized = fold(text);
       if (defaultPii(normalized) || pii.some(pattern => normalized.includes(pattern))) return false;
+      if (!mayNeedPathCheck(normalized, pathProbe, deny)) return true;
       const candidates = normalized.includes("/") || /\.[a-z]/.test(normalized) ? pathCandidates(normalized) : [];
       const paths = [normalized, nodePath(normalized), ...candidates, ...normalized.split(/[\s"'`(){}\[\],;:=<>]+/)];
-      return !paths.some(path => path && isDenied(posix.normalize(path), deny));
+      return ![...new Set(paths)].some(path => path && isDenied(posix.normalize(path), deny));
     };
     const allowed = check(), bytes = Buffer.byteLength(text);
     if (bytes <= 1024) {
@@ -140,8 +193,14 @@ export function createStandalonePolicy(options: StandalonePolicyOptions = {}): S
   const standalone = (value: unknown): { ok: boolean; value?: unknown } => {
     try {
       // The exported default lists can be tightened by a host between calls.
+      // A getter can change behavior without changing its first serialized value: validate shape every time.
+      const defaultsPlain = plainDefaultStrings(DENY_NAMES) && plainDefaultStrings(DENY_SEGMENTS);
       const revision = JSON.stringify([DENY_NAMES, DENY_SEGMENTS]);
-      if (revision !== defaultDenyRevision) { textChecks.clear(); textBytes = 0; defaultDenyRevision = revision; }
+      const changed = revision !== defaultDenyRevision;
+      if (changed) { textChecks.clear(); textBytes = 0; defaultDenyRevision = revision; }
+      if (!defaultsPlain) pathProbe = undefined;
+      else if (changed || !defaultsWerePlain) pathProbe = defaultPathProbe();
+      defaultsWerePlain = defaultsPlain;
       const complete = snapshot(value);
       if (!complete) return { ok: false };
       // Only pure text checks are reused. Shape/bounds/private flags and the host's detached

package/src/memory/search-fts.ts

@@ -187,6 +187,59 @@ export class SearchIndex {
   close(): void { this.db?.close(); }
 }
 
+/** Screened query-local corpus in SQLite-owned TEMP storage, removed even when the process exits. */
+export class ScreenedSearchIndex<T> {
+  readonly available = fts5Available();
+  private readonly db: Database;
+  private closed = false;
+
+  constructor() {
+    let db: Database | undefined;
+    try {
+      db = new Database(":memory:");
+      // SQLite owns the anonymous TEMP files; no named plaintext cache survives a killed MCP child.
+      if ((db.query("SELECT sqlite_compileoption_used('TEMP_STORE=3') AS memoryOnly").get() as { memoryOnly: number }).memoryOnly) throw Error("disk-backed search unavailable");
+      db.run("PRAGMA temp_store = FILE");
+      db.run(this.available
+        ? "CREATE VIRTUAL TABLE temp.docs USING fts5(body, ref UNINDEXED, tier UNINDEXED, at UNINDEXED, payload UNINDEXED, expires UNINDEXED)"
+        : "CREATE TEMP TABLE docs (body TEXT, ref TEXT, tier TEXT, at TEXT, payload TEXT, expires REAL)");
+      db.run("PRAGMA temp.cache_size = -2048");
+      // A platform spill minimum can exceed cache_size (macOS: 20,000 pages).
+      // Spill at the cache target so dirty TEMP pages cannot accumulate behind that minimum.
+      db.run("PRAGMA temp.cache_spill = 1");
+      this.db = db;
+    } catch (error) { db?.close(); throw error; }
+  }
+
+  append(rows: readonly { body: string; ref: string; tier: string; at: string; value: T; expiresAt?: string | null }[]): void {
+    const insert = this.db.query("INSERT INTO docs (body, ref, tier, at, payload, expires) VALUES (?, ?, ?, ?, ?, ?)");
+    this.db.transaction(() => {
+      for (const row of rows) {
+        const deadline = row.expiresAt == null ? null : Date.parse(row.expiresAt);
+        // Invalid deadlines fail closed; this sentinel predates every representable Date.
+        insert.run(row.body, row.ref, row.tier, row.at, JSON.stringify(row.value), deadline !== null && !Number.isFinite(deadline) ? Number.MIN_SAFE_INTEGER : deadline);
+      }
+    })();
+  }
+
+  best(query: string, limit: number, now: number, useFts = this.available): { value: T; score: number }[] {
+    if (useFts && !ftsTerms(query)) return [];
+    const rank = useFts ? "-bm25(docs)" : "1.0";
+    const instant = new Date(now).toISOString();
+    const where = "WHERE (expires IS NULL OR expires > ?)" + (useFts ? " AND docs MATCH ?" : "");
+    const rows = this.db.query(`SELECT payload, ${rank} * CASE tier WHEN 'long' THEN 1.0 WHEN 'capture' THEN 0.5 ELSE 0.9 END
+      / (1 + max(0, (julianday(?) - julianday(at)) / 30.0)) AS score FROM docs ${where} ORDER BY score DESC, ref LIMIT ?`)
+      .all(instant, now, ...(useFts ? [ftsTerms(query)] : []), limit) as { payload: string; score: number }[];
+    return rows.map(row => ({ value: JSON.parse(row.payload) as T, score: row.score }));
+  }
+
+  close(): void {
+    if (this.closed) return;
+    this.closed = true;
+    this.db.close();
+  }
+}
+
 interface RawCaptureRow { id: number; at: string; project: string; agent: string; event: string; tool: string | null; paths: string; status: string | null; excerpt: string }
 
 /**
@@ -222,20 +275,23 @@ export interface ReadWindow {
   anchor?: string;
   prefix?: string;
   id?: string;
+  /** Exhaustive screened scans need stable identity order, not a chronological relevance window. */
+  order?: "id";
   after?: { position: number; id: string };
 }
 export interface ReadRef { id: string; at: string; position: number }
 /** Fixed column names supplied by the three derived stores; all caller values remain SQL parameters. */
-export function readWindowSql(window: ReadWindow, id: "id" | "ref") {
+export function readWindowSql(window: ReadWindow, id: "id" | "ref", identity: "text" | "integer" = "text") {
   if (!Number.isSafeInteger(window.limit) || window.limit < 1 || window.limit > 256) throw new Error("invalid read page limit");
   const bind: (string | number)[] = [];
-  const position = window.anchor ? (bind.push(window.anchor), "abs(julianday(at) - julianday(?))") : "-julianday(at)";
+  const position = window.order === "id" ? (identity === "integer" ? id : "0") : window.anchor ? (bind.push(window.anchor), "abs(julianday(at) - julianday(?))") : "-julianday(at)";
   const columns = `CAST(${id} AS TEXT) AS candidate_id, at, ${position} AS candidate_position`;
   const where = ["project IN (SELECT value FROM json_each(?))"]; bind.push(JSON.stringify(window.projects ?? [window.project]));
   if (window.since) { where.push("julianday(at) >= julianday(?)"); bind.push(window.since); }
   if (window.id !== undefined) { where.push(`${id} = ?`); bind.push(window.id); }
   if (window.prefix !== undefined) { where.push(`substr(${id}, 1, length(?)) = ?`); bind.push(window.prefix, window.prefix); }
-  if (window.after) {
+  if (window.after && window.order === "id") { where.push(`${id} > ?`); bind.push(window.after.id); }
+  else if (window.after) {
     where.push("(candidate_position > ? OR (candidate_position = ? AND candidate_id > ?))");
     bind.push(window.after.position, window.after.position, window.after.id);
   }

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));