@plannotator/pi-extension 0.28.50 → 0.28.51

package/generated/config.ts

@@ -7,7 +7,7 @@
  */
 
 import { childEnv } from "./child-env.ts";
-import { join } from "path";
+import { isAbsolute, join, resolve } from "path";
 import { getPlannotatorDataDir } from "./data-dir.ts";
 import {
   readFileSync,
@@ -559,6 +559,20 @@ export interface PlannotatorConfig {
    * a tagged machine, which has no owner. Config only. Default: none.
    */
   inboxTailscaleAllow?: string[];
+  /**
+   * Launch agents from the Inbox (compose's "New Claude Code session";
+   * packages/server/inbox-launch.ts). `enabled`: config only, default false,
+   * off, compose, the thread and every route are as before.
+   * `fullPermissions`: Settings → Agents' "Start new sessions with full
+   * permissions" (bypass mode); never set, a launch follows the person's
+   * login shell (CLAUDE_CODE_EVEN_MORE_DANGEROUSLY_SKIP_PERMISSIONS). `model`: config only, a model name such as
+   * `haiku` for each launch's settings file (the manual smoke); anything that
+   * is not a plain model name is ignored. `scratchDir`: Settings → Agents'
+   * "Scratch folders", where "New scratch folder" makes each new folder (an
+   * absolute path; default `<dataDir>/scratch`). Moving it applies to new
+   * folders only.
+   */
+  inboxLaunch?: { enabled?: boolean; fullPermissions?: boolean; model?: string; scratchDir?: string };
   /**
    * Inject a Plannotator Flavored Markdown reminder into every EnterPlanMode
    * call so the agent is aware it can enrich plans with code-file links,
@@ -1218,6 +1232,24 @@ export function resolveDefaultDiffTypeFor(
   return v === 'jj-current' || v === 'jj-last' || v === 'jj-line' || v === 'jj-evolog' || v === 'jj-all' ? v : 'jj-current';
 }
 
+/** A model name as Claude Code takes it (`haiku`, `claude-opus-4-1`, `opus[1m]`): letters, digits, `.`, `_`, `-`, `[`, `]`. */
+const LAUNCH_MODEL = /^[\w.\-[\]]{1,64}$/;
+
+/**
+ * config.inboxLaunch, coerced: off unless `enabled` is true; `model` only when it is a plain model name;
+ * `scratchDir` only when it is an absolute path other than `/` (null: the default, `<dataDir>/scratch`).
+ */
+export function resolveInboxLaunch(config: PlannotatorConfig): { enabled: boolean; fullPermissions: boolean | null; model: string | null; scratchDir: string | null } {
+  const value = config.inboxLaunch && typeof config.inboxLaunch === "object" ? config.inboxLaunch : {};
+  return {
+    enabled: coerceConfigBoolean(value.enabled, false),
+    // null: the person never set the switch (a launch follows their login shell).
+    fullPermissions: parseConfigBoolean(value.fullPermissions) ?? null,
+    model: typeof value.model === "string" && LAUNCH_MODEL.test(value.model) ? value.model : null,
+    scratchDir: typeof value.scratchDir === "string" && isAbsolute(value.scratchDir) && resolve(value.scratchDir) !== resolve("/") ? resolve(value.scratchDir) : null,
+  };
+}
+
 /**
  * Coerce a config.json value that should be a boolean. JSON parsing preserves
  * whatever type the user typed, so a hand-edited `"false"` (quoted) arrives as

package/generated/diff-files.ts

@@ -113,6 +113,19 @@ export function parseDiffToFiles(rawPatch: string): DiffFile[] {
   return files;
 }
 
+/** The two blobs a file's patch runs between (its `index` line). */
+export interface PatchBlobIds {
+  oldId: string;
+  newId: string;
+}
+
+/** A file's `index` blob ids; null when there is no such line (GitLab's rebuilt patches) or a side does not exist (all zeros). */
+export function patchBlobIds(patch: string): PatchBlobIds | null {
+  const ids = /^index ([0-9a-f]{7,64})\.\.([0-9a-f]{7,64})/m.exec(patch);
+  if (!ids || /^0+$/.test(ids[1]!) || /^0+$/.test(ids[2]!)) return null;
+  return { oldId: ids[1]!, newId: ids[2]! };
+}
+
 /** One line of a hunk, numbered on each side it exists on. `text` drops the ` `/`+`/`-` prefix. */
 export type DiffHunkLine =
   | { kind: "context"; oldLine: number; newLine: number; text: string }

package/generated/guide-viewer-manifest.ts

@@ -6,10 +6,10 @@
 import type { GuideViewerAssets } from "./guide-format.ts";
 
 export const GUIDE_VIEWER_MANIFEST: Omit<GuideViewerAssets, "baseUrl"> = {
-  js: "viewer.DOAD0J-z.js",
-  css: "viewer.BNAWy9fE.css",
-  jsIntegrity: "sha384-gTRUeyKROuoVEcrx0xREkS1ITbCZwah9MkDjsRfVMrCEgtGa2ZXGd3emZa+oeVXh",
-  cssIntegrity: "sha384-X4c5I/iPKAqFtOuCQJJxlH1IZ5rDhT9nNBxQJ9JwjJ1W8ryzDZPb52INO+uGg9Cx",
+  js: "viewer.Bh38x7eb.js",
+  css: "viewer.DQlAZIQO.css",
+  jsIntegrity: "sha384-kTcI5/tmk5lJy6WIKj+Q8x8Revf/kzEzg/GObKZdig0kdL2tV/wbGyy1KaNm1aG5",
+  cssIntegrity: "sha384-GCY67iUks9B4xUXsjYkdSroZmJDmLMOtQFnvhshUgakVdrt9dCHOGgKaEw2UNxE7",
   langs: {
     "astro": "chunks/astro.Ts5EKq2l.js",
     "c": "chunks/c.BIGW1oBm.js",

package/generated/inbox/agent-link.ts

@@ -42,6 +42,8 @@ import {
   INBOX_BRIDGE_EVENT_PATH,
   INBOX_BRIDGE_POLL_PATH,
   INBOX_SEND_NOW_POLL_FIELD,
+  INBOX_STEER_POLLS_POLL_FIELD,
+  inboxClaimName,
   INBOX_TAGS_POLL_FIELD,
   INBOX_TOOL_NAME,
   inboxHealthPeeks,
@@ -94,13 +96,12 @@ function rememberedToolsFileOf(dataDir: string): string {
 }
 
 /**
- * The claim folder of one delivery. A reply that tags agents goes to several
- * sessions, which may share this data dir (two Pi sessions, Pi and OpenCode):
- * a tagged session's claim names its session too, so each is delivered once.
+ * The claim folder of one delivery. A reply can go to several sessions, which may share this data dir (two Pi
+ * sessions, Pi and OpenCode): a reply that tags agents, or one moved after its session stopped holding the claim. So
+ * the claim names the session too, and each is delivered once.
  */
-function claimDirOf(dataDir: string, replyId: string, taggedSession?: string | null): string {
-  const name = taggedSession ? `${replyId}.${taggedSession.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 120)}` : replyId;
-  return join(dataDir, "inbox", "claims", name);
+function claimDirOf(dataDir: string, replyId: string, session: string): string {
+  return join(dataDir, "inbox", "claims", inboxClaimName(replyId, session));
 }
 
 /** One session's lease on one host: which of its processes polls and delivers. */
@@ -659,11 +660,13 @@ export class InboxWake {
       (this.steerable || busy === false);
     if (!this.delivering && this.pending.size > 0 && (this.idleTicks >= 2 || urgent)) {
       this.delivering = true;
-      try {
-        await this.deliverNext(this.idleTicks < 2 && urgent);
-      } finally {
-        this.delivering = false;
-      }
+      // Not awaited: a steer resolves only when the message enters the run, which a long tool call can hold for
+      // minutes, and the tick has to go on polling meanwhile, or the session reads as ended (the Claude Code mod's way).
+      void this.deliverNext(this.idleTicks < 2 && urgent)
+        .catch(() => undefined)
+        .finally(() => {
+          this.delivering = false;
+        });
     }
   }
 
@@ -733,6 +736,7 @@ export class InboxWake {
         started_at: this.startedAt,
         ...(this.busy === null ? {} : { busy: this.busy, idle_since: this.idleSince }),
         ...(this.steerable ? { [INBOX_SEND_NOW_POLL_FIELD]: true } : {}),
+        [INBOX_STEER_POLLS_POLL_FIELD]: true,
         // Tags (approval "inbox-tag-agents"): this connection words a reply it was tagged in truthfully.
         [INBOX_TAGS_POLL_FIELD]: true,
         // What this process loaded (additive): the Inbox says when the session runs an older one.
@@ -757,6 +761,9 @@ export class InboxWake {
       }
       this.backoffMs = 0;
       this.retryAt = 0;
+      // What the Inbox stopped handing out is done with here: handed out again (the reply moved back), it is new.
+      const handedOut = new Set(commands.map((command) => command.id));
+      for (const id of this.settled) if (!handedOut.has(id)) this.settled.delete(id);
       for (const command of commands) {
         // A later poll may carry `now` (the person pressed Send now): the newest command wins.
         if (!this.settled.has(command.id)) this.pending.set(command.id, command);
@@ -777,14 +784,17 @@ export class InboxWake {
    * running turn when one runs (`steer`), else as a turn at once.
    */
   private async deliverNext(urgent = false): Promise<void> {
-    const command = this.pending.values().next().value as InboxReplyCommand | undefined;
-    if (!command) return;
+    const waiting = this.pending.values().next().value as InboxReplyCommand | undefined;
+    if (!waiting) return;
     // Still waiting? An agent may have read it through the tool meanwhile, or
     // another process delivered it.
     const fresh = await this.pendingNow(0);
     if (fresh === null || this.disposed) return;
-    if (!fresh.some((candidate) => candidate.id === command.id)) {
-      this.settle(command.id);
+    // What the Inbox says now is what goes in: a reply can have moved here since it was first handed out.
+    const command = fresh.find((candidate) => candidate.id === waiting.id);
+    if (!command) {
+      // Not settled: nothing went in here, so if the reply moves back before the next poll, it goes in.
+      this.pending.delete(waiting.id);
       return;
     }
     const busy = await this.target.isBusy();
@@ -795,7 +805,12 @@ export class InboxWake {
     }
     // The person may have moved to another process since the last tick.
     if (this.disposed || !this.holdLease(Date.now())) return;
-    const claim = claimDirOf(this.connection.dataDir, command.id, command.tagged ? this.sessionId : null);
+    // An older version's claim, by the reply id alone: that process took it (the Inbox removes it when it moves the reply).
+    if (!command.tagged && existsSync(join(this.connection.dataDir, "inbox", "claims", command.id))) {
+      this.settle(command.id);
+      return;
+    }
+    const claim = claimDirOf(this.connection.dataDir, command.id, this.sessionId);
     try {
       mkdirSync(join(claim, ".."), { recursive: true, mode: 0o700 });
       mkdirSync(claim, { mode: 0o700 });

package/generated/inbox/connection.ts

@@ -31,6 +31,25 @@
  * paste). The server imports the path constants from here.
  */
 
+/** The folder name of one session's claim on one delivery (`inbox/claims/`): a moved reply is a new delivery for the next session. */
+export function inboxClaimName(replyId: string, session: string): string {
+  return `${replyId}.${session.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 120)}`;
+}
+
+/**
+ * The stop notice of a thread handed to another session goes by its own id, not the reply's. A connection only keeps the
+ * id and reports it, so what any connection or wake keeps per id (settled, claims, a T3 request), and its report, can
+ * never stand for the person's words when the reply moves back to that session. Older connections included.
+ */
+export function inboxStopNoticeId(replyId: string): string {
+  return `${replyId}-stop`;
+}
+
+/** The reply a stop notice's id belongs to; null for any other id. */
+export function inboxStopNoticeReply(id: string): string | null {
+  return id.length > '-stop'.length && id.endsWith('-stop') ? id.slice(0, -'-stop'.length) : null;
+}
+
 // --- CONTRACT (copied byte for byte into apps/hook/hooks/mod/inbox-contract.ts; edit packages/shared/inbox/connection.ts, then paste) ---
 
 /** The agent tool every connection registers. */
@@ -1076,6 +1095,13 @@ function wakeName(value: unknown): string {
  */
 export const INBOX_SEND_NOW_POLL_FIELD = 'send_now'
 
+/**
+ * On a poll, the connection's tick goes on polling while a steer waits for the running turn. A connection without it
+ * (from before that) stops polling until the steer goes in, so the Inbox counts a session it handed one as there.
+ * An older Inbox ignores it.
+ */
+export const INBOX_STEER_POLLS_POLL_FIELD = 'steer_polls'
+
 /**
  * The poll field (`true`) by which a connection says it can answer Ask AI
  * live. An older connection never sends it, so a question never waits for it.

package/generated/open-in-apps.ts

@@ -38,6 +38,12 @@ export interface OpenInApp {
   win?: { bin: string };
   /** Linux PATH binary. */
   linux?: { bin: string };
+  /**
+   * How it opens a file at a line. `mac`: the app's URL scheme, `<scheme>://file/<path>:<line>`
+   * through `open -a`. `cli`: `--goto <path>:<line>` or `<path>:<line>` on its Windows and Linux
+   * binary. Absent: the file opens at its top.
+   */
+  line?: { mac?: string; cli?: 'goto' | 'suffix' };
 }
 
 /**
@@ -62,6 +68,7 @@ export const OPEN_IN_APPS: OpenInApp[] = [
     mac: { appName: 'Visual Studio Code' },
     win: { bin: 'code' },
     linux: { bin: 'code' },
+    line: { mac: 'vscode', cli: 'goto' },
   },
   {
     id: 'cursor',
@@ -71,6 +78,7 @@ export const OPEN_IN_APPS: OpenInApp[] = [
     mac: { appName: 'Cursor' },
     win: { bin: 'cursor' },
     linux: { bin: 'cursor' },
+    line: { mac: 'cursor', cli: 'goto' },
   },
   {
     id: 'zed',
@@ -80,6 +88,7 @@ export const OPEN_IN_APPS: OpenInApp[] = [
     mac: { appName: 'Zed' },
     win: { bin: 'zed' },
     linux: { bin: 'zed' },
+    line: { cli: 'suffix' },
   },
   {
     id: 'zed-preview',
@@ -99,6 +108,7 @@ export const OPEN_IN_APPS: OpenInApp[] = [
     mac: { appName: 'Sublime Text' },
     win: { bin: 'subl' },
     linux: { bin: 'subl' },
+    line: { cli: 'suffix' },
   },
   {
     id: 'textmate',

package/generated/question-block.ts

@@ -265,6 +265,11 @@ const CHOICE_IMAGE_RE = /!\[([^\]\n]*)\]\(([^)\n]+)\)/;
 // What may follow a recommendation that names the start of a choice label
 // (`Recommended: Unpin it` for `Unpin it: the toast says…`).
 const LABEL_HEAD_SEP_RE = /^(?:\s*[:—–(]|\s+-\s)/;
+// A recommendation that is only a label's leading token, a letter or a
+// number (`Recommended: A` for `A · Yes`), names the label when the token is
+// followed by a middle dot.
+const LABEL_TOKEN_RE = /^(?:[a-z]|\d+)$/;
+const LABEL_TOKEN_SEP_RE = /^ · /;
 // At the start of the line (no indentation), so an indented line under a
 // choice stays that choice's continuation.
 const DECISION_RE = /^decision\s*:\s*(.*?)\s*$/i;
@@ -485,7 +490,9 @@ const QUESTION_KEY_RE = /^q-[0-9a-f]{8}(?:-\d{1,3})?$/;
  * The one choice a recommendation names by the start of its label: the
  * choice whose label (or any of its other names, such as a task list's full
  * text) begins with the text and then a separator (`:` `—` `–` ` - ` `(`),
- * compared case-insensitively with emphasis and spacing folded
+ * or whose leading letter or number the text is, followed by ` · `
+ * (`Recommended: A` names `A · Yes`), compared case-insensitively with
+ * emphasis and spacing folded
  * (`Recommended: Unpin it` names `Unpin it: the toast says…`). -1 when no
  * choice or several do. `names` holds each choice's names, label first.
  */
@@ -498,7 +505,9 @@ export const recommendationHeadChoice = (
   const begins = (value: string | undefined): boolean => {
     if (!value) return false;
     const folded = value.replace(/[*_`]+/g, '').replace(/\s+/g, ' ').trim().toLowerCase();
-    return folded.startsWith(target) && LABEL_HEAD_SEP_RE.test(folded.slice(target.length));
+    if (!folded.startsWith(target)) return false;
+    const rest = folded.slice(target.length);
+    return LABEL_HEAD_SEP_RE.test(rest) || (LABEL_TOKEN_RE.test(target) && LABEL_TOKEN_SEP_RE.test(rest));
   };
   const hits = names.flatMap((entry, i) => ((typeof entry === 'string' ? [entry] : entry).some(begins) ? [i] : []));
   return hits.length === 1 ? hits[0] : -1;

package/generated/review-core.ts

@@ -2520,6 +2520,37 @@ function isPathInside(root: string, child: string): boolean {
   return c === r || c.startsWith(`${r}/`);
 }
 
+/**
+ * One blob's bytes by any spec git takes (`<rev>:<path>`, or a blob id, whole
+ * or abbreviated), capped at `maxBytes`: the size is read first, and the blob
+ * stream stops at the cap. The spec goes on stdin, never argv.
+ */
+export async function readGitObjectBytes(
+  runtime: ReviewGitRuntime,
+  spec: string,
+  maxBytes: number,
+  cwd?: string,
+): Promise<FileBytesRead> {
+  if (!runtime.runGitBytes) return { kind: "unavailable" };
+  if (/[\r\n]/.test(spec)) return { kind: "missing" };
+  const check = await runtime.runGit(
+    ["cat-file", "--batch-check=%(objectname) %(objecttype) %(objectsize)"],
+    { cwd, stdin: `${spec}\n` },
+  );
+  if (check.exitCode !== 0) return { kind: "missing" };
+  const match = check.stdout.trim().match(/^([0-9a-f]{40,64}) (\S+) (\d+)$/);
+  if (!match || match[2] !== "blob") return { kind: "missing" };
+  const size = Number(match[3]);
+  if (size > maxBytes) return { kind: "too-large", size };
+  const blob = await runtime.runGitBytes(["cat-file", "blob", match[1]], {
+    cwd,
+    maxOutputBytes: maxBytes,
+  });
+  if (blob.truncated) return { kind: "too-large", size };
+  if (blob.exitCode !== 0) return { kind: "missing" };
+  return { kind: "ok", bytes: blob.stdout, etag: `"${match[1]}"` };
+}
+
 /**
  * Read one side as raw bytes for the image preview, capped at `maxBytes`.
  *
@@ -2540,25 +2571,7 @@ export async function readDiffSideBytes(
   cwd?: string,
 ): Promise<FileBytesRead> {
   if (source.kind === "object") {
-    if (!runtime.runGitBytes) return { kind: "unavailable" };
-    const spec = `${source.rev}:${source.path}`;
-    if (/[\r\n]/.test(spec)) return { kind: "missing" };
-    const check = await runtime.runGit(
-      ["cat-file", "--batch-check=%(objectname) %(objecttype) %(objectsize)"],
-      { cwd, stdin: `${spec}\n` },
-    );
-    if (check.exitCode !== 0) return { kind: "missing" };
-    const match = check.stdout.trim().match(/^([0-9a-f]{40,64}) (\S+) (\d+)$/);
-    if (!match || match[2] !== "blob") return { kind: "missing" };
-    const size = Number(match[3]);
-    if (size > maxBytes) return { kind: "too-large", size };
-    const blob = await runtime.runGitBytes(["cat-file", "blob", match[1]], {
-      cwd,
-      maxOutputBytes: maxBytes,
-    });
-    if (blob.truncated) return { kind: "too-large", size };
-    if (blob.exitCode !== 0) return { kind: "missing" };
-    return { kind: "ok", bytes: blob.stdout, etag: `"${match[1]}"` };
+    return readGitObjectBytes(runtime, `${source.rev}:${source.path}`, maxBytes, cwd);
   }
 
   if (!runtime.readFileBytes || !runtime.realPath) return { kind: "unavailable" };

package/generated/review-skill-loader.ts

@@ -33,8 +33,8 @@ import {
   statSync,
   writeFileSync,
 } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
+import { homedir, tmpdir } from "node:os";
+import { join, sep } from "node:path";
 import { getPlannotatorDataDir } from "./data-dir.ts";
 import {
   BUILTIN_DEFAULT_PROFILE,
@@ -69,6 +69,26 @@ export interface DiscoveredSkill {
 // Root resolution
 // ---------------------------------------------------------------------------
 
+/**
+ * True when `dir` (already resolved) sits inside a temp folder. A test run
+ * (PLANNOTATOR_TEST_SANDBOX) reads only such folders, so a test that left HOME
+ * or CLAUDE_CONFIG_DIR alone never reads the person's real skills, while a test
+ * that seeds skills under a scratch home still finds them. Like
+ * `agentHomeAllowed` in inbox-agents.ts, which this file cannot import: it is
+ * vendored to Pi.
+ */
+function isScratchDir(dir: string): boolean {
+  return [tmpdir(), "/tmp", "/private/tmp"].some((root) => {
+    let base = root;
+    try {
+      base = realpathSync(root);
+    } catch {
+      // No such temp root here (/private/tmp off macOS); compare it as written.
+    }
+    return dir.startsWith(`${base.replace(/[\\/]+$/, "")}${sep}`);
+  });
+}
+
 /**
  * The ordered global skill roots, honoring env overrides. First-seen wins on a
  * cross-root name clash, so order matters: Claude → Codex → universal.
@@ -110,6 +130,7 @@ export function resolveGlobalSkillRoots(): Array<{ dir: string; root: SkillRoot
       // non-existent root still dedupes against an identical literal.
       key = candidate.dir;
     }
+    if (process.env.PLANNOTATOR_TEST_SANDBOX && !isScratchDir(key)) continue;
     if (seen.has(key)) continue;
     seen.add(key);
     roots.push(candidate);