@brainervirus/workit-pi 8.20.0 → 8.21.0

package/dist/worker.js

@@ -8476,8 +8476,38 @@ var TIER_HOSTS = new Set([
 ]);
 
 // packages/workit-core/src/git/rev.ts
+import { spawnSync } from "node:child_process";
 var MAX_BUFFER = 256 * 1024 * 1024;
+var GIT_TIMEOUTS = { local: 20000, worktree: 120000, network: 15000 };
+var git = (cwd, args, options = {}) => {
+  const result = spawnSync("git", args, {
+    cwd,
+    encoding: "utf8",
+    env: options.env ?? process.env,
+    input: options.input,
+    maxBuffer: MAX_BUFFER,
+    timeout: options.timeoutMs ?? GIT_TIMEOUTS.local,
+    killSignal: "SIGKILL",
+    windowsHide: true
+  });
+  const error = result.error;
+  return {
+    ok: result.status === 0,
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? "",
+    timedOut: error?.code === "ETIMEDOUT"
+  };
+};
+var line = (run) => {
+  if (!run.ok)
+    return null;
+  const value = run.stdout.trim();
+  return value ? value : null;
+};
 var MAX_UNTRACKED_BYTES = 5 * 1024 * 1024;
+function currentBranch(cwd) {
+  return line(git(cwd, ["symbolic-ref", "--short", "-q", "HEAD"]));
+}
 
 // packages/workit-core/src/core/release-tracks.ts
 var KNOWN_FIELDS = new Set([
@@ -8540,6 +8570,160 @@ var STACK_WORDS = new Set(["stack", "stacktrace", "trace"]);
 var escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 var homePattern = new RegExp(`${escapeRegExp(os.homedir())}(?=[/\\\\]|$)|\\$HOME(?=[/\\\\]|$)`, "g");
 
+// packages/workit-core/src/store/paths.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+import fs from "node:fs";
+import path2 from "node:path";
+var NOT_A_REPO = /not a git repository \(or any (of the parent directories|parent up to)/u;
+var gitRun = (cwd, args) => {
+  const run = spawnSync2("git", args, {
+    cwd,
+    encoding: "utf8",
+    timeout: 20000,
+    killSignal: "SIGKILL",
+    windowsHide: true,
+    env: {
+      ...process.env,
+      GIT_TERMINAL_PROMPT: "0",
+      GIT_OPTIONAL_LOCKS: "0",
+      LC_ALL: "C",
+      LANGUAGE: "C"
+    }
+  });
+  const error = run.error;
+  return {
+    ok: run.status === 0,
+    stdout: run.stdout ?? "",
+    stderr: error ? String(error.message) : run.stderr ?? "",
+    missing: error?.code === "ENOENT"
+  };
+};
+var real = (file) => {
+  try {
+    return fs.realpathSync.native(file);
+  } catch {
+    return file;
+  }
+};
+var DISCOVERY_ENV = [
+  "GIT_DIR",
+  "GIT_COMMON_DIR",
+  "GIT_WORK_TREE",
+  "GIT_CEILING_DIRECTORIES",
+  "GIT_DISCOVERY_ACROSS_FILESYSTEM"
+];
+var isGitDir = (dir) => {
+  try {
+    return fs.statSync(path2.join(dir, "HEAD")).isFile() && fs.statSync(path2.join(dir, "objects")).isDirectory() && fs.statSync(path2.join(dir, "refs")).isDirectory();
+  } catch {
+    return false;
+  }
+};
+var reftableRefs = (common) => {
+  try {
+    return /^\s*refstorage\s*=\s*reftable\s*$/imu.test(fs.readFileSync(path2.join(common, "config"), "utf8"));
+  } catch {
+    return false;
+  }
+};
+function fastGit(root) {
+  if (DISCOVERY_ENV.some((name) => process.env[name]))
+    return null;
+  let dir = real(root);
+  let device = null;
+  for (;; ) {
+    let stat;
+    try {
+      stat = fs.statSync(dir);
+    } catch {
+      return null;
+    }
+    if (device !== null && stat.dev !== device)
+      return { kind: "none" };
+    device = stat.dev;
+    const dotGit = path2.join(dir, ".git");
+    let entry = null;
+    try {
+      entry = fs.statSync(dotGit);
+    } catch {}
+    let gitDir = null;
+    let top = null;
+    if (entry) {
+      top = dir;
+      if (entry.isDirectory())
+        gitDir = dotGit;
+      else if (entry.isFile()) {
+        let text = "";
+        try {
+          text = fs.readFileSync(dotGit, "utf8");
+        } catch {
+          return null;
+        }
+        const match = /^gitdir: (.+)$/mu.exec(text);
+        if (!match)
+          return null;
+        gitDir = path2.resolve(dir, match[1].trim());
+      } else
+        return null;
+      if (!fs.existsSync(path2.join(gitDir, "HEAD")))
+        return null;
+    } else if (isGitDir(dir))
+      gitDir = dir;
+    if (gitDir) {
+      let common = gitDir;
+      try {
+        common = path2.resolve(gitDir, fs.readFileSync(path2.join(gitDir, "commondir"), "utf8").trim());
+      } catch {}
+      if (!fs.existsSync(path2.join(common, "objects")))
+        return null;
+      return {
+        kind: "repo",
+        common: real(common),
+        gitDir: real(gitDir),
+        top: top === null ? null : real(top),
+        reftable: reftableRefs(common)
+      };
+    }
+    const parent = path2.dirname(dir);
+    if (parent === dir)
+      return { kind: "none" };
+    dir = parent;
+  }
+}
+function resolveStore(root) {
+  root = path2.resolve(root);
+  let directory = false;
+  try {
+    directory = fs.statSync(root).isDirectory();
+  } catch {}
+  if (!directory)
+    return { dir: path2.join(root, ".workit"), shared: false, top: null };
+  const fast = fastGit(root);
+  if (fast?.kind === "none")
+    return { dir: path2.join(root, ".workit"), shared: false, top: null };
+  if (fast?.kind === "repo")
+    return {
+      dir: path2.join(fast.common, "workit"),
+      shared: true,
+      top: fast.top,
+      git: { gitDir: fast.gitDir, top: fast.top, reftable: fast.reftable }
+    };
+  const run = gitRun(root, ["rev-parse", "--path-format=absolute", "--git-common-dir"]);
+  const common = run.stdout.trim();
+  if (run.ok && common) {
+    const top = gitRun(root, ["rev-parse", "--path-format=absolute", "--show-toplevel"]);
+    return {
+      dir: path2.join(real(path2.resolve(root, common)), "workit"),
+      shared: true,
+      top: top.ok && top.stdout.trim() ? real(top.stdout.trim()) : null
+    };
+  }
+  if (run.missing || !run.ok && NOT_A_REPO.test(run.stderr))
+    return { dir: path2.join(root, ".workit"), shared: false, top: null };
+  return new Error(`cannot locate the workit store: git rev-parse failed (${run.stderr.trim().split(`
+`)[0] || "no output"}); fix the repository (git status should work here)`);
+}
+
 // packages/workit-core/src/host-session.ts
 var OWN_CHILD_SHELL = new Set(["opencode", "pi"]);
 var SESSION_UNSAFE = /[^A-Za-z0-9_.:@/+-]/g;
@@ -8551,20 +8735,20 @@ function childSessionId(lead, child) {
 
 // packages/workit-core/src/core/package-root.ts
 import { existsSync } from "node:fs";
-import path2 from "node:path";
+import path3 from "node:path";
 import { fileURLToPath } from "node:url";
 var packageRoot = () => {
-  let dir = path2.dirname(fileURLToPath(import.meta.url));
+  let dir = path3.dirname(fileURLToPath(import.meta.url));
   while (true) {
-    const parent = path2.dirname(dir);
-    if (existsSync(path2.join(dir, "package.json")) || parent === dir)
+    const parent = path3.dirname(dir);
+    if (existsSync(path3.join(dir, "package.json")) || parent === dir)
       return dir;
     dir = parent;
   }
 };
 var assetRoot = () => {
   const root = packageRoot();
-  const assets = path2.join(root, "assets");
+  const assets = path3.join(root, "assets");
   return existsSync(assets) ? assets : root;
 };
 
@@ -8617,6 +8801,57 @@ var STALE_TEMPORARY_MS = 60 * 60000;
 var origins = new Map;
 var heldInProcess = new Map;
 // packages/workit-core/src/ledger.ts
+import { spawnSync as spawnSync3 } from "node:child_process";
+import { createHash as createHash3, randomBytes } from "node:crypto";
+import fs3 from "node:fs";
+import path5 from "node:path";
+
+// packages/workit-core/src/hooks/standing-signal.ts
+import { createHash as createHash2 } from "node:crypto";
+import fs2 from "node:fs";
+import path4 from "node:path";
+var gitStoreDir = (cwd) => {
+  try {
+    for (let dir = path4.resolve(cwd);; dir = path4.dirname(dir)) {
+      const dotGit = path4.join(dir, ".git");
+      if (fs2.existsSync(dotGit)) {
+        let gitDir = dotGit;
+        if (fs2.statSync(dotGit).isFile()) {
+          const target = /^gitdir:\s*(.+)$/mu.exec(fs2.readFileSync(dotGit, "utf8"))?.[1]?.trim();
+          if (!target)
+            return null;
+          gitDir = path4.resolve(dir, target);
+          const common = path4.join(gitDir, "commondir");
+          if (fs2.existsSync(common))
+            gitDir = path4.resolve(gitDir, fs2.readFileSync(common, "utf8").trim());
+        }
+        return path4.join(gitDir, "workit");
+      }
+      if (path4.dirname(dir) === dir)
+        return null;
+    }
+  } catch {
+    return null;
+  }
+};
+var standingRevFile = (store) => path4.join(store, "standing", "rev");
+var standingSeenFile = (store, session, agentId) => path4.join(store, "standing", "seen", `${createHash2("sha256").update(`${session}\x00${agentId ?? ""}`).digest("hex").slice(0, 32)}.json`);
+var readStandingRev = (store) => {
+  try {
+    return fs2.readFileSync(standingRevFile(store), "utf8").trim() || null;
+  } catch {
+    return null;
+  }
+};
+var writeStandingSeen = (file, seen) => {
+  try {
+    fs2.mkdirSync(path4.dirname(file), { recursive: true });
+    fs2.writeFileSync(file, JSON.stringify(seen));
+  } catch {}
+};
+
+// packages/workit-core/src/ledger.ts
+var LEDGER_VERSION = 1;
 var PASSING = new Set(["verified", "tests-verified", "type-check-only"]);
 var FAILING = new Set(["failed", "blocked"]);
 var STRONG_RESULTS = new Set(["verified", "tests-verified"]);
@@ -8626,6 +8861,50 @@ var PR_ROW_TYPES = new Set([
   "pr.merged",
   "pr.linked"
 ]);
+var err = (code, error, unblock) => ({
+  ok: false,
+  code,
+  error,
+  ...unblock ? { unblock } : {}
+});
+var gitRun2 = (cwd, args, timeoutMs = GIT_TIMEOUTS.local) => {
+  const run = spawnSync3("git", args, {
+    cwd,
+    encoding: "utf8",
+    timeout: timeoutMs,
+    killSignal: "SIGKILL",
+    windowsHide: true,
+    maxBuffer: 256 * 1024 * 1024,
+    env: {
+      ...process.env,
+      GIT_TERMINAL_PROMPT: "0",
+      GIT_OPTIONAL_LOCKS: "0",
+      LC_ALL: "C",
+      LANGUAGE: "C"
+    }
+  });
+  return {
+    ok: run.status === 0,
+    stdout: run.stdout ?? "",
+    stderr: run.error ? String(run.error.message) : run.stderr ?? ""
+  };
+};
+var git2 = (cwd, args) => {
+  const run = gitRun2(cwd, args);
+  const value = run.ok ? run.stdout.trim() : "";
+  return value ? value : null;
+};
+var safeRef = (value) => value.length > 0 && !value.startsWith("-");
+function storeRoot(cwd) {
+  const location = resolveStore(path5.resolve(cwd));
+  if (location instanceof Error)
+    return err("unavailable", location.message.replace(/; fix the repository.*$/u, ""), "fix the repository (git status should work here) or run from a non-git directory");
+  return { ok: true, value: { root: location.dir, shared: location.shared } };
+}
+function ledgerPath(cwd) {
+  const root = storeRoot(cwd);
+  return root.ok ? { ok: true, value: path5.join(root.value.root, "ledger", "ledger.jsonl") } : root;
+}
 var NETWORK_FS_TYPES = new Set([
   26985,
   20859,
@@ -8638,9 +8917,219 @@ var NETWORK_FS_TYPES = new Set([
   1196443219,
   198183888
 ]);
+var sha2562 = (text) => createHash3("sha256").update(text).digest("hex");
+var chainHash = (prevHash, body) => sha2562(`${prevHash ?? ""}
+${body}`);
 var TAIL_BYTES = 64 * 1024;
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var str2 = (value) => typeof value === "string" ? value : null;
+var normalizeActor = (value) => {
+  const actor = isRecord(value) ? value : {};
+  return {
+    host: str2(actor.host) ?? "unknown",
+    session: str2(actor.session),
+    agentId: str2(actor.agentId)
+  };
+};
+function supersedeAllowed(by, target, onBranch = (row) => (by.branch ?? null) === (row.branch ?? null)) {
+  if (by.type !== target.type)
+    return `a ${by.type} row cannot supersede a ${target.type} row`;
+  if (!by.actor.session || by.actor.session !== target.actor.session)
+    return "only the session that wrote a row can supersede it";
+  if (!onBranch(target))
+    return `the row is on another branch (${String(target.branch ?? "none")}); a row supersedes only one on its own branch`;
+  if (by.type === "verdict" && (by.kind ?? "review") !== (target.kind ?? "review"))
+    return `a ${String(by.kind ?? "review")} verdict cannot supersede a ${String(target.kind ?? "review")} verdict; record it with --kind ${String(target.kind ?? "review")}`;
+  if (by.type === "verdict" && by.self === true && target.self !== true)
+    return "a self verdict cannot replace an independent verdict";
+  return null;
+}
+function readLedger(cwd, options = {}) {
+  const file = ledgerPath(cwd);
+  if (!file.ok)
+    return file;
+  let text = "";
+  let stat = null;
+  try {
+    stat = fs3.statSync(file.value);
+    text = fs3.readFileSync(file.value, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return {
+        ok: true,
+        value: {
+          path: file.value,
+          rows: [],
+          skipped: 0,
+          integrity: options.integrity ? { chained: 0, legacy: 0, unverified: [] } : null
+        }
+      };
+    return err("unavailable", `cannot read ${file.value}: ${error.message}`);
+  }
+  const rows = [];
+  let skipped = 0;
+  const integrity = { chained: 0, legacy: 0, unverified: [] };
+  const earlier = new Set([null]);
+  let chainStarted = false;
+  const ids = new Set;
+  for (const raw of text.split(`
+`)) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+      continue;
+    const linked = (prevHash) => earlier.has(prevHash);
+    if (options.integrity)
+      earlier.add(sha2562(trimmed));
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      skipped += 1;
+      continue;
+    }
+    if (!isRecord(parsed) || !str2(parsed.id) || !str2(parsed.type) || !str2(parsed.at)) {
+      skipped += 1;
+      continue;
+    }
+    let rowIntegrity = options.integrity ? "verified" : undefined;
+    let reason = null;
+    if (!options.integrity) {} else if (typeof parsed.rowHash === "string") {
+      chainStarted = true;
+      const { rowHash, ...body } = parsed;
+      const prevHash = str2(parsed.prevHash);
+      if (chainHash(prevHash, JSON.stringify(body)) !== rowHash)
+        reason = "hash_mismatch";
+      else if (!linked(prevHash))
+        reason = "broken_link";
+    } else if (chainStarted)
+      reason = "unsigned";
+    else
+      rowIntegrity = "legacy";
+    if (options.integrity && !reason && ids.has(parsed.id))
+      reason = "duplicate_id";
+    if (options.integrity)
+      ids.add(parsed.id);
+    if (reason)
+      rowIntegrity = "unverified";
+    const pr = typeof parsed.pr === "number" && Number.isInteger(parsed.pr) ? parsed.pr : undefined;
+    const row = {
+      ...parsed,
+      v: typeof parsed.v === "number" ? parsed.v : LEDGER_VERSION,
+      id: parsed.id,
+      at: parsed.at,
+      type: parsed.type,
+      actor: normalizeActor(parsed.actor),
+      branch: str2(parsed.branch),
+      head: str2(parsed.head),
+      base: str2(parsed.base),
+      baseSha: str2(parsed.baseSha),
+      patchId: str2(parsed.patchId),
+      diffHash: str2(parsed.diffHash),
+      tree: str2(parsed.tree),
+      dirty: typeof parsed.dirty === "boolean" ? parsed.dirty : null,
+      ...pr === undefined ? {} : { pr },
+      ...str2(parsed.supersedes) ? { supersedes: parsed.supersedes } : {},
+      seq: rows.length + 1,
+      superseded: false,
+      supersedeIgnored: false,
+      ...rowIntegrity ? { integrity: rowIntegrity } : {},
+      ...reason ? { integrityReason: reason } : {}
+    };
+    rows.push(row);
+    if (!options.integrity)
+      continue;
+    if (rowIntegrity === "verified")
+      integrity.chained += 1;
+    else if (rowIntegrity === "legacy")
+      integrity.legacy += 1;
+    else if (reason)
+      integrity.unverified.push({
+        seq: row.seq,
+        id: row.id,
+        type: row.type,
+        branch: row.branch,
+        reason
+      });
+  }
+  const scopes = new Map;
+  const scopeOf = (branch) => {
+    let scope = scopes.get(branch);
+    if (!scope)
+      scopes.set(branch, scope = branchScope(cwd, branch));
+    return scope;
+  };
+  const byId = new Map;
+  for (const row of rows) {
+    const target = row.supersedes ? byId.get(row.supersedes) : undefined;
+    if (target && row.integrity !== "unverified" && supersedeAllowed(row, target, renameAwareBranch(scopeOf, row.branch)) === null)
+      target.superseded = true;
+    else if (row.supersedes)
+      row.supersedeIgnored = true;
+    if (!byId.has(row.id))
+      byId.set(row.id, row);
+  }
+  if (options.integrity && stat && Buffer.byteLength(text) === stat.size)
+    tamperCache.set(file.value, {
+      size: stat.size,
+      stamp: fileStamp(stat),
+      breaks: integrity.unverified.filter((row) => TAMPER_REASONS.has(row.reason))
+    });
+  return {
+    ok: true,
+    value: { path: file.value, rows, skipped, integrity: options.integrity ? integrity : null }
+  };
+}
 var TAMPER_REASONS = new Set(["hash_mismatch", "broken_link"]);
 var tamperCache = new Map;
+var fileStamp = (stat) => `${stat.ino}:${stat.mtimeMs}:${stat.ctimeMs}`;
+var RENAMED = /^branch: renamed refs\/heads\/(.+) to refs\/heads\/(.+)$/iu;
+function branchScope(cwd, branch) {
+  const renamedAt = new Map;
+  let since = Number.NEGATIVE_INFINITY;
+  if (safeRef(branch)) {
+    const log = git2(cwd, [
+      "log",
+      "-g",
+      "--date=unix",
+      "--format=%gd%x09%gs",
+      `refs/heads/${branch}`,
+      "--"
+    ]);
+    for (const line of (log ?? "").split(`
+`)) {
+      const [selector = "", subject = ""] = line.split("\t");
+      const seconds = Number(/@\{(\d+)\}$/u.exec(selector)?.[1]);
+      if (!Number.isFinite(seconds))
+        continue;
+      since = seconds * 1000;
+      const match = RENAMED.exec(subject);
+      if (!match || match[1] === branch)
+        continue;
+      const until = (seconds + 1) * 1000;
+      renamedAt.set(match[1], Math.max(renamedAt.get(match[1]) ?? 0, until));
+    }
+  }
+  return (row) => {
+    if (row.branch === branch)
+      return true;
+    const until = row.branch === null ? undefined : renamedAt.get(row.branch);
+    if (until === undefined)
+      return false;
+    const at = Date.parse(row.at);
+    return at >= since && at <= until;
+  };
+}
+var renameAwareBranch = (scopeOf, branch) => {
+  return (target) => {
+    const own = typeof branch === "string" ? branch : null;
+    const theirs = typeof target.branch === "string" ? target.branch : null;
+    if (own === theirs)
+      return true;
+    if (own === null || theirs === null || typeof target.at !== "string")
+      return false;
+    return scopeOf(own)({ branch: theirs, at: target.at });
+  };
+};
 var TRUST_REASONS = new Set([
   "unsigned",
   "hash_mismatch",
@@ -8656,6 +9145,28 @@ var SHELL_VOUCHED_HOSTS = new Set([
   "codex_cli",
   "codex_desktop"
 ]);
+var fromLead = (row, leads) => leads === null || row.actor.session !== null && leads.includes(row.actor.session);
+function activeStanding(rows, fanout, leads = null) {
+  const active = [];
+  for (const row of rows) {
+    if (row.fanout !== fanout || !fromLead(row, leads))
+      continue;
+    if (row.type === "standing" && typeof row.what === "string" && row.what.trim()) {
+      if (!row.superseded)
+        active.push(row);
+    } else if (row.type === "standing.cleared") {
+      const target = str2(row.target);
+      if (target === null)
+        active.length = 0;
+      else {
+        const index = active.findIndex((order) => order.id === target);
+        if (index >= 0)
+          active.splice(index, 1);
+      }
+    }
+  }
+  return active;
+}
 var OBSERVED_ONLY = new Set([
   "check",
   "merge.unverified",
@@ -8850,12 +9361,82 @@ var contextReadSchema = object({
   planPath: string2().optional(),
   cwd: string2().min(1).optional()
 }).strict();
+// packages/workit-core/src/hooks/standing.ts
+import fs4 from "node:fs";
+import path6 from "node:path";
+var readPlans = (store) => {
+  const dir = path6.join(store, "fanouts");
+  let names;
+  try {
+    names = fs4.readdirSync(dir).filter((name) => name.endsWith(".json"));
+  } catch {
+    return [];
+  }
+  const plans = [];
+  for (const name of names) {
+    try {
+      const raw = JSON.parse(fs4.readFileSync(path6.join(dir, name), "utf8"));
+      if (typeof raw.name !== "string" || !Array.isArray(raw.slices))
+        continue;
+      const texts = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string" && item !== "") : [];
+      plans.push({
+        name: raw.name,
+        leads: texts([raw.leadSession, ...texts(raw.formerLeads)]),
+        branches: texts(raw.slices.map((slice) => slice && typeof slice === "object" ? slice.branch : null))
+      });
+    } catch {}
+  }
+  return plans;
+};
+var leadOf = (input) => input.session.parentId ?? (input.session.agentId ? input.session.id : null) ?? (input.session.id.includes(":") ? input.session.id.split(":")[0] : null);
+var worksFor = (plan, input, branch) => {
+  const session = input.session.id;
+  if (plan.leads.includes(session) && !input.session.agentId)
+    return false;
+  const lead = leadOf(input);
+  if (lead && plan.leads.includes(lead))
+    return true;
+  if (plan.leads.some((each) => session.startsWith(`${each}-w-`)))
+    return true;
+  const current = branch();
+  return current !== null && plan.branches.includes(current);
+};
+var standingFor = (input, store, rev) => {
+  const orders = new Map;
+  const ledger = readLedger(input.cwd);
+  const rows = ledger.ok ? ledger.value.rows : [];
+  let branch;
+  const lazyBranch = () => branch === undefined ? branch = currentBranch(input.cwd) : branch;
+  for (const plan of readPlans(store))
+    if (worksFor(plan, input, lazyBranch))
+      for (const row of activeStanding(rows, plan.name, plan.leads.length ? plan.leads : null))
+        orders.set(row.id, row);
+  return { rev, orders, rows };
+};
+var located = (input) => {
+  const store = input.session.id ? gitStoreDir(input.cwd) : null;
+  const rev = store ? readStandingRev(store) : null;
+  if (!store || rev === null)
+    return null;
+  return { store, rev, file: standingSeenFile(store, input.session.id, input.session.agentId) };
+};
+var seedStanding = (input) => {
+  try {
+    const where = located(input);
+    if (!where)
+      return;
+    const now = standingFor(input, where.store, where.rev);
+    writeStandingSeen(where.file, { rev: where.rev, ids: [...now.orders.keys()] });
+  } catch {}
+};
+var sinceStart = new Map;
+
 // packages/workit-pi/src/worker-protocol.ts
 var MAX_WORKER_LINE_BYTES = 64 * 1024;
 var MAX_WORKER_STDERR_BYTES = 64 * 1024;
-var isRecord = (value) => typeof value === "object" && value !== null;
+var isRecord2 = (value) => typeof value === "object" && value !== null;
 var parseEvent = (value) => {
-  if (!isRecord(value) || typeof value.type !== "string")
+  if (!isRecord2(value) || typeof value.type !== "string")
     return null;
   if (value.type === "workit_worker_ready") {
     if (typeof value.workerId !== "string" || typeof value.sessionId !== "string")
@@ -9013,6 +9594,14 @@ function launchWorker(assignment, options) {
     WORKIT_PI_WORKER_ROLE: assignment.role,
     WORKIT_PI_WORKER_SCOPE: JSON.stringify(assignment.scope)
   };
+  seedStanding({
+    host: "pi",
+    cwd: spec.cwd,
+    session: { id: env.WORKIT_SESSION_ID, agentId: null, agentType: null, parentId: null },
+    permissionMode: null,
+    transcriptPath: null,
+    event: { kind: "session.start", source: "startup" }
+  });
   try {
     const spawn = options.spawn ?? ((command, args, spawnOptions) => nodeSpawn(command, args, spawnOptions));
     handle.spec = { ...spec, env };