@tryinget/pi-activity-strip 0.9.0 → 0.10.0

package/src/native/placement.mjs

@@ -7,14 +7,12 @@
 import path from "node:path";
 import { ACTIVITY_STRIP_SOCKET_DIR } from "../common/constants.mjs";
 import { resolvePiSessionIdentity, resolveSessionWindow } from "../common/niri-focus.mjs";
-import {
-  createSurfaceBindingStore,
-  parseTerminalTitleBinding,
-} from "../common/surface-bindings.mjs";
+import { createSurfaceBindingStore } from "../common/surface-bindings.mjs";
 import {
   canonicalGhosttyTerminalKey,
   resolveTerminalHostPid,
 } from "../common/terminal-identity.mjs";
+import { resolveWorkspaceView } from "../common/workspace-view.mjs";
 import { mapTabInventoryToBindings, probeGhosttyTabInventory } from "./tab-inventory.mjs";
 
 // The AT-SPI tab inventory is the only exact source for tabs that have never been shown while the
@@ -59,8 +57,13 @@ export function createPlacementRuntime({
   });
   /** @type {Map<string, number>} */
   const hostPidCache = new Map();
-  /** @type {Map<unknown, string>} */
-  const windowSignatures = new Map();
+  /** Complete latest window inventory, advanced synchronously by compositor events. */
+  /** @type {Map<unknown, NiriWindow>} */
+  const observedWindows = new Map();
+  let windowCacheValid = false;
+  /** Established publisher facts from the last full projection, not title-shape inference. */
+  /** @type {Array<Record<string, unknown>> | null} */
+  let sourceSessions = null;
   let inventoryInFlight = false;
   let inventoryNextAt = 0;
 
@@ -72,10 +75,58 @@ export function createPlacementRuntime({
     lookupBinding: (bindingKey) => bindings.lookup(bindingKey),
   };
 
-  /** Workspace plus visible surface: everything about a window that can move a card. */
-  /** @param {NiriWindow} window */
-  function signatureOf(window) {
-    return `${window.workspace_id}|${parseTerminalTitleBinding(window.title)?.terminalKey ?? ""}`;
+  /** @param {NiriWindow[]} windows */
+  function cacheWindowList(windows) {
+    observedWindows.clear();
+    windowCacheValid = windows.every((window) => Number.isInteger(window?.id));
+    for (const window of windows) {
+      if (observedWindows.has(window?.id)) windowCacheValid = false;
+      observedWindows.set(window?.id, { ...window });
+    }
+  }
+
+  /** The same complete-window admission resolver used by full reconciliation.
+   * @param {Record<string, unknown>} workspace
+   */
+  function resolveCachedWorkspaceView(workspace) {
+    if (!windowCacheValid || sourceSessions === null) return null;
+    return resolveWorkspaceView([...observedWindows.values()], workspace, sourceSessions, options);
+  }
+
+  // Only admission changes schedule work. A Pi display prefix or an unrelated browser title
+  // cannot churn eligibility, but a new claimant anywhere changes the canonical projection.
+  function admissionSignature() {
+    const windows = [...observedWindows.values()];
+    if (!sourceSessions?.length) {
+      // Unknown source facts: preserve full title sensitivity, never normalize by hex shape.
+      return JSON.stringify(
+        windows.map((window) => [
+          window.id,
+          window.workspace_id,
+          window.app_id,
+          window.pid,
+          window.title,
+        ]),
+      );
+    }
+    const workspaceIds = [...new Set(windows.map((window) => window.workspace_id))];
+    const cards = workspaceIds.flatMap((id) => {
+      const view = resolveCachedWorkspaceView({ id });
+      return (view?.sessions ?? []).map((card) => {
+        const window = observedWindows.get(card.windowId);
+        return JSON.stringify([
+          id,
+          card.cardId,
+          card.windowId,
+          card.placement,
+          card.surfaceVisible,
+          card.publisherRecordKeys,
+          window?.app_id,
+          window?.pid,
+        ]);
+      });
+    });
+    return JSON.stringify([windowCacheValid, cards.sort()]);
   }
 
   /**
@@ -97,14 +148,11 @@ export function createPlacementRuntime({
 
   /** @param {NiriWindow[]} windows */
   function observeWindowList(windows) {
+    cacheWindowList(windows);
     if (windows.length === 0) return;
     bindings.observeWindows(windows);
     bindings.prune(windows);
     bindings.persist();
-    windowSignatures.clear();
-    for (const window of windows) {
-      if (Number.isInteger(window?.id)) windowSignatures.set(window.id, signatureOf(window));
-    }
   }
 
   /**
@@ -113,11 +161,10 @@ export function createPlacementRuntime({
    */
   function observeWindowEvent(window) {
     if (!Number.isInteger(window?.id)) return false;
+    const before = admissionSignature();
+    observedWindows.set(window.id, { ...window });
     const learned = bindings.observeWindows([window]);
-    const signature = signatureOf(window);
-    const changed = windowSignatures.get(window.id) !== signature;
-    windowSignatures.set(window.id, signature);
-    return learned.length > 0 || changed;
+    return learned.length > 0 || before !== admissionSignature();
   }
 
   /**
@@ -125,8 +172,11 @@ export function createPlacementRuntime({
    * same tab stays placed once it is hidden behind another tab.
    * @param {Array<Record<string, unknown>>} cards
    * @param {NiriWindow[]} windows
+   * @param {Array<Record<string, unknown>>} [sessions] All raw publishers, including other agents.
    */
-  function learnFromPlacements(cards, windows) {
+  function learnFromPlacements(cards, windows, sessions = cards) {
+    sourceSessions = sessions.map((session) => ({ ...session }));
+    cacheWindowList(windows);
     const byId = new Map(
       windows.filter((window) => Number.isInteger(window?.id)).map((window) => [window.id, window]),
     );
@@ -149,7 +199,7 @@ export function createPlacementRuntime({
 
   /** @param {number} windowId */
   function forgetWindow(windowId) {
-    return windowSignatures.delete(windowId);
+    return observedWindows.delete(windowId);
   }
 
   /** @param {NiriWindow[]} windows */
@@ -213,6 +263,19 @@ export function createPlacementRuntime({
     options,
     observeWindowList,
     observeWindowEvent,
+    resolveCachedWorkspaceView,
+    /** Read-only established fact copy; never lets an intent mutate the event cache. @param {number} id */
+    getObservedWindow(id) {
+      const window = windowCacheValid ? observedWindows.get(id) : null;
+      return window
+        ? {
+            id: window.id,
+            workspace_id: window.workspace_id,
+            app_id: window.app_id,
+            pid: window.pid,
+          }
+        : null;
+    },
     learnFromPlacements,
     forgetWindow,
     countUnplaced,

package/src/native/recovery-inventory.mjs

@@ -0,0 +1,209 @@
+// ---
+// summary: "Read-only native recovery inventory: procfs, metadata registries, niri queries and AK list."
+// read_when: ["operating or testing the recovery manifest CLI"]
+// ---
+
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { buildRecoveryManifest } from "../common/recovery-manifest.mjs";
+import { fileIdentity, processClock, record, scanProcesses, string } from "./recovery-proc.mjs";
+import {
+  claudeRegistry,
+  codexDescriptors,
+  inspectTranscript,
+  markRepublished,
+  nodecodeShellRoot,
+  nodecodeShells,
+  piBroker,
+  transcriptIndex,
+} from "./recovery-sources.mjs";
+
+/** @typedef {import('../common/recovery-types.ts').SourceCoverage} SourceCoverage */
+/** @typedef {import('../common/recovery-types.ts').SessionObservation} SessionObservation */
+
+/** Commands are fixed read-only APIs, no shell, stderr never carries source text into output.
+ * @param {string} executable @param {string[]} args */
+function jsonCommand(executable, args) {
+  try {
+    const raw = execFileSync(executable, args, {
+      encoding: "utf8",
+      maxBuffer: 8 * 1024 * 1024,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    const rows = JSON.parse(raw);
+    if (!Array.isArray(rows)) throw new Error("not-array");
+    return { state: "observed", rows: rows.map(record) };
+  } catch {
+    return { state: "unavailable", rows: [] };
+  }
+}
+
+/** @param {SourceCoverage[]} sources @param {string} suffix */
+function compositor(sources, suffix) {
+  const windows = jsonCommand("niri", ["msg", "-j", "windows"]);
+  const workspaces = jsonCommand("niri", ["msg", "-j", "workspaces"]);
+  sources.push(
+    ...[
+      ["windows", windows],
+      ["workspaces", workspaces],
+    ].map(([label, data]) => {
+      const source = /** @type {ReturnType<typeof jsonCommand>} */ (data);
+      return {
+        source: `niri-${label}-${suffix}`,
+        state: source.state,
+        observed: source.rows.length,
+        rejected: 0,
+        limitations: ["no titles retained; no compositor mutations"],
+      };
+    }),
+  );
+  return {
+    windows: windows.rows
+      .filter((r) => Number.isSafeInteger(r.id))
+      .map((r) => ({
+        id: Number(r.id),
+        pid: Number.isSafeInteger(r.pid) ? Number(r.pid) : null,
+        workspace_id: Number.isSafeInteger(r.workspace_id) ? Number(r.workspace_id) : null,
+      })),
+    workspaces: workspaces.rows
+      .filter((r) => Number.isSafeInteger(r.id) && Number.isSafeInteger(r.idx))
+      .map((r) => ({ id: Number(r.id), idx: Number(r.idx) })),
+  };
+}
+
+/** @param {{includePaths?: boolean; piSessionRoot?: string; home?: string; noAk?: boolean}} [options] */
+export async function collectRecoveryManifest({
+  includePaths = false,
+  piSessionRoot,
+  home = os.homedir(),
+  noAk = false,
+} = {}) {
+  const startedAt = Date.now();
+  const clock = processClock();
+  /** @type {SourceCoverage[]} */
+  const sources = [];
+  const before = scanProcesses(clock);
+  sources.push(before.coverage);
+  const niri = compositor(sources, "before");
+  const registryRoot = path.join(home, ".claude", "sessions");
+  const claude = claudeRegistry(registryRoot);
+  const pi = await piBroker();
+  const codex = codexDescriptors(
+    before.processes,
+    process.env.CODEX_HOME || path.join(home, ".codex"),
+  );
+  const shellRoot = nodecodeShellRoot(process.env);
+  const nodecode = nodecodeShells(shellRoot);
+  sources.push(claude.coverage, pi.coverage, codex.coverage, nodecode.coverage);
+  const claudeFiles = transcriptIndex(path.join(home, ".claude", "projects"));
+  const piFiles = transcriptIndex(
+    piSessionRoot ||
+      process.env.PI_CODING_AGENT_SESSION_DIR ||
+      path.join(process.env.PI_CODING_AGENT_DIR || path.join(home, ".pi", "agent"), "sessions"),
+  );
+  sources.push(claudeFiles.coverage, piFiles.coverage);
+  const sessions = [...claude.sessions, ...pi.sessions, ...codex.sessions, ...nodecode.sessions];
+  for (const s of sessions) {
+    if (s.harness !== "claude" && s.harness !== "pi") continue;
+    const index = s.harness === "claude" ? claudeFiles : piFiles;
+    const files = index.files.get(s.sessionId?.toLowerCase() ?? "") ?? [];
+    s.transcripts = files.map((f) => inspectTranscript(f, s.sessionId ?? "", s.harness));
+    if (files.length === 0)
+      s.transcripts.push({
+        path: "",
+        state: "not-found-in-scanned-roots",
+        method: "bounded-filename-inventory",
+      });
+    if (files.length > 1) for (const t of s.transcripts) t.state = "ambiguous-path";
+  }
+  const ak = noAk
+    ? { state: "disabled", rows: [] }
+    : jsonCommand(process.env.PI_ACTIVITY_STRIP_AK_BIN || "ak", [
+        "task",
+        "list",
+        "--status",
+        "claimed",
+        "--format",
+        "json",
+        "--all",
+        "--verbose",
+      ]);
+  const validClaims = ak.rows.filter(
+    (r) => Number.isSafeInteger(r.id) && typeof r.claimed_by === "string",
+  );
+  sources.push({
+    source: "ak-claimed-tasks",
+    state: ak.state,
+    observed: ak.rows.length,
+    rejected: ak.rows.length - validClaims.length,
+    limitations: ["read-only current claims; no task titles, no history, no custody transfer"],
+  });
+  // Recheck source identity as well as PID birth. Ordinary heartbeat updates do not change identity.
+  const claudeAfter = claudeRegistry(registryRoot);
+  const piAfter = await piBroker();
+  const nodecodeAfter = nodecodeShells(shellRoot);
+  markRepublished(
+    sessions,
+    new Map([
+      ["claude-registry", claudeAfter.sessions],
+      ["pi-broker", piAfter.sessions],
+      ["nodecode-shell-presence", nodecodeAfter.sessions],
+    ]),
+  );
+  for (const s of sessions) {
+    if (s.source === "codex-open-rollout") {
+      try {
+        s.changed ||=
+          fs.readlinkSync(s.sourceRef) !== s.transcripts[0]?.path ||
+          fileIdentity(s.sourceRef).identity !== s.transcripts[0]?.identity;
+      } catch {
+        s.changed = true;
+      }
+    }
+    for (const t of s.transcripts) {
+      if (!t.identity || !t.path) continue;
+      try {
+        const now = fileIdentity(t.path);
+        t.changed ||= now.identity !== t.identity || now.size !== t.size;
+        if (now.identity !== t.identity) t.state = "file-replaced";
+      } catch {
+        t.state = "unavailable-after-capture";
+        t.changed = true;
+      }
+    }
+  }
+  sources.push(
+    { ...claudeAfter.coverage, source: `${registryRoot} (after)` },
+    { ...piAfter.coverage, source: "pi-activity-strip-broker-after" },
+    { ...nodecodeAfter.coverage, source: `${nodecodeAfter.coverage.source} (after)` },
+  );
+  const niriAfter = compositor(sources, "after");
+  const afterClock = processClock();
+  const after = scanProcesses(afterClock);
+  sources.push({ ...after.coverage, source: "procfs-current-user-after" });
+  return buildRecoveryManifest(
+    {
+      startedAt,
+      endedAt: Date.now(),
+      bootId: clock.bootId,
+      pidDomain: clock.pidDomain,
+      before: before.processes,
+      after: after.processes,
+      sessions,
+      sources,
+      windows: niri.windows,
+      windowsAfter: niriAfter.windows,
+      workspaces: niri.workspaces,
+      workspacesAfter: niriAfter.workspaces,
+      claims: validClaims.map((r) => ({
+        id: Number(r.id),
+        claimed_by: string(r.claimed_by),
+        status: string(r.status),
+        lease_expires_at: string(r.lease_expires_at),
+      })),
+    },
+    { includePaths },
+  );
+}

package/src/native/recovery-proc.mjs

@@ -0,0 +1,178 @@
+// ---
+// summary: "Bounded procfs metadata collection without emitting environment or command-line text."
+// read_when: ["changing recovery process observations"]
+// ---
+
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { classifyAgentProcess } from "../common/agent-identity.mjs";
+
+/** @param {string} file */
+export function textFile(file) {
+  return fs.readFileSync(file, "utf8");
+}
+/** @param {unknown} value */
+export function string(value) {
+  return typeof value === "string" ? value : "";
+}
+/** @param {unknown} value */
+export function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? /** @type {Record<string, unknown>} */ (value)
+    : {};
+}
+/** @param {string} file */
+export function fileIdentity(file) {
+  const s = fs.statSync(file);
+  return { identity: `${s.dev}:${s.ino}`, size: s.size, mtimeMs: s.mtimeMs };
+}
+
+/** @param {string} raw @param {number} pid */
+export function parseProcStat(raw, pid) {
+  const end = raw.lastIndexOf(")");
+  if (!raw.startsWith(`${pid} (`) || end < 0) return null;
+  const fields = raw
+    .slice(end + 2)
+    .trim()
+    .split(/\s+/);
+  if (!/^\d+$/.test(fields[19] ?? "") || !/^\d+$/.test(fields[1] ?? "")) return null;
+  return { ppid: Number(fields[1]), startTicks: fields[19] };
+}
+
+/** @param {{comm: string; executable: string; argv0: string; argv1: string}} p */
+export function recoveryHarness(p) {
+  const exe = path.basename(p.executable);
+  const first = path.basename(p.argv0);
+  if (
+    exe === "pi" ||
+    p.comm === "pi" ||
+    (exe.startsWith("node") && /\/pi-coding-agent\/(?:dist\/)?cli\.(?:js|mjs)$/.test(p.argv1))
+  )
+    return "pi";
+  if (exe === "angel" && p.executable.includes("/angelx-pi/")) return "angelx";
+  if (exe === "electron" && p.executable.includes("/agnt/")) return "agnt";
+  if (exe === "omp" || first === "omp") return "omp";
+  // Only the actual executable or runtime's script slot participates, never prompt arguments.
+  return (
+    classifyAgentProcess({
+      command: exe,
+      argv0: first,
+      argv1: /^(node|bun|python)/.test(exe) ? p.argv1 : "",
+    })?.kind ?? ""
+  );
+}
+
+export function processClock() {
+  const bootId = textFile("/proc/sys/kernel/random/boot_id").trim();
+  const machineId = textFile("/etc/machine-id").trim();
+  const namespace = fs.readlinkSync("/proc/self/ns/pid");
+  const ticks = Number(execFileSync("getconf", ["CLK_TCK"], { encoding: "utf8" }).trim());
+  const bootSeconds = Number(/^btime (\d+)$/m.exec(textFile("/proc/stat"))?.[1]);
+  if (!bootId || !machineId || !namespace || !(ticks > 0) || !(bootSeconds > 0))
+    throw new Error("process-clock-unavailable");
+  return {
+    bootId,
+    machineId,
+    pidDomain: `linux:${machineId}:${namespace}`,
+    ticks,
+    bootMs: bootSeconds * 1000,
+  };
+}
+
+/** @param {ReturnType<typeof processClock>} clock */
+export function scanProcesses(clock) {
+  /** @type {import('../common/recovery-types.ts').ProcessObservation[]} */
+  const processes = [];
+  let rejected = 0;
+  const entries = fs.readdirSync("/proc").filter((v) => /^\d+$/.test(v));
+  let excluded = 0;
+  for (const entry of entries) {
+    const base = `/proc/${entry}`;
+    try {
+      if (fs.statSync(base).uid !== process.getuid?.()) {
+        excluded++;
+        continue;
+      }
+      const pid = Number(entry);
+      const stat = parseProcStat(textFile(`${base}/stat`), pid);
+      if (!stat) {
+        rejected++;
+        continue;
+      }
+      const executable = fs.readlinkSync(`${base}/exe`);
+      // Inspect only executable/script selectors; no arguments or environ are retained.
+      const argv = textFile(`${base}/cmdline`).split("\0", 2);
+      const comm = textFile(`${base}/comm`).trim();
+      const selectorDigest = createHash("sha256")
+        .update(
+          JSON.stringify([
+            executable,
+            comm,
+            argv[0],
+            /^(node|bun|python)/.test(path.basename(executable)) ? argv[1] : "",
+          ]),
+        )
+        .digest("hex");
+      const cwd = fs.readlinkSync(`${base}/cwd`);
+      const executableIdentity = fileIdentity(`${base}/exe`).identity;
+      // PID numbers read via this procfs belong to the observer's domain, not the target's ns.
+      const pidDomain = clock.pidDomain;
+      const check = parseProcStat(textFile(`${base}/stat`), pid);
+      if (!check || check.startTicks !== stat.startTicks || check.ppid !== stat.ppid) {
+        rejected++;
+        continue;
+      }
+      processes.push({
+        pid,
+        ...stat,
+        birthMs: clock.bootMs + (Number(stat.startTicks) * 1000) / clock.ticks,
+        bootId: clock.bootId,
+        pidDomain,
+        executable,
+        executableIdentity,
+        selectorDigest,
+        cwd,
+        harness: recoveryHarness({ comm, executable, argv0: argv[0] ?? "", argv1: argv[1] ?? "" }),
+      });
+    } catch {
+      rejected++;
+    }
+  }
+  return {
+    processes,
+    coverage: {
+      source: "procfs-current-user",
+      state: "observed",
+      observed: entries.length,
+      rejected,
+      limitations: [
+        `other-user-pids-excluded:${excluded}`,
+        "exec/script recognition is local evidence, not authentication",
+        "processes may exit or appear during scan",
+      ],
+    },
+  };
+}
+
+/** @param {number} pid */
+export function openJsonlDescriptors(pid) {
+  const dir = `/proc/${pid}/fd`;
+  const results = [];
+  try {
+    for (const name of fs.readdirSync(dir)) {
+      try {
+        const descriptor = `${dir}/${name}`;
+        const target = fs.readlinkSync(descriptor);
+        if (target.endsWith(".jsonl"))
+          results.push({ descriptor, target, identity: fileIdentity(descriptor).identity });
+      } catch {
+        /* An fd can close while it is enumerated. */
+      }
+    }
+  } catch {
+    return { state: "unavailable", descriptors: [] };
+  }
+  return { state: "observed", descriptors: results };
+}