@plannotator/pi-extension 0.28.45 → 0.28.47

package/generated/bridge-script.ts

@@ -61,6 +61,10 @@ body[data-plannotator-pinpoint-cursor],
 body[data-plannotator-pinpoint-cursor] * {
   cursor: crosshair !important;
 }
+/* Armed, body listens for clicks so a tap pins (setTapTarget): no grey flash over the whole page on each tap. */
+body[data-plannotator-pinpoint-cursor] {
+  -webkit-tap-highlight-color: transparent;
+}
 /* A plain click on a link with a real destination follows it while armed
  * (Cmd/Ctrl-click pins it), so such a link keeps the pointer that says so,
  * until the modifier is held. A link that goes nowhere (no href, "", "#",
@@ -509,14 +513,31 @@ export const BRIDGE_SCRIPT = `(function() {
   var annotateModeActive = true;
   // A native host decides link navigations itself (HtmlViewer hostNavigates).
   var hostNavigates = false;
+  // WebKit's touch model (iOS, and Playwright's WebKit on Linux) turns a tap
+  // into mouse events and a click only when the tapped element or an ancestor
+  // up to <body> listens for a click; listeners on document and window (all
+  // of the bridge's) do not count. Without this, a tap on plain text while
+  // armed sends no click and pins nothing. So while armed in pinpoint, body
+  // listens (a no-op), and its tap highlight is off: the pin draws its own box.
+  var tapTargetBody = null;
+  function noteTap() {}
+  function setTapTarget(on) {
+    var body = on ? document.body : null;
+    if (body === tapTargetBody) return;
+    if (tapTargetBody) tapTargetBody.removeEventListener('click', noteTap);
+    tapTargetBody = body;
+    if (body) body.addEventListener('click', noteTap);
+  }
   function updatePinpointCursor() {
     if (!document.body) return;
     if (annotateModeActive && currentInputMethod === 'pinpoint') {
       document.body.setAttribute('data-plannotator-pinpoint-cursor', '');
       if (!LIVE) document.body.setAttribute('data-plannotator-frame-inert', '');
+      setTapTarget(true);
     } else {
       document.body.removeAttribute('data-plannotator-pinpoint-cursor');
       document.body.removeAttribute('data-plannotator-frame-inert');
+      setTapTarget(false);
     }
   }
   var pinpointHover = null;
@@ -873,11 +894,21 @@ export const BRIDGE_SCRIPT = `(function() {
     else if (type === PREFIX + 'reveal-pin') {
       // A host whose own panel covers the page's lower part (a phone's comment
       // sheet) shrank the frame: bring the pinned draft back into view.
+      // clearBottom: the panel floats over the frame instead (the Inbox's card).
       if (pendingPinEl && pendingPinEl.isConnected) {
-        try { pendingPinEl.scrollIntoView({ behavior: 'smooth', block: 'center' }); } catch (ex) {}
+        var clearBottom = e.data.clearBottom;
+        if (typeof clearBottom === 'number' && isFinite(clearBottom) && clearBottom > 0) {
+          revealAbove(pendingPinEl, Math.min(clearBottom, window.innerHeight));
+        } else {
+          try { pendingPinEl.scrollIntoView({ behavior: 'smooth', block: 'center' }); } catch (ex) {}
+        }
       }
     }
 
+    else if (type === PREFIX + 'set-touch-selection') {
+      setTouchSelection(e.data.active === true);
+    }
+
     else if (type === PREFIX + 'scroll-to') {
       // Selecting an annotation scrolls its first resolved target into view
       // and flashes the overlay focus highlight over EVERY rect of EVERY
@@ -4125,6 +4156,67 @@ export const BRIDGE_SCRIPT = `(function() {
     return true;
   }
 
+  // The pinned element in the frame's top part, a host's panel over the last
+  // covered pixels: its middle in the middle of what shows, or its top when it
+  // is taller. Already in sight, nothing moves.
+  function revealAbove(el, covered) {
+    var shown = window.innerHeight - covered;
+    var box = el.getBoundingClientRect();
+    if (box.top >= 0 && box.bottom <= shown) return;
+    var by = box.height > shown ? box.top : box.top + box.height / 2 - shown / 2;
+    var root = document.scrollingElement;
+    for (var node = el.parentElement; node && by; node = node.parentElement) {
+      if (node !== root && !/auto|scroll/.test(getComputedStyle(node).overflowY)) continue;
+      var before = node.scrollTop;
+      node.scrollTop = before + by;
+      by -= node.scrollTop - before;
+    }
+  }
+
+  // --- Touch: a selection made with a finger ---
+  // A long press and its handles send no mouseup, so the capture-phase mouseup
+  // listener above never sees them. Where the host asks for it (HtmlViewer
+  // touchSelection) and the main pointer is a finger, the selection is read
+  // from selectionchange once it rests, as the Markdown viewer does. A collapsed
+  // selection is not taken: moving focus out of the frame can collapse it, and
+  // a tap on the page already closes the draft through mouseup. What the bridge
+  // reported already (a pin's own selection, a draft that did not change) is
+  // not reported again. The query and the wait are utils/touchSelection.ts's
+  // (this file is vendored whole and imports nothing; a test keeps them equal).
+  var touchSelectionOn = false;
+  var touchSelectionTimer = 0;
+  function isReportedRange(range) {
+    if (!pendingRange) return false;
+    try {
+      return pendingRange.compareBoundaryPoints(Range.START_TO_START, range) === 0
+        && pendingRange.compareBoundaryPoints(Range.END_TO_END, range) === 0;
+    } catch (ex) {
+      return false;
+    }
+  }
+  function takeTouchSelection() {
+    var sel = window.getSelection();
+    if (!sel || sel.isCollapsed || !sel.rangeCount) return;
+    if (isReportedRange(sel.getRangeAt(0))) return;
+    if (!(sel.toString() || '').trim()) return;
+    // New words chosen over a pin: the selection is the draft now.
+    clearMultiTargets();
+    clearPendingPin();
+    handleSelection();
+  }
+  function onTouchSelectionChange() {
+    clearTimeout(touchSelectionTimer);
+    touchSelectionTimer = setTimeout(takeTouchSelection, 400);
+  }
+  function setTouchSelection(active) {
+    var on = active && window.matchMedia('(pointer: coarse)').matches;
+    if (on === touchSelectionOn) return;
+    touchSelectionOn = on;
+    clearTimeout(touchSelectionTimer);
+    if (on) document.addEventListener('selectionchange', onTouchSelectionChange);
+    else document.removeEventListener('selectionchange', onTouchSelectionChange);
+  }
+
   // --- Touch: a tap on a link follows it, press-and-hold pins it ---
   // The owner's amendment to html-link-click (2026-10-20): on a phone there is
   // no Cmd/Ctrl, so while armed a TAP on a link follows it (the click handlers

package/generated/config.ts

@@ -397,6 +397,16 @@ export interface PlannotatorConfig {
    * `{ text_size }`.
    */
   inboxTextSize?: number;
+  /**
+   * How the Inbox list's rows look: the names of the row options that are on
+   * (core `INBOX_ROWS_OPTIONS`), every other one off. Unset: none written yet
+   * (a window adopts its browser's old cookies once). Written by the Inbox's ⋮
+   * menu and Settings → Rows through POST /api/inbox/settings `{ rows }`. A
+   * name this build does not know is dropped on read.
+   */
+  inboxRows?: string[];
+  /** How many times `inboxRows` was saved: windows take a look only when it is newer than the last they took. */
+  inboxRowsRev?: number;
   /**
    * The Inbox's onboarding tour, per machine (approval "inbox-onboarding-tour"):
    * when it was started, finished or skipped, and whether the first real thread
@@ -431,8 +441,8 @@ export interface PlannotatorConfig {
    * announcement (`POST /api/inbox/settings` `{ voice }`).
    */
   inboxVoice?: { on?: boolean; phonesOnly?: boolean; engine?: "codex" | "api" };
-  /** The voice announcement: the list intro's rule (`dueAt`, or `shownAt` on a fresh install), claimed with `POST /api/inbox/voice/intro`. */
-  inboxVoiceIntro?: { dueAt?: string; shownAt?: string };
+  /** The voice announcement: the list intro's rule (`dueAt`, or `shownAt` on a fresh install), claimed with `POST /api/inbox/voice/intro`. `skippedAt`: the check found no ChatGPT login, so it never asks again. */
+  inboxVoiceIntro?: { dueAt?: string; shownAt?: string; skippedAt?: string };
   /**
    * The Board (approval "inbox-board", 2026-10-26 amendment): something the
    * person turns on, off by default. On: the sidebar's Board row and page,

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.D8s5nXA_.js",
-  css: "viewer.CfyK-nt_.css",
-  jsIntegrity: "sha384-ttJm9w/o3SyLUMGneTh8OaaifLy3MT7HZB9/kBHqJ0+45DYhxzmOuWUBAYhNK3vm",
-  cssIntegrity: "sha384-Egde7gEF8IuWkM4XoUBzRwFHrsOZewlgRG9X1g2ZKsiL0y89Iy/NvYtlfPpadq8f",
+  js: "viewer.BfflE3Ru.js",
+  css: "viewer.b_pZ_mPX.css",
+  jsIntegrity: "sha384-1EH/kDTH8mGiMlSMNNZVhSX+/faRqfHb+0y/rlCoFbHG5hoxc3xf5njsncjsu95X",
+  cssIntegrity: "sha384-7tITytAS3P1UFEPudEv1zIuOiOvjfnyNmjJj+HGZZUqJUfCBi2PIIX5rNL5WlC9M",
   langs: {
     "astro": "chunks/astro.Ts5EKq2l.js",
     "c": "chunks/c.BIGW1oBm.js",

package/generated/inbox/connection.ts

@@ -316,7 +316,7 @@ export const INBOX_SESSION_THREADS_CHANNEL = "Their decisions stay in these thre
 
 /** When to use the Inbox. Fixed text: the agent tool's lead and the Inbox's server instructions carry it whole. */
 export const INBOX_USE_RULE =
-  "Use it for a decision only they can make (a :::question block; go on with other work), finished long work (a short summary, files in `attachments`), or when they ask."
+  "Use it for a decision only they can make (a :::question block; go on with other work), finished long work (a short summary with its pictures inline, files in `attachments`), or when they ask."
 
 /**
  * Separate work, separate threads (the owner, 2026-10-29: an agent given new
@@ -403,6 +403,20 @@ export const INBOX_AGENT_ACTION_LEADS: Readonly<Record<string, string>> = {
   card: "A Board card for work that outlasts this reply: create it, then move it and say where it is as the work moves.",
 }
 
+/**
+ * Pictures sit where they are discussed (the owner, 2026-11-02: agents sent
+ * a message's screenshots and the pictures of its options as attachments at
+ * the bottom, so the person had to scroll there to see what each option
+ * was). Fixed text: the agent tool's `body` field, the MCP server's `body`
+ * field and `plannotator inbox --help` carry it whole.
+ */
+export const INBOX_PICTURES_RULE =
+  'Pictures go in the body where you write about them, `![alt](/abs/path.png)`, never only in `attachments`; do not also attach one the body shows. Visual options are picture choices, one picture each: `- [ ] A · Label — ![alt](path) what it means`; the label comes back.'
+
+/** The `attachments` field's line on pictures (fixed text, on every copy of the field). */
+export const INBOX_ATTACHMENTS_PICTURES_LINE =
+  'Screenshots and pictures go in the body instead (`![alt](path)`); attach what the person should open or click through.'
+
 /**
  * The agent tool's own words for the fields whose Inbox description is long
  * (the MCP server's are written for a raw MCP client, which has no other
@@ -432,7 +446,9 @@ export const INBOX_AGENT_FIELD_DESCRIPTIONS: Readonly<Record<string, Readonly<Re
       '',
       'Your recommendation goes on the `Recommended:` line, never in a choice label. Keep the choices in their natural order; never move yours first. `:::question-multi` takes several choices, `:::question-text` free text. The person can always answer Other, add a note or skip, so never add an Other choice yourself. `Stopped: <why>` only when you cannot go on until it is answered (never `Stopped: no`); `Holds up: <work>` names work that waits while you go on. Ask only what you cannot decide alone, about 8 a round at most. Answers come back in the reply under "Answers to your questions".',
       '',
-      'Optional lines after the question; most questions need none of these: `Stakes: <what it affects>` (give one with every Stopped or Holds up), `Shows: ![alt](path)` or `Shows: [name](file)` (the one picture or file it is about), `Why: <why your recommendation>` on its own line, `Reversible: no — <why>` only when it cannot be undone. Visual options can be picture choices, `- [ ] Label — ![alt](path)`: the picture picks it, the label comes back.',
+      INBOX_PICTURES_RULE,
+      '',
+      'Optional lines after the question; most questions need none of these: `Stakes: <what it affects>` (give one with every Stopped or Holds up), `Shows: ![alt](path)` or `Shows: [name](file)` (the one picture or file it is about), `Why: <why your recommendation>` on its own line, `Reversible: no — <why>` only when it cannot be undone.',
       '',
       'Only for a true blocker the person must go and do outside this chat, that you cannot do yourself (approve a deploy, sign in, touch a security key, merge a PR you cannot merge), write a `:::action` block: first line the order, then why. Each command the person must run goes in the why in its own fenced code block (```), one block per command in the order to run them, so each gets a copy button. Optional: `Where: <url>`, `Stopped:`, `Watching: <what you watch>`. Never for a decision or a question, for what you can do yourself, or as a checklist or status update; most messages need none. Done or Can\'t do it comes back under "Action items you asked for".',
       '',
@@ -444,7 +460,7 @@ export const INBOX_AGENT_FIELD_DESCRIPTIONS: Readonly<Record<string, Readonly<Re
     thread: "A short thread name, one line, to keep separate work apart: the same name in this project is the same open thread, across sessions. Without it, your messages join your session's open thread. Ignored with reply_to, except when you are asked to name a thread the person started: then it names that thread, once.",
     supersedes: 'Your own questions in this thread that are still open (read_thread state open or picked) and no longer apply: a newer message replaces them, or the reply settled them in words. "<message id>/<key>" for one, "<message id>" for all of that message\'s; send with reply_to into their thread. With one question in this message it replaces them, otherwise they read "No longer applies".',
     done: 'Your own open action items (`:::action`) in this thread that you saw done yourself, e.g. the deploy you watch is Ready: "<message id>/<key>" (key a-…); send with reply_to into their thread. The card says you saw it done; nothing is sent to the person.',
-    attachments: 'Files to show the person beside the message, absolute or relative to project_path: a plan, a screenshot, an HTML mock, code, a video, any file. For something visual, a screenshot or image usually reads fastest; attach the HTML or source too when they should open or click through it. Link one from the body (`[the mock](mock.html)`) to open it beside the thread. Their comments on the files come back in the reply. Folders and .env files are refused.',
+    attachments: `Files to show the person beside the message, absolute or relative to project_path: a plan, an HTML mock, code, a video, any file. ${INBOX_ATTACHMENTS_PICTURES_LINE} Link one from the body (\`[the mock](mock.html)\`) to open it beside the thread. Their comments on the files come back in the reply. Folders and .env files are refused.`,
   },
   read_thread: {
     thread_id: 'A thread id. read_thread shows its open questions, the newest messages in full, and earlier ones one line each.',

package/inbox.ts

@@ -186,6 +186,23 @@ function userText(message: { content?: unknown } | undefined): string {
 		.join("");
 }
 
+/**
+ * PLANNOTATOR_SESSION_PROJECT (apps/hook/server/inbox-mcp-shim.ts,
+ * `inboxSessionProjectFromEnv`): `pi:<session id>:<ctx.cwd>`, the folder this
+ * session's `plannotator_inbox` tool files under. Pi gives each bash call this
+ * process's environment plus PI_SESSION_ID, so a `cd sub && plannotator inbox
+ * call …` or `plannotator card …` lands in the tool's project too. Set before
+ * every bash call, so a new or resumed session's id is the one named. A stale
+ * ctx names nothing new.
+ */
+export function exportPiSessionProject(env: Record<string, string | undefined>, ctx: Pick<ExtensionContext, "cwd" | "sessionManager">): void {
+	try {
+		env.PLANNOTATOR_SESSION_PROJECT = `${PI_INBOX_HOST}:${ctx.sessionManager.getSessionId()}:${ctx.cwd}`;
+	} catch {
+		// A stale ctx: the last value stands, and it names its own session.
+	}
+}
+
 function registerPiInbox(pi: InboxPi, connection: InboxAgentConnection, options: PiInboxOptions & { reminder: string | null }): void {
 	const spec = inboxAgentTool(connection.tools);
 	const ohMyPi = detectPiHost(pi) === "oh-my-pi";
@@ -324,6 +341,11 @@ function registerPiInbox(pi: InboxPi, connection: InboxAgentConnection, options:
 		},
 	};
 
+	// Before each bash call: the session's project for the commands it runs (exportPiSessionProject).
+	pi.on("tool_call", (event: { toolName?: unknown } | undefined, callCtx: ExtensionContext) => {
+		if (event?.toolName === "bash") exportPiSessionProject(process.env, callCtx);
+	});
+
 	pi.on("session_start", (_event, startCtx: ExtensionContext) => {
 		ctx = startCtx;
 		if (!activationSettled) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plannotator/pi-extension",
-  "version": "0.28.45",
+  "version": "0.28.47",
   "type": "module",
   "description": "Plannotator Pi extension - interactive plan review with annotations, annotate agent messages, and review code/PRs",
   "author": "backnotprop",