@plannotator/pi-extension 0.28.37 → 0.28.39

package/generated/call-flow.ts

@@ -3,11 +3,13 @@
  * Isolated CallDiff execution over immutable review snapshots.
  *
  * CallDiff is a Node-native, synchronous Tree-sitter library. Plannotator runs
- * it in a short-lived Node 22 worker and never imports it into Bun or Pi.
+ * it in a short-lived Node worker (22.18 or newer) and never imports it into
+ * Bun or Pi.
  */
 import { childEnv } from "./child-env.ts";
 import { createHash } from "node:crypto";
 import { chmodSync, cpSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import type { Dirent } from "node:fs";
 import { mkdtemp } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { basename, dirname, isAbsolute, join } from "node:path";
@@ -34,11 +36,14 @@ import type {
   ParsedCallDiffWorkerResult,
 } from "./call-flow-types.ts";
 
-export const CALLDIFF_VERSION = "0.4.1";
-export const CALLDIFF_COMMIT = "a3194d20ca91ef6a314273d634e9b9c0db1c2707";
+export const CALLDIFF_VERSION = "0.6.0";
+export const CALLDIFF_COMMIT = "2086f6e4e9ed3c410bba7c94ca3dde77791b1956";
 export const CALLDIFF_SOURCE_SPEC = `https://github.com/tanishqkancharla/calldiff/archive/${CALLDIFF_COMMIT}.tar.gz`;
-export const CALLDIFF_SOURCE_INTEGRITY = "sha512-5y6tjre5UE00qPrVFPurnk9RBdk8WlRok+0w41lxLt1MyPLOlNUEaAT2/j/nz2xWlhDm3DfDYvW/5KBD2b9TLg==";
+export const CALLDIFF_SOURCE_INTEGRITY = "sha512-t+YCPz0WkETiwSOznwx3mLxVkEUe7DVACV+it2HJER7q/ha+K0IavN9IfBvP+7/ijzPXoUHgJIkAM/kg1O5S6A==";
 export const CALLDIFF_TREE_SITTER_VERSION = "0.25.1";
+/** CallDiff's own `engines.node` floor at the pinned commit (>=22.18.0). */
+export const CALL_FLOW_MIN_NODE_VERSION = { major: 22, minor: 18 } as const;
+const CALL_FLOW_NODE_REQUIREMENT = "Node.js 22.18 or newer";
 const CALLDIFF_ARCHIVE_FILE = `calldiff-${CALLDIFF_COMMIT}.tar.gz`;
 const MAX_CALLDIFF_ARCHIVE_BYTES = 20 * 1024 * 1024;
 const MAX_PACK_ARCHIVES_BYTES = 256 * 1024 * 1024;
@@ -248,11 +253,23 @@ function hasCommittedRuntimeLock(runtimeDir: string): boolean {
   }
 }
 
-async function checkNode22(nodePath: string): Promise<{ ok: true } | { ok: false; message: string }> {
+/** True when a `node --version` string meets CallDiff's 22.18 floor. */
+export function callFlowNodeVersionSupported(version: string): boolean {
+  const match = /^v?(\d+)\.(\d+)/.exec(version.trim());
+  if (!match) return false;
+  const major = Number(match[1]);
+  const minor = Number(match[2]);
+  const floor = CALL_FLOW_MIN_NODE_VERSION;
+  return major > floor.major || (major === floor.major && minor >= floor.minor);
+}
+
+async function checkCallFlowNode(nodePath: string): Promise<{ ok: true } | { ok: false; message: string }> {
   const result = await runCommand(nodePath, ["--version"], { timeoutMs: 3_000 });
-  const match = /^v(\d+)/.exec(result.stdout.trim());
-  if (result.exitCode !== 0 || !match) return { ok: false, message: "Node.js could not be started." };
-  if (Number(match[1]) < 22) return { ok: false, message: `Node.js 22 or newer is required (found ${result.stdout.trim()}).` };
+  const found = result.stdout.trim();
+  if (result.exitCode !== 0 || !/^v\d+\.\d+/.test(found)) return { ok: false, message: "Node.js could not be started." };
+  if (!callFlowNodeVersionSupported(found)) {
+    return { ok: false, message: `Call flow needs ${CALL_FLOW_NODE_REQUIREMENT}. You have Node.js ${found}.` };
+  }
   return { ok: true };
 }
 
@@ -279,8 +296,8 @@ function findExecutable(name: string): string | null {
  */
 export async function preflightCallFlowNode(): Promise<CallFlowNodePreflight> {
   const nodePath = findExecutable("node");
-  if (!nodePath) return { ok: false, reason: "node-unavailable", message: "Call flow requires Node.js 22 or newer, which was not found on PATH." };
-  const nodeCheck = await checkNode22(nodePath);
+  if (!nodePath) return { ok: false, reason: "node-unavailable", message: `Call flow needs ${CALL_FLOW_NODE_REQUIREMENT}, which was not found on PATH.` };
+  const nodeCheck = await checkCallFlowNode(nodePath);
   if (!nodeCheck.ok) return { ok: false, reason: "node-version", message: nodeCheck.message };
   return { ok: true };
 }
@@ -288,8 +305,8 @@ export async function preflightCallFlowNode(): Promise<CallFlowNodePreflight> {
 /** Resolve the pruned core and report independently installed language packs. */
 export async function resolveCallFlowRuntime(): Promise<CallFlowRuntimeResolution> {
   const nodePath = findExecutable("node");
-  if (!nodePath) return { ok: false, reason: "node-unavailable", message: "Call flow requires Node.js 22 or newer." };
-  const nodeCheck = await checkNode22(nodePath);
+  if (!nodePath) return { ok: false, reason: "node-unavailable", message: `Call flow needs ${CALL_FLOW_NODE_REQUIREMENT}, which was not found on PATH.` };
+  const nodeCheck = await checkCallFlowNode(nodePath);
   if (!nodeCheck.ok) return { ok: false, reason: "node-version", message: nodeCheck.message };
 
   const override = process.env.PLANNOTATOR_CALLDIFF_PATH?.trim();
@@ -686,29 +703,125 @@ function ensureGrammarCacheManifest(cacheDir: string): void {
   }), "utf8");
 }
 
-async function preserveValidatedLanguagePacks(
+/**
+ * Copy optional packs into a candidate core. Sources are tried in order (the
+ * current runtime first, then folders left by older pins); a pack crosses only
+ * when its exact committed lock marker matches and it loads through the
+ * candidate core. Packs are pinned independently of CallDiff, so an upgrade
+ * keeps the user's installed languages instead of downloading them again.
+ */
+export async function preserveValidatedLanguagePacks(
   nodePath: string,
-  currentRuntimeDir: string,
+  sourceRuntimeDirs: readonly string[],
   candidateRuntimeDir: string,
-): Promise<void> {
+): Promise<CallFlowLanguageId[]> {
   const candidateCache = getCallFlowGrammarCacheDir(candidateRuntimeDir);
   ensureGrammarCacheManifest(candidateCache);
+  const preserved: CallFlowLanguageId[] = [];
   for (const language of CALL_FLOW_LANGUAGES) {
-    if (language.kind !== "pack" || !isLanguageInstalled(currentRuntimeDir, language, true)) continue;
+    if (language.kind !== "pack") continue;
     const packId = language.id as Exclude<CallFlowLanguageId, "javascript-typescript">;
-    const currentRoot = getLanguagePackageRoot(currentRuntimeDir, language);
     const candidateRoot = getLanguagePackageRoot(candidateRuntimeDir, language);
-    mkdirSync(dirname(candidateRoot), { recursive: true });
-    cpSync(currentRoot, candidateRoot, { recursive: true, force: true });
+    for (const sourceRuntimeDir of sourceRuntimeDirs) {
+      if (!isLanguageInstalled(sourceRuntimeDir, language, true)) continue;
+      mkdirSync(dirname(candidateRoot), { recursive: true });
+      cpSync(getLanguagePackageRoot(sourceRuntimeDir, language), candidateRoot, { recursive: true, force: true });
+      try {
+        await validatePrunedLanguage(nodePath, candidateRuntimeDir, candidateCache, [language.id]);
+        const marker = getLanguageLockMarker(candidateRuntimeDir, language.id);
+        mkdirSync(dirname(marker), { recursive: true });
+        writeFileSync(marker, runtimeJson(CALL_FLOW_PACK_LOCKS[packId]), "utf8");
+        preserved.push(language.id);
+        break;
+      } catch {
+        // A pack whose files no longer load is not independently verified and
+        // must not cross the atomic core repair boundary.
+        removeDirectoryStrict(candidateRoot);
+      }
+    }
+  }
+  return preserved;
+}
+
+/**
+ * Folder names Plannotator itself creates for a managed core: the published
+ * `calldiff-<version>` and the `.previous-<pid>-<ms>` backup a core swap
+ * leaves when it is interrupted. Nothing else in vendor/call-flow matches.
+ */
+const MANAGED_CORE_DIR_PATTERN = /^calldiff-(\d+)\.(\d+)\.(\d+)(\.previous-\d+-\d+)?$/;
+
+function compareVersionTriples(a: readonly number[], b: readonly number[]): number {
+  for (let index = 0; index < 3; index += 1) {
+    if (a[index] !== b[index]) return a[index] - b[index];
+  }
+  return 0;
+}
+
+/**
+ * Managed core folders under this data dir that no current or newer
+ * Plannotator uses: cores of an older CallDiff pin, and interrupted-swap
+ * backups of an older or the current pin. A newer pin's folder and backups
+ * are kept, so downgrading and upgrading again finds it still installed.
+ */
+export function listStaleCallFlowRuntimeDirs(dataDir = getPlannotatorDataDir()): string[] {
+  const currentDir = getCallFlowManagedRuntimeDir(dataDir);
+  const parent = dirname(currentDir);
+  const current = CALLDIFF_VERSION.split(".").map(Number);
+  let entries: Dirent[];
+  try {
+    entries = readdirSync(parent, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const stale: string[] = [];
+  for (const entry of entries) {
+    // Dirent types come from lstat: a symlink is never followed or removed.
+    if (!entry.isDirectory()) continue;
+    const match = MANAGED_CORE_DIR_PATTERN.exec(entry.name);
+    if (!match) continue;
+    const isBackup = match[4] !== undefined;
+    const version = [Number(match[1]), Number(match[2]), Number(match[3])];
+    const order = compareVersionTriples(version, current);
+    if (order < 0 || (isBackup && order === 0)) stale.push(join(parent, entry.name));
+  }
+  return stale.sort();
+}
+
+/**
+ * A stale core is renamed to this dot-prefixed name before it is deleted. No
+ * Plannotator version resolves a dot-prefixed folder, so a delete cut short
+ * (a killed process, a busy file on Windows) never leaves a half-deleted
+ * `calldiff-<x.y.z>` that an older Plannotator would take as installed.
+ */
+const STALE_TOMBSTONE_PATTERN = /^\.calldiff-stale-\d+-\d+-\d+$/;
+
+/**
+ * Remove stale managed cores once the current pin is published. Runs only
+ * under the install lease and only after a successful install, so a failed
+ * upgrade keeps the previous folder for a downgrade. Each folder is first
+ * renamed to a tombstone (atomic); one that cannot be renamed (in use on
+ * Windows) stays whole and is retried by the next install. Tombstones,
+ * including any an earlier interrupted delete left, are then removed.
+ */
+export function removeStaleCallFlowRuntimeDirs(dataDir = getPlannotatorDataDir()): void {
+  const parent = dirname(getCallFlowManagedRuntimeDir(dataDir));
+  const stamp = `${process.pid}-${Date.now()}`;
+  listStaleCallFlowRuntimeDirs(dataDir).forEach((path, index) => {
     try {
-      await validatePrunedLanguage(nodePath, candidateRuntimeDir, candidateCache, [language.id]);
-      const marker = getLanguageLockMarker(candidateRuntimeDir, language.id);
-      mkdirSync(dirname(marker), { recursive: true });
-      writeFileSync(marker, runtimeJson(CALL_FLOW_PACK_LOCKS[packId]), "utf8");
+      renameSync(path, join(parent, `.calldiff-stale-${stamp}-${index}`));
     } catch {
-      // A pack whose files no longer load is not independently verified and
-      // must not cross the atomic core repair boundary.
-      removeDirectoryStrict(candidateRoot);
+      // Left whole under its own name; the next install tries again.
+    }
+  });
+  let entries: Dirent[];
+  try {
+    entries = readdirSync(parent, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.isDirectory() && STALE_TOMBSTONE_PATTERN.test(entry.name)) {
+      removeDirectoryBestEffort(join(parent, entry.name));
     }
   }
 }
@@ -734,13 +847,14 @@ async function installCallFlowRuntimeUnlocked(
   const nodePath = findExecutable("node");
   const npmPath = findExecutable("npm");
   if (!nodePath || !npmPath) {
-    return { ok: false, status: "failed", runtimeDir, message: "Call-flow runtime requires Node.js 22+ and npm." };
+    return { ok: false, status: "failed", runtimeDir, message: `Call flow needs ${CALL_FLOW_NODE_REQUIREMENT} and npm on PATH.` };
   }
-  const nodeCheck = await checkNode22(nodePath);
+  const nodeCheck = await checkCallFlowNode(nodePath);
   if (!nodeCheck.ok) return { ok: false, status: "failed", runtimeDir, message: nodeCheck.message };
 
   const existing = await resolveCallFlowRuntime();
   if (existing.ok && existing.runtime.runtimeDir === runtimeDir) {
+    removeStaleCallFlowRuntimeDirs();
     return { ok: true, status: "already-installed", runtimeDir, languageId: CALL_FLOW_CORE_LANGUAGE_ID, message: `Call-flow core already installed at ${runtimeDir}.` };
   }
   const runtimeParent = dirname(runtimeDir);
@@ -803,10 +917,11 @@ async function installCallFlowRuntimeUnlocked(
     await validatePrunedLanguage(nodePath, installDir, getCallFlowGrammarCacheDir(installDir), [CALL_FLOW_CORE_LANGUAGE_ID]);
     const sizeAfterPruneBytes = measureCallFlowDirectoryBytes(installDir);
 
-    // A core repair preserves only packs whose exact marker, package version,
-    // and native payload all still validate against the candidate core.
+    // A core repair or upgrade preserves only packs whose exact marker,
+    // package version, and native payload all still validate against the
+    // candidate core. An upgrade takes them from the older pin's folder.
     const nextCache = getCallFlowGrammarCacheDir(installDir);
-    await preserveValidatedLanguagePacks(nodePath, runtimeDir, installDir);
+    await preserveValidatedLanguagePacks(nodePath, [runtimeDir, ...listStaleCallFlowRuntimeDirs()], installDir);
     ensureGrammarCacheManifest(nextCache);
 
     if (existsSync(runtimeDir)) renameSync(runtimeDir, backupDir);
@@ -817,6 +932,8 @@ async function installCallFlowRuntimeUnlocked(
       throw error;
     }
     removeDirectoryBestEffort(backupDir);
+    // Only now that the new pin is published do older pins' folders go.
+    removeStaleCallFlowRuntimeDirs();
     return { ok: true, status: "installed", runtimeDir, languageId: CALL_FLOW_CORE_LANGUAGE_ID, sizeBeforePruneBytes, sizeAfterPruneBytes, message: `Installed the pruned CallDiff ${CALLDIFF_VERSION} core at ${runtimeDir}.` };
   } catch (error) {
     return {
@@ -861,7 +978,7 @@ async function installCallFlowLanguagePackUnlocked(
   const nodePath = findExecutable("node");
   const npmPath = findExecutable("npm");
   if (!nodePath || !npmPath) {
-    return { ok: false, status: "failed", runtimeDir, message: "Call-flow language packs require Node.js 22+ and npm." };
+    return { ok: false, status: "failed", runtimeDir, message: `Call flow language support needs ${CALL_FLOW_NODE_REQUIREMENT} and npm on PATH.` };
   }
   const runtime = await resolveCallFlowRuntime();
   if (!runtime.ok || !runtime.runtime.managed || runtime.runtime.runtimeDir !== runtimeDir) {

package/generated/child-env.ts

@@ -37,6 +37,18 @@ export function childEnv(extra?: Readonly<ChildEnv>): ChildEnv {
   return env;
 }
 
+/**
+ * Whether this process runs inside an agent Plannotator's Ask AI started:
+ * `PLANNOTATOR_ASK_AI_CHILD` is exactly "1" (set by `askAiChildEnv` in
+ * packages/ai/providers/ask-ai-env.ts). There, Plannotator's own integration
+ * stands down: the Inbox MCP shim lists no tools, the plan-review hook exits
+ * 0, and the OpenCode plugin registers nothing. Any other value, or none, is
+ * a person's session and changes nothing.
+ */
+export function isAskAiChild(env: Readonly<ChildEnv> = process.env): boolean {
+  return env.PLANNOTATOR_ASK_AI_CHILD === "1";
+}
+
 /**
  * The live PATH, for `Bun.which(command, { PATH: childPath() })`: without the
  * option Bun.which searches the startup PATH.

package/generated/claude-review.ts

@@ -329,6 +329,9 @@ export const CLAUDE_JOB_DISALLOWED_TOOLS: readonly string[] = [
   "Bash(git grep *)", "Bash(git ls-remote *)", "Bash(gh api *)", "Bash(glab api *)",
   // jj: config injection (global flags, accepted anywhere) and external tools.
   "Bash(jj --config*)", "Bash(jj * --config*)", "Bash(jj * --tool*)",
+  // Plannotator's Inbox MCP server, by name, as Ask AI does (claude-agent-sdk.ts).
+  // `--strict-mcp-config` already loads no MCP server; this holds whatever the transport.
+  "mcp__plannotator-inbox",
 ];
 
 /** `--tools` / `--allowedTools` / `--disallowedTools` for a Claude agent job. */

package/generated/codex-review.ts

@@ -17,6 +17,7 @@ import {
   type ResolvedReviewProfile,
 } from "./review-profiles.ts";
 import { classifyFindingPlacement } from "./external-annotation.ts";
+import { codexAskAiConfigArgs, readCodexConfigTexts } from "./ai/providers/ask-ai-env.ts";
 
 // ---------------------------------------------------------------------------
 // Debug log — only active when PLANNOTATOR_DEBUG is set
@@ -217,6 +218,8 @@ export async function buildCodexCommand(options: CodexCommandOptions): Promise<s
     ...(model ? ["-m", model] : []),
     ...(reasoningEffort ? ["-c", `model_reasoning_effort=${reasoningEffort}`] : []),
     ...(fastMode ? ["-c", "service_tier=fast"] : []),
+    // The Inbox MCP server off: Codex hands a stdio MCP server none of the job's env.
+    ...codexAskAiConfigArgs(readCodexConfigTexts(cwd)),
     "exec",
     "--output-schema", schemaPath,
     "-o", outputPath,

package/generated/guide-review.ts

@@ -3,6 +3,7 @@ import { dirname, join } from "node:path";
 import { tmpdir } from "node:os";
 import { mkdir, writeFile, readFile, unlink } from "node:fs/promises";
 import { getPlannotatorDataDir } from "./data-dir.ts";
+import { codexAskAiConfigArgs, readCodexConfigTexts } from "./ai/providers/ask-ai-env.ts";
 import { loadConfig, resolveClaudeSandbox, resolveCursorSandbox } from "./config.ts";
 import { claudeJobIsolationArgs, claudeJobToolArgs, findClaudeStructuredOutput, type ClaudeJobCommandOptions } from "./claude-review.ts";
 import {
@@ -156,6 +157,8 @@ export async function buildGuideCodexCommand(options: {
     ...(model ? ["-m", model] : []),
     ...(reasoningEffort ? ["-c", `model_reasoning_effort=${reasoningEffort}`] : []),
     ...(fastMode ? ["-c", "service_tier=fast"] : []),
+    // The Inbox MCP server off: Codex hands a stdio MCP server none of the job's env.
+    ...codexAskAiConfigArgs(readCodexConfigTexts(cwd)),
     "exec",
     "--output-schema", schemaPath,
     "-o", outputPath,

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.SgPt8W-S.js",
-  css: "viewer.DejL7_DK.css",
-  jsIntegrity: "sha384-P3KhhgeAgJGa3CTHbXg0ZuIN5F703EFwTG7ont4K08zzCQtJS6EP55W2uRIsdItJ",
-  cssIntegrity: "sha384-RC1v6OjikD4krGxtTP5dn1SNTtuT4wQWdRSS5HSVrmAdJk97gNs5wbKca+3/0Hdl",
+  js: "viewer.CdCl9A4y.js",
+  css: "viewer.DwkeqVw0.css",
+  jsIntegrity: "sha384-2X50K3TjsKUyCt69GjPLTwRrZcYV0LS4+5Nv93J3b8gE1sFjbXaviLKYZJTZb3HS",
+  cssIntegrity: "sha384-xdeDB20PiSkAJ7ueRdgFndT6bub5IF/tjxEaq7rwDqCBe1U2gH2B7GHtIr5R59/F",
   langs: {
     "astro": "chunks/astro.Ts5EKq2l.js",
     "c": "chunks/c.BIGW1oBm.js",

package/generated/inbox/connection.ts

@@ -66,15 +66,17 @@ export type InboxFilledArguments = Record<(typeof INBOX_FILLED_ARGUMENTS)[number
 
 /**
  * The one filled argument an agent may set itself: the repository or folder
- * a call is about, when it is not the session's working folder (a session
- * started in a notes subfolder). Optional in the agent's schema; absent, the
- * working folder is filled as before. The connection resolves a relative path
- * against the working folder and refuses a path that is not an existing
- * folder before anything reaches the Inbox.
+ * a call is about, when it is not the folder the session started in (a
+ * message about another repository). Optional in the agent's schema; absent,
+ * the connection fills the session's folder (the Claude Code mod: where the
+ * session started, which a shell `cd` never moves). The connection resolves a
+ * relative path against the current working folder and refuses a path that
+ * is not an existing folder before anything reaches the Inbox.
  */
 export const INBOX_AGENT_PROJECT_PATH = 'project_path'
 
-export const INBOX_AGENT_PROJECT_PATH_DESCRIPTION = 'The repository or folder this is about; defaults to your working folder.'
+export const INBOX_AGENT_PROJECT_PATH_DESCRIPTION =
+  'The repository or folder this is about; defaults to the folder your session started in. Pass it only when the message is about another repository or folder.'
 
 /** Why an agent's `project_path` is refused before any folder is looked at, or null when its shape passes. */
 export function inboxProjectPathShapeRefusal(value: unknown): string | null {
@@ -94,9 +96,33 @@ export function inboxProjectPathShapeRefusal(value: unknown): string | null {
  */
 export const INBOX_WAKES_META_KEY = 'ai.plannotator/inbox-wakes'
 
-/** The `tools/call` params for an Inbox tool call: `wakes` when this session's replies arrive as turns. */
-export function inboxToolCallParams(call: { name: string; arguments: Record<string, unknown> }, options: { wakes: boolean }): Record<string, unknown> {
-  return { name: call.name, arguments: call.arguments, ...(options.wakes ? { _meta: { [INBOX_WAKES_META_KEY]: true } } : {}) }
+/**
+ * The `_meta` key a connection sets on a send (`send_message`,
+ * `submit_guide`) to the absolute folder the agent works in now, when that is
+ * not the `project_path` it filled: the Claude Code mod files a session's
+ * messages under the folder it started in, while a shell `cd` moves the
+ * agent. Relative `attachments`, and the body's relative images and links
+ * (the message's `base_path`), then resolve there, where they resolved before
+ * the project stopped following the `cd`. Never sent with a `project_path`
+ * the agent named (its relative paths stay relative to it). An older Inbox
+ * ignores it; the mod also makes relative attachments absolute itself.
+ */
+export const INBOX_WORKING_FOLDER_META_KEY = 'ai.plannotator/working-folder'
+
+/**
+ * The `tools/call` params for an Inbox tool call: `wakes` when this session's
+ * replies arrive as turns, `workingFolder` (INBOX_WORKING_FOLDER_META_KEY)
+ * when the agent works outside the filled `project_path`.
+ */
+export function inboxToolCallParams(
+  call: { name: string; arguments: Record<string, unknown> },
+  options: { wakes: boolean; workingFolder?: string },
+): Record<string, unknown> {
+  const meta: Record<string, unknown> = {
+    ...(options.wakes ? { [INBOX_WAKES_META_KEY]: true } : {}),
+    ...(options.workingFolder ? { [INBOX_WORKING_FOLDER_META_KEY]: options.workingFolder } : {}),
+  }
+  return { name: call.name, arguments: call.arguments, ...(Object.keys(meta).length > 0 ? { _meta: meta } : {}) }
 }
 
 /**
@@ -284,6 +310,17 @@ export const INBOX_SESSION_THREADS_CHANNEL = "Their decisions stay in these thre
 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."
 
+/**
+ * Separate work, separate threads (the owner, 2026-10-29: an agent given new
+ * work in its chat kept posting into an old thread on a related subject). The
+ * owner's sentence, word for word, without more instruction around it: the
+ * `thread` field says how. Fixed text, one wording everywhere: the agent
+ * tool's lead and the Inbox's server instructions (INBOX_AGENT_RULES), the
+ * reminder, the note, `plannotator inbox --help`, the skill and every
+ * `/plannotator-inbox` briefing (tests/inbox-guidance-parity.test.ts).
+ */
+export const INBOX_THREAD_RULE = "One thread per work stream, unless the person says otherwise."
+
 /**
  * Follow through, without pinging (the owner, 2026-10-27: an agent promised
  * the person pictures "coming" and left them unsent for an hour, held
@@ -306,11 +343,16 @@ export const INBOX_SUBAGENT_RULE = "If another agent started you, report to it i
  * the agent tool's lead and the Inbox's server instructions carry it whole,
  * so the two can never word them differently.
  */
-export const INBOX_AGENT_RULES = `${INBOX_USE_RULE} ${INBOX_CHANNEL_RULE} ${INBOX_FOLLOW_THROUGH_RULE} ${INBOX_SUBAGENT_RULE}`
+export const INBOX_AGENT_RULES = `${INBOX_USE_RULE} ${INBOX_THREAD_RULE} ${INBOX_CHANNEL_RULE} ${INBOX_FOLLOW_THROUGH_RULE} ${INBOX_SUBAGENT_RULE}`
 
-/** What the agent tool says, before the per-action lines. Fixed text. */
+/**
+ * What the agent tool says, before the per-action lines. Fixed text. Room for
+ * INBOX_THREAD_RULE under Claude Code's 2,048 characters came from this first
+ * sentence's ", without blocking this session", restored in shorter form as
+ * "nothing blocks" by shortening the help line, and from get_guide_brief's lead.
+ */
 export const INBOX_TOOL_LEAD =
-  `The Plannotator Inbox on this machine: message the person and get their answer later, without blocking this session. ${INBOX_AGENT_RULES} Set \`action\` to a tool below, with its fields.`
+  `The Plannotator Inbox on this machine: message the person, get their answer later; nothing blocks. ${INBOX_AGENT_RULES} Set \`action\` to a tool below, with its fields.`
 
 /**
  * Fixed text: how a reply comes back. The connection delivers the person's
@@ -327,7 +369,7 @@ export const INBOX_TOOL_WAKE_NOTE =
  * examples), so an agent that needs more reads it once instead of every
  * request carrying it.
  */
-export const INBOX_TOOL_HELP_NOTE = "Every field and the full question syntax: `plannotator inbox --help`."
+export const INBOX_TOOL_HELP_NOTE = "Every field and question syntax: `plannotator inbox --help`."
 
 /**
  * Fixed text, one line: the agent tool's description carries it while the
@@ -350,7 +392,7 @@ export const INBOX_AGENT_ACTION_LEADS: Readonly<Record<string, string>> = {
   // What a read shows lives on `thread_id` (a field description does not count toward the 2,048).
   read_thread: 'Read a thread (thread_id); with no id, list your threads (asked_by "anyone": all).',
   search: 'Find messages by words, older ones too (read-only).',
-  get_guide_brief: "How to write a guided review: method, JSON shape, rules, a worked submit_guide call.",
+  get_guide_brief: "How to write a guided review, with a worked submit_guide call.",
   card: "A Board card for work that outlasts this reply: create it, then move it and say where it is as the work moves.",
 }
 
@@ -415,14 +457,14 @@ export const INBOX_AGENT_FIELD_DESCRIPTIONS: Readonly<Record<string, Readonly<Re
  * the send, before anything about the chat, so it reads as about the Inbox.
  */
 export const INBOX_REMINDER_TEXT =
-  `Plannotator Inbox is on: when you finish long work, or need a decision only the person can make, send it with plannotator_inbox send_message and keep going. ${INBOX_FOLLOW_THROUGH_RULE} Their reply comes back here. A decision in the Inbox stays there: when the person writes here, say what waits and link its thread, but never also ask it in the chat with a blocking question tool (AskUserQuestion or similar). Run \`plannotator inbox --help\` for how it works.`
+  `Plannotator Inbox is on: when you finish long work, or need a decision only the person can make, send it with plannotator_inbox send_message and keep going. ${INBOX_FOLLOW_THROUGH_RULE} ${INBOX_THREAD_RULE} Their reply comes back here. A decision in the Inbox stays there: when the person writes here, say what waits and link its thread, but never also ask it in the chat with a blocking question tool (AskUserQuestion or similar). Run \`plannotator inbox --help\` for how it works.`
 
 /**
  * The same line for a host without the wake (OpenCode 1): the reply does not
  * come back by itself there, so it names wait_for_reply instead.
  */
 export const INBOX_REMINDER_TEXT_NO_WAKE =
-  `Plannotator Inbox is on: when you finish long work, or need a decision only the person can make, send it with plannotator_inbox send_message and keep going. ${INBOX_FOLLOW_THROUGH_RULE} Call wait_for_reply when you need their answer. A decision in the Inbox stays there: when the person writes here, say what waits and link its thread, but never also ask it in the chat with a blocking question tool (AskUserQuestion or similar). Run \`plannotator inbox --help\` for how it works.`
+  `Plannotator Inbox is on: when you finish long work, or need a decision only the person can make, send it with plannotator_inbox send_message and keep going. ${INBOX_FOLLOW_THROUGH_RULE} ${INBOX_THREAD_RULE} Call wait_for_reply when you need their answer. A decision in the Inbox stays there: when the person writes here, say what waits and link its thread, but never also ask it in the chat with a blocking question tool (AskUserQuestion or similar). Run \`plannotator inbox --help\` for how it works.`
 
 /**
  * The reminder naming the tool as the host registered it. Claude Code defers
@@ -463,6 +505,7 @@ export const INBOX_COMMAND_BRIEFING = [
   'The person opened their Plannotator Inbox with /plannotator-inbox and has its address. The Plannotator Inbox is one window on this computer where you leave the person messages, `:::question` blocks they answer with a click, and files. They answer when they can. Nothing blocks: you send, then keep working or end your turn.',
   '',
   `- ${INBOX_USE_RULE}`,
+  `- ${INBOX_THREAD_RULE}`,
   '- Send with a `plannotator_inbox` tool when you have one (it can be listed with a prefix and may need loading through tool search first): `action` `send_message`, with a markdown `body`. Otherwise call `send_message` on the Inbox\'s MCP server, `plannotator inbox mcp`.',
   "- send_message's result says whether the person's reply arrives in this session by itself. When it does, do not wait or poll for it: end your turn or go on with other work. When it does not, call wait_for_reply when you need the answer.",
   `- ${INBOX_CHANNEL_RULE}`,

package/generated/project.ts

@@ -22,8 +22,9 @@ export function sanitizeTag(name: string): string | null {
     .replace(/[\s_]+/g, "-")      // spaces/underscores -> hyphens
     .replace(/[^a-z0-9-]/g, "")   // remove special chars
     .replace(/-+/g, "-")          // collapse multiple hyphens
-    .replace(/^-|-$/g, "")        // trim leading/trailing hyphens
-    .slice(0, 30);                // max 30 chars
+    .replace(/^-/, "")            // trim leading hyphen
+    .slice(0, 30)                 // max 30 chars
+    .replace(/-$/, "");           // trim trailing hyphen, after the cut so the result is idempotent
 
   return sanitized.length >= 2 ? sanitized : null;
 }

package/generated/question-block.ts

@@ -1890,8 +1890,8 @@ Recommended: Local only, purged after 30 days
   - Add a screenshot (\`![alt](path)\`) for anything visual.
   - Link a file that shows it better (a plan, a mock): \`[the mock](mock.html)\`. In the Inbox, attach it too; the link opens it beside the thread.
 - Choices: \`- [ ] label\`, optionally \`- [ ] label — why\`. The reviewer can also answer "Other", add a note, or skip.
-- \`Recommended: <label>\` marks yours (\`A, B and C\` on \`:::question-multi\`); other text shows as one more answer, tagged Recommended.
-- Ask only what you cannot decide alone, about 8 a round at most. Do not ask rhetorical questions or questions the codebase answers.
+- \`Recommended: <label>\` marks yours (\`A, B and C\` on \`:::question-multi\`); other text is one more answer, tagged Recommended. Keep A, B, C order.
+- Ask only what you cannot decide alone, about 8 a round. Do not ask rhetorical questions or questions the codebase answers.
 - \`- [x]\` marks a settled choice. On resubmit, check the chosen answer, or drop the block and state the decision in prose.
 - Leave blank lines between the parts so the block reads well on GitHub.
 - Each answer comes back under its question (\`### Q2. <question> (line N)\`) as \`Answer: <choice>\`, marked \`(your recommendation)\` when the reviewer took yours, or as \`Other: …\`, free text in a quote, or \`Skipped\`, plus any \`Note:\`. A question you marked \`- [x]\` is settled and only comes back if the reviewer changed it or added a note.

package/generated/tour-review.ts

@@ -3,6 +3,7 @@ import { dirname, join } from "node:path";
 import { tmpdir } from "node:os";
 import { mkdir, writeFile, readFile, unlink } from "node:fs/promises";
 import { getPlannotatorDataDir } from "./data-dir.ts";
+import { codexAskAiConfigArgs, readCodexConfigTexts } from "./ai/providers/ask-ai-env.ts";
 import type { DiffType } from "./review-core.ts";
 import { getPRPlatformCapabilities, type PRMetadata } from "./pr-provider.ts";
 import { buildWorkspacePromptContextLines, getLocalDiffInstruction, type WorkspaceReviewPromptContext } from "./agent-review-message.ts";
@@ -449,6 +450,8 @@ export async function buildTourCodexCommand(options: {
     ...(model ? ["-m", model] : []),
     ...(reasoningEffort ? ["-c", `model_reasoning_effort=${reasoningEffort}`] : []),
     ...(fastMode ? ["-c", "service_tier=fast"] : []),
+    // The Inbox MCP server off: Codex hands a stdio MCP server none of the job's env.
+    ...codexAskAiConfigArgs(readCodexConfigTexts(cwd)),
     "exec",
     "--output-schema", schemaPath,
     "-o", outputPath,