@staix/agent-hub 0.12.25 → 0.12.27

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

package/src/pet/config.ts

@@ -1,14 +1,47 @@
-import { readFileSync } from "node:fs";
+import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { randomUUID } from "node:crypto";
 import { join } from "node:path";
 import { characterId, type CharacterId, type PetSize, type PetGlyphs } from "./frame.ts";
 
-export interface PetConfig { enabled: boolean; blink: boolean; bell: boolean; character?: CharacterId; size?: PetSize; glyphs?: PetGlyphs; notice?: string }
+export type PetPalette = "blue" | "teal" | "violet" | "ochre";
+const PALETTES: Record<string, PetPalette> = { a: "blue", b: "teal", c: "violet", d: "ochre", blue: "blue", teal: "teal", violet: "violet", ochre: "ochre" };
+export function petPalette(value: unknown): PetPalette | undefined {
+  return typeof value === "string" ? PALETTES[value.toLowerCase()] : undefined;
+}
+export interface PetConfig { enabled: boolean; blink: boolean; bell: boolean; character?: CharacterId; size?: PetSize; glyphs?: PetGlyphs; palette?: PetPalette; notice?: string; window?: boolean }
+/** Console-local presentation only; it merges pet.palette into config.local.json and grants no authority. */
+export function savePetPalette(cwd: string, value: string): string {
+  const palette = petPalette(value);
+  if (!palette) throw new Error("Unknown pet palette; use blue, teal, violet or ochre (a/b/c/d).");
+  const dir = join(cwd, ".agenthub");
+  const path = join(dir, "config.local.json");
+  let file: Record<string, unknown> = {};
+  try {
+    const parsed: unknown = JSON.parse(readFileSync(path, "utf8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("malformed");
+    file = parsed as Record<string, unknown>;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw new Error("Cannot update config.local.json; it is malformed.");
+  }
+  const pet = file.pet && typeof file.pet === "object" && !Array.isArray(file.pet) ? file.pet as Record<string, unknown> : {};
+  mkdirSync(dir, { recursive: true });
+  const temporary = join(dir, `config.local.${randomUUID()}.tmp`);
+  try {
+    writeFileSync(temporary, JSON.stringify({ ...file, pet: { ...pet, palette } }, null, 2) + "\n", { flag: "wx" });
+    renameSync(temporary, path);
+  } finally { rmSync(temporary, { force: true }); }
+  return `Pet palette set to ${palette}.`;
+}
 /** Console-local presentation only; this reader never writes config or grants authority. */
 export function loadPetConfig(cwd: string): PetConfig {
   let value: unknown;
+  let enabled = true;
   for (const name of ["config.json", "config.local.json"]) {
     try {
       const file = JSON.parse(readFileSync(join(cwd, ".agenthub", name), "utf8"));
+      // A window-only local opt-in does not undo inherited pet:false presentation.
+      if (file.pet === false) enabled = false;
+      else if (file.pet !== undefined && !(file.pet && typeof file.pet === "object" && !Array.isArray(file.pet) && Object.keys(file.pet).length === 1 && Object.hasOwn(file.pet, "window"))) enabled = true;
       if (file.pet !== undefined) value = value && typeof value === "object" && file.pet && typeof file.pet === "object" ? { ...value, ...file.pet } : file.pet;
     } catch (error) {
       if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
@@ -19,13 +52,17 @@ export function loadPetConfig(cwd: string): PetConfig {
   if (value === undefined) return defaults;
   if (!value || typeof value !== "object" || Array.isArray(value)) return { ...defaults, notice: "Unknown pet configuration; using stai line defaults." };
   const row = value as Record<string, unknown>;
-  const invalid = Object.keys(row).some(key => !["character", "size", "glyphs", "blink", "bell"].includes(key)) ||
+  const invalid = Object.keys(row).some(key => !["character", "size", "glyphs", "blink", "bell", "palette", "window"].includes(key)) ||
     row.character !== undefined && !characterId(row.character) || row.size !== undefined && !["line", "mini", "full"].includes(row.size as string) ||
     row.glyphs !== undefined && (typeof row.glyphs !== "string" || !["auto", "ascii", "blocks"].includes(row.glyphs)) ||
-    row.blink !== undefined && typeof row.blink !== "boolean" || row.bell !== undefined && typeof row.bell !== "boolean";
-  return { enabled: true, blink: typeof row.blink === "boolean" ? row.blink : true, bell: typeof row.bell === "boolean" ? row.bell : false,
+    row.palette !== undefined && !petPalette(row.palette) ||
+    row.blink !== undefined && typeof row.blink !== "boolean" || row.bell !== undefined && typeof row.bell !== "boolean" || row.window !== undefined && typeof row.window !== "boolean";
+  const palette = petPalette(row.palette);
+  return { enabled, blink: typeof row.blink === "boolean" ? row.blink : true, bell: typeof row.bell === "boolean" ? row.bell : false,
+    ...(typeof row.window === "boolean" ? { window: row.window } : {}),
     ...(characterId(row.character) && row.character !== "stai" ? { character: row.character } : {}),
     ...(row.size === "mini" || row.size === "full" ? { size: row.size } : {}),
     ...(row.glyphs === "ascii" || row.glyphs === "blocks" ? { glyphs: row.glyphs } : {}),
+    ...(palette && palette !== "teal" ? { palette } : {}),
     ...(invalid ? { notice: "Unknown pet option; using stai line defaults for that option." } : {}) };
 }

package/src/pet/window.html

@@ -0,0 +1,114 @@
+<!doctype html>
+<html lang="en">
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta http-equiv="Content-Security-Policy" content="default-src 'none'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; connect-src 'none'; base-uri 'none'; form-action 'none'">
+<title>agent-hub pet</title>
+<style>
+:root { color-scheme: dark; font: 12px system-ui, sans-serif; color: #eceef3; }
+html, body { margin: 0; background: transparent; overflow: hidden; }
+body { width: 150px; height: 150px; display: flex; align-items: center; flex-direction: column; justify-content: flex-end; gap: 4px; padding-bottom: 4px; box-sizing: border-box; }
+button { font: inherit; color: inherit; cursor: pointer; border: 0; background: transparent; border-radius: 10px; }
+button:focus-visible, input:focus-visible { outline: 2px solid #79dfb2; outline-offset: 2px; }
+#pet { width: 63px; height: 58px; padding: 0; cursor: grab; touch-action: none; }
+#pet:active { cursor: grabbing; }
+svg { width: 100%; height: 100%; overflow: visible; image-rendering: pixelated; filter: drop-shadow(0 1px 1px #687a78) drop-shadow(0 0 1px #687a78); }
+[data-palette="blue"] svg { filter: drop-shadow(0 1px 1px #64748b) drop-shadow(0 0 1px #64748b); }
+[data-palette="violet"] svg { filter: drop-shadow(0 1px 1px #796d8b) drop-shadow(0 0 1px #796d8b); }
+[data-palette="ochre"] svg { filter: drop-shadow(0 1px 1px #81725f) drop-shadow(0 0 1px #81725f); }
+rect { fill: #168b87; }
+[data-palette="blue"] rect { fill: #3979d6; }
+[data-palette="violet"] rect { fill: #8864cc; }
+[data-palette="ochre"] rect { fill: #be7a22; }
+[data-state="waiting"] rect { fill: #c4880f; }
+[data-state="blocked"] rect { fill: #cf6156; }
+[data-state="review"] rect { fill: #8a6cd8; }
+[data-state="offline"] rect { fill: #6f7787; }
+body[data-state="working"] #frame { animation: working-bob 0.7s steps(3, end) infinite; }
+@keyframes working-bob {
+  0%, 100% { transform: translateY(0); }
+  50% { transform: translateY(-4px); }
+}
+@media (prefers-reduced-motion: reduce) {
+  body[data-state="working"] #frame { animation: none; }
+}
+#pill { display: flex; align-items: center; gap: 4px; border-radius: 14px; padding: 3px 7px; background: #242936ed; font-size: 11px; }
+#pill button { padding: 2px 4px; }
+#composer { width: 100%; background: #242936f5; padding: 4px; border-radius: 10px; box-sizing: border-box; }
+#composer[hidden] { display: none; }
+/* Hidden by opacity only: visibility would drop the #state live region from the a11y tree. */
+#pill { opacity: 0; pointer-events: none; transition: opacity .12s ease; }
+#pet:hover ~ #pill, #pet:focus-visible ~ #pill, #pill:hover, #pill:focus-within, body[data-hover] #pill, body[data-composing] #pill { opacity: 1; pointer-events: auto; }
+input { width: 100%; box-sizing: border-box; border: 1px solid #657081; border-radius: 6px; padding: 5px; background: #111722; color: #eceef3; font: 13px system-ui; }
+#result { margin-top: 2px; min-height: 12px; font-size: 11px; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+</style>
+<button id="pet" aria-label="Open agent-hub dashboard"><svg id="frame" role="img" aria-label="Pet" viewBox="0 0 60 64"></svg></button>
+<div id="pill"><span id="state" aria-live="polite">Starting</span><button id="pencil" aria-label="Write a console message">✎</button><button id="close" aria-label="Close pet window">×</button></div>
+<div id="composer" hidden><input id="message" aria-label="Console message" placeholder="Message, Enter to send" maxlength="65536"><div id="result" role="status">Esc to cancel</div></div>
+<script>
+const post = body => window.webkit.messageHandlers.pet.postMessage(body);
+const pet = document.getElementById('pet'), frame = document.getElementById('frame'), pill = document.getElementById('pill');
+const state = document.getElementById('state'), composer = document.getElementById('composer'), input = document.getElementById('message'), result = document.getElementById('result');
+let signature = '', drag, sending = false;
+const draw = (x, y, w, h) => {
+  const rect = document.createElementNS('http://www.w3.org/2000/svg', 'rect');
+  rect.setAttribute('x', x); rect.setAttribute('y', y); rect.setAttribute('width', w); rect.setAttribute('height', h);
+  return rect;
+};
+window.update = view => {
+  if (view.offline) {
+    document.body.dataset.state = 'offline'; state.textContent = 'Offline';
+    document.getElementById('pencil').disabled = true; return;
+  }
+  document.getElementById('pencil').disabled = false;
+  document.body.dataset.state = view.state;
+  document.body.dataset.palette = view.palette;
+  state.textContent = view.state + (view.act ? ' · act ' + view.act : '') + (view.watch ? ' · watch ' + view.watch : '');
+  pet.setAttribute('aria-label', 'Open dashboard, ' + state.textContent);
+  const next = JSON.stringify(view.frame);
+  if (signature === next) return;
+  signature = next;
+  frame.setAttribute('viewBox', '0 0 ' + view.frame.width + ' ' + view.frame.height);
+  frame.replaceChildren(...view.frame.pixels.map(([x, y]) => draw(x, y, 1, 1)));
+};
+window.focusInput = () => { document.body.dataset.composing = ''; composer.hidden = false; input.focus(); };
+window.commandResult = ok => { sending = false; input.disabled = false; result.textContent = ok ? 'Sent' : 'Not confirmed; check the dashboard.'; if (ok) { input.value = ''; composer.hidden = true; delete document.body.dataset.composing; } };
+document.getElementById('pencil').addEventListener('click', () => post({ kind: 'pencil' }));
+document.getElementById('close').addEventListener('click', () => post({ kind: 'close' }));
+input.addEventListener('keydown', event => {
+  if (event.key === 'Escape') { composer.hidden = true; delete document.body.dataset.composing; pet.focus(); }
+  if (event.key === 'Enter' && !event.isComposing && input.value.trim() && !sending) {
+    event.preventDefault(); sending = true; input.disabled = true; result.textContent = 'Sending'; post({ kind: 'send', text: input.value });
+  }
+});
+// The native host polls the global mouse position against this rect (pet + pill) and
+// calls hoverChanged, because an inactive accessory panel never fires CSS :hover.
+window.hoverChanged = on => { if (on) document.body.dataset.hover = ''; else delete document.body.dataset.hover; };
+const postHotspot = () => {
+  const a = pet.getBoundingClientRect(), b = pill.getBoundingClientRect();
+  const x = Math.min(a.x, b.x), y = Math.min(a.y, b.y);
+  post({ kind: 'hotspot', x, y, w: Math.max(a.right, b.right) - x, h: Math.max(a.bottom, b.bottom) - y });
+};
+// While the panel is key, 1/2/3/4 switch the palette (blue/teal/violet/ochre) and save it.
+const KEY_PALETTES = { '1': 'blue', '2': 'teal', '3': 'violet', '4': 'ochre' };
+document.addEventListener('keydown', event => {
+  const palette = KEY_PALETTES[event.key];
+  if (!palette || event.target === input) return;
+  document.body.dataset.palette = palette;
+  post({ kind: 'palette', palette });
+});
+pet.addEventListener('pointerdown', event => { drag = { x: event.screenX, y: event.screenY, moved: false }; pet.setPointerCapture(event.pointerId); });
+pet.addEventListener('pointermove', event => {
+  if (!drag) return;
+  const dx = event.screenX - drag.x, dy = event.screenY - drag.y;
+  if (!dx && !dy) return;
+  drag.moved = true; drag.x = event.screenX; drag.y = event.screenY;
+  post({ kind: 'drag', dx, dy });
+});
+pet.addEventListener('pointerup', () => { const moved = drag?.moved; drag = null; if (!moved) post({ kind: 'open' }); });
+pet.addEventListener('pointercancel', () => { drag = null; });
+pet.addEventListener('keydown', event => { if (event.key === 'Enter' || event.key === ' ') { event.preventDefault(); post({ kind: 'open' }); } });
+postHotspot();
+post({ kind: 'ready' });
+</script>
+</html>

package/src/pet/window.jxa.js

@@ -0,0 +1,122 @@
+// Local AppKit/WebKit surface. No shell evaluation or remote content.
+ObjC.import('Cocoa');
+ObjC.import('WebKit');
+var panel, web, app, viewPath, positionPath, readyPath, cliArgv, timer, hoverTimer, bridge;
+var offlineAt = 0, commands = [], exiting = false, hotspot = null, hovering = false;
+function ignoreCompletion(result, error) {}
+function evaluate(source) { web.evaluateJavaScriptCompletionHandler(source, ignoreCompletion); }
+// An inactive accessory panel receives no mouse-moved events, so hover reveal is
+// polled from the global mouse position against the hotspot rect the page posts.
+function pollHover() {
+  if (!hotspot || exiting) return;
+  var mouse = $.NSEvent.mouseLocation, frame = panel.frame;
+  var x = mouse.x - frame.origin.x, y = frame.origin.y + frame.size.height - mouse.y;
+  var inside = x >= hotspot.x && x <= hotspot.x + hotspot.w && y >= hotspot.y && y <= hotspot.y + hotspot.h;
+  if (inside !== hovering) { hovering = inside; evaluate('hoverChanged(' + inside + ')'); }
+}
+function savePosition() {
+  var origin = panel.frame.origin;
+  $(JSON.stringify({ x: origin.x, y: origin.y })).writeToFileAtomicallyEncodingError(positionPath, true, $.NSUTF8StringEncoding, null);
+}
+function quit() { exiting = true; savePosition(); app.terminate(null); }
+function runCommand(command, extra, argv) {
+  if (exiting || commands.length >= 8) return;
+  var task = $.NSTask.alloc.init;
+  task.executableURL = $.NSURL.fileURLWithPath(argv[0]);
+  var args = argv.slice(1).concat([command]).concat(extra);
+  task.arguments = $(args); // argv array only; message text is a single argument.
+  task.standardInput = $.NSFileHandle.fileHandleWithNullDevice;
+  task.standardOutput = $.NSFileHandle.fileHandleWithNullDevice;
+  task.standardError = $.NSFileHandle.fileHandleWithNullDevice;
+  if (task.launchAndReturnError(null)) commands.push({ task: task, command: command });
+  else evaluate('commandResult(false)');
+}
+ObjC.registerSubclass({ name: 'AhubPetPanel', superclass: 'NSPanel', methods: {
+  canBecomeKeyWindow: { types: ['bool', []], implementation: function() { return true; } },
+  canBecomeMainWindow: { types: ['bool', []], implementation: function() { return false; } }
+} });
+// JXA cannot resolve WKScriptMessageHandler by name on some macOS versions;
+// WebKit invokes the exact Objective-C selector on this retained subclass.
+ObjC.registerSubclass({ name: 'AhubPetBridge', superclass: 'NSObject', methods: {
+  'userContentController:didReceiveScriptMessage:': { types: ['void', ['id', 'id']], implementation: function(controller, message) {
+    var body = ObjC.deepUnwrap(message.body);
+    if (!body || typeof body !== 'object' || exiting) return;
+    if (body.kind === 'ready') {
+      tick();
+      $('ready').writeToFileAtomicallyEncodingError(readyPath, true, $.NSUTF8StringEncoding, null);
+    } else if (body.kind === 'pencil') {
+      panel.orderFrontRegardless; panel.makeKeyWindow;
+      evaluate('focusInput()');
+    } else if (body.kind === 'drag' && typeof body.dx === 'number' && typeof body.dy === 'number' && isFinite(body.dx) && isFinite(body.dy) && Math.abs(body.dx) <= 2000 && Math.abs(body.dy) <= 2000) {
+      var origin = panel.frame.origin;
+      panel.setFrameOrigin($.NSMakePoint(origin.x + body.dx, origin.y - body.dy));
+      savePosition();
+    } else if (body.kind === 'hotspot' && typeof body.x === 'number' && typeof body.y === 'number' && typeof body.w === 'number' && typeof body.h === 'number' && isFinite(body.x) && isFinite(body.y) && Math.abs(body.x) <= 500 && Math.abs(body.y) <= 500 && body.w > 0 && body.h > 0 && body.w <= 500 && body.h <= 500) {
+      hotspot = { x: body.x, y: body.y, w: body.w, h: body.h };
+    } else if (body.kind === 'send' && typeof body.text === 'string' && body.text.trim() && body.text.length <= 65536 && body.text.indexOf('\0') === -1) {
+      runCommand('say', ['--', body.text], cliArgv);
+    } else if (body.kind === 'palette' && typeof body.palette === 'string' && /^(blue|teal|violet|ochre)$/.test(body.palette)) {
+      runCommand('pet', ['--palette', body.palette], cliArgv);
+    } else if (body.kind === 'open') runCommand('ui', [], cliArgv);
+    else if (body.kind === 'close') quit();
+  } },
+  'tick:': { types: ['void', ['id']], implementation: function(sender) { tick(); } },
+  'hover:': { types: ['void', ['id']], implementation: function(sender) { pollHover(); } }
+} });
+function tick() {
+  var value;
+  try { value = JSON.parse(ObjC.unwrap($.NSString.stringWithContentsOfFileEncodingError(viewPath, $.NSUTF8StringEncoding, null))); }
+  catch (error) { value = { offline: true }; }
+  evaluate('update(' + JSON.stringify(value) + ')');
+  if (value.offline === true) { if (!offlineAt) offlineAt = Date.now(); if (Date.now() - offlineAt >= 2000) quit(); }
+  else offlineAt = 0;
+  commands = commands.filter(function(item) {
+    if (item.task.isRunning) return true;
+    if (item.command === 'say') evaluate('commandResult(' + (Number(item.task.terminationStatus) === 0) + ')');
+    return false;
+  });
+}
+function run(argv) {
+  if (argv.length !== 3) throw new Error('Invalid pet window arguments');
+  viewPath = argv[0];
+  var htmlPath = argv[1];
+  cliArgv = JSON.parse(argv[2]);
+  if (!Array.isArray(cliArgv) || cliArgv.length !== 4 || cliArgv.some(function(arg) { return typeof arg !== 'string'; }) || cliArgv[2] !== '--project') throw new Error('Invalid CLI argv');
+  var stateDir = ObjC.unwrap($(viewPath).stringByDeletingLastPathComponent);
+  positionPath = stateDir + '/pet-window-pos.json';
+  var owner = JSON.parse(ObjC.unwrap($.NSString.stringWithContentsOfFileEncodingError(stateDir + '/pet-window.pid', $.NSUTF8StringEncoding, null)));
+  readyPath = stateDir + '/pet-window-ready-' + owner.token;
+  app = $.NSApplication.sharedApplication;
+  app.setActivationPolicy($.NSApplicationActivationPolicyAccessory);
+  var screen = $.NSScreen.mainScreen.visibleFrame;
+  var W = 150, H = 150;
+  var origin = { x: screen.origin.x + screen.size.width - (W + 20), y: screen.origin.y + 80 };
+  try {
+    var saved = JSON.parse(ObjC.unwrap($.NSString.stringWithContentsOfFileEncodingError(positionPath, $.NSUTF8StringEncoding, null)));
+    if (typeof saved.x === 'number' && typeof saved.y === 'number' && isFinite(saved.x) && isFinite(saved.y)) origin = saved;
+  } catch (error) {}
+  var screens = $.NSScreen.screens;
+  var visible = false;
+  for (var i = 0; i < screens.count; i++) {
+    var frame = screens.objectAtIndex(i).visibleFrame;
+    if (origin.x >= frame.origin.x && origin.y >= frame.origin.y && origin.x + W <= frame.origin.x + frame.size.width && origin.y + H <= frame.origin.y + frame.size.height) visible = true;
+  }
+  if (!visible) origin = { x: screen.origin.x + screen.size.width - (W + 20), y: screen.origin.y + 80 };
+  panel = $.AhubPetPanel.alloc.initWithContentRectStyleMaskBackingDefer($.NSMakeRect(origin.x, origin.y, W, H), $.NSWindowStyleMaskBorderless | $.NSWindowStyleMaskNonactivatingPanel, $.NSBackingStoreBuffered, false);
+  panel.title = 'agent-hub pet'; panel.opaque = false; panel.backgroundColor = $.NSColor.clearColor;
+  panel.level = $.NSFloatingWindowLevel;
+  panel.collectionBehavior = $.NSWindowCollectionBehaviorCanJoinAllSpaces | $.NSWindowCollectionBehaviorStationary;
+  panel.hidesOnDeactivate = false;
+  panel.acceptsMouseMovedEvents = true; // CSS :hover while key; pollHover() covers the inactive case
+  var config = $.WKWebViewConfiguration.alloc.init;
+  bridge = $.AhubPetBridge.alloc.init;
+  config.userContentController.addScriptMessageHandlerName(bridge, 'pet');
+  web = $.WKWebView.alloc.initWithFrameConfiguration($.NSMakeRect(0, 0, W, H), config);
+  web.setValueForKey(false, 'drawsBackground');
+  panel.contentView = web;
+  web.loadFileURLAllowingReadAccessToURL($.NSURL.fileURLWithPath(htmlPath), $.NSURL.fileURLWithPath(htmlPath));
+  panel.orderFrontRegardless; panel.makeKeyWindow;
+  timer = $.NSTimer.scheduledTimerWithTimeIntervalTargetSelectorUserInfoRepeats(1, bridge, 'tick:', null, true);
+  hoverTimer = $.NSTimer.scheduledTimerWithTimeIntervalTargetSelectorUserInfoRepeats(0.1, bridge, 'hover:', null, true);
+  app.run;
+}