pi-outpost 0.27.1 → 0.28.0

package/dist/contract/validate-structured-exchange.mjs

@@ -12370,7 +12370,7 @@ function rulePatterns(profile, rules, sources) {
 }
 
 // shared/bin/validate-structured-exchange.mjs
-var VERSION = `validate-structured-exchange ${false ? "development" : "0.27.1"}`;
+var VERSION = `validate-structured-exchange ${false ? "development" : "0.28.0"}`;
 var USAGE = `validate-structured-exchange [file]
 validate-structured-exchange --profile <profile.json> [file]
 validate-structured-exchange --check-profile <profile.json>

package/dist/pi-outpost.mjs

@@ -132364,6 +132364,12 @@ var WORST_LISTED = 8;
 function isStackExhaustion(message) {
   return /maximum call stack size exceeded|call stack size exceeded|stack overflow/i.test(message);
 }
+var PROVIDER_STACK_ENV = "PI_OUTPOST_PROVIDER_STACK";
+var PROVIDER_STACK_OFF = /* @__PURE__ */ new Set(["", "0", "false", "no", "off"]);
+function providerStackProbeArmed(env2 = process.env) {
+  return !PROVIDER_STACK_OFF.has((env2[PROVIDER_STACK_ENV] ?? "").trim().toLowerCase());
+}
+var PROVIDER_STACK_HINT = `[pi-outpost] no stack accompanies this \u2014 the provider's catch drops it. Set ${PROVIDER_STACK_ENV}=1 and the next occurrence will print one.`;
 function inspectShape(root) {
   let depth = 0;
   let cyclic = false;
@@ -132508,6 +132514,7 @@ function writeRecord(agentDir, report) {
     context?.cyclic?.length ? ` SELF-REFERENCE in ${context.cyclic.length} entr${context.cyclic.length === 1 ? "y" : "ies"}` : ""
   ].join("");
   console.error(headline);
+  if (!providerStackProbeArmed()) console.error(PROVIDER_STACK_HINT);
   const file = path23.join(agentDir, "turn-failures.jsonl");
   try {
     fs21.mkdirSync(agentDir, { recursive: true });
@@ -143476,7 +143483,7 @@ function cacheControlFor(url) {
 }
 
 // ../server/src/index.ts
-var VERSION2 = true ? "0.27.1" : "dev";
+var VERSION2 = true ? "0.28.0" : "dev";
 var PI_SDK_VERSION = true ? "0.86.1" : readInstalledPiSdkVersion();
 var LAUNCH_DIR = process.env.INIT_CWD ?? process.cwd();
 function complain(error) {
@@ -144212,8 +144219,8 @@ for (const root of config.openProjects) {
 }
 workspace.workPlan = await loadWorkPlan(workspace.agent.snapshot().sessionFile);
 workspace.workPlanSessionFile = workspace.agent.snapshot().sessionFile;
-publishWorkPlanTools(workspace, workspace.workPlan);
 withholdDocumentTools(workspace);
+publishWorkPlanTools(workspace, workspace.workPlan);
 function withholdDocumentTools(workspace2) {
   for (const tool of [...DOCUMENT_TOOLS, PROJECT_MODEL_TOOL]) workspace2.agent.setToolPublished(tool, false);
   workspace2.documentToolIdleTurns.clear();
@@ -144241,11 +144248,12 @@ function unpublishDocumentTools(workspace2, tools) {
   }
 }
 var DOCUMENT_TOOL_IDLE_LIMIT = { unused: 1, used: 5 };
+var WORK_PLAN_EXTENDED_IDLE_LIMIT = 5;
 function ageDocumentTools(workspace2) {
   const used = workspace2.documentToolsUsedThisTurn;
   for (const [tool, idle] of workspace2.documentToolIdleTurns) {
     if (used.has(tool)) continue;
-    const limit = workspace2.documentToolsEverUsed.has(tool) ? DOCUMENT_TOOL_IDLE_LIMIT.used : DOCUMENT_TOOL_IDLE_LIMIT.unused;
+    const limit = tool === WORK_PLAN_EXTENDED_TOOL ? WORK_PLAN_EXTENDED_IDLE_LIMIT : workspace2.documentToolsEverUsed.has(tool) ? DOCUMENT_TOOL_IDLE_LIMIT.used : DOCUMENT_TOOL_IDLE_LIMIT.unused;
     if (idle + 1 < limit) {
       workspace2.documentToolIdleTurns.set(tool, idle + 1);
       continue;
@@ -144256,7 +144264,10 @@ function ageDocumentTools(workspace2) {
   used.clear();
 }
 function publishWorkPlanTools(workspace2, plan) {
-  workspace2.agent.setToolPublished(WORK_PLAN_EXTENDED_TOOL, plan !== null);
+  const published = plan !== null;
+  if (!workspace2.agent.setToolPublished(WORK_PLAN_EXTENDED_TOOL, published)) return;
+  if (published) workspace2.documentToolIdleTurns.set(WORK_PLAN_EXTENDED_TOOL, 0);
+  else workspace2.documentToolIdleTurns.delete(WORK_PLAN_EXTENDED_TOOL);
 }
 function queueWorkPlanSessionSync(workspace2, after) {
   const sessionFile = workspace2.agent.snapshot().sessionFile;
@@ -144276,8 +144287,8 @@ function queueWorkPlanSessionSync(workspace2, after) {
     if (!sameSessionFile(workspace2.agent.snapshot().sessionFile, sessionFile)) return;
     workspace2.workPlan = plan;
     workspace2.workPlanSessionFile = sessionFile;
-    publishWorkPlanTools(workspace2, plan);
     withholdDocumentTools(workspace2);
+    publishWorkPlanTools(workspace2, plan);
     broadcast(workspace2, { type: "session_replaced", ...snapshot(workspace2) });
     if (inherited) broadcast(workspace2, { type: "work_plan_changed", workPlan: plan });
     announceWorkspaceActivity();
@@ -145251,8 +145262,8 @@ async function ensureStarted(target) {
     refreshExtensionRender(target);
     target.workPlan = await loadWorkPlan(runtime.snapshot().sessionFile);
     target.workPlanSessionFile = runtime.snapshot().sessionFile;
-    publishWorkPlanTools(target, target.workPlan);
     withholdDocumentTools(target);
+    publishWorkPlanTools(target, target.workPlan);
     target.lastUsedAt = Date.now();
     void refreshPiPackages(target);
   })();

package/dist/pi-outpost.sea.mjs

@@ -468768,6 +468768,12 @@ var WORST_LISTED = 8;
 function isStackExhaustion(message) {
   return /maximum call stack size exceeded|call stack size exceeded|stack overflow/i.test(message);
 }
+var PROVIDER_STACK_ENV = "PI_OUTPOST_PROVIDER_STACK";
+var PROVIDER_STACK_OFF = /* @__PURE__ */ new Set(["", "0", "false", "no", "off"]);
+function providerStackProbeArmed(env4 = process.env) {
+  return !PROVIDER_STACK_OFF.has((env4[PROVIDER_STACK_ENV] ?? "").trim().toLowerCase());
+}
+var PROVIDER_STACK_HINT = `[pi-outpost] no stack accompanies this \u2014 the provider's catch drops it. Set ${PROVIDER_STACK_ENV}=1 and the next occurrence will print one.`;
 function inspectShape(root) {
   let depth = 0;
   let cyclic = false;
@@ -468912,6 +468918,7 @@ function writeRecord(agentDir, report) {
     context?.cyclic?.length ? ` SELF-REFERENCE in ${context.cyclic.length} entr${context.cyclic.length === 1 ? "y" : "ies"}` : ""
   ].join("");
   console.error(headline);
+  if (!providerStackProbeArmed()) console.error(PROVIDER_STACK_HINT);
   const file = path41.join(agentDir, "turn-failures.jsonl");
   try {
     fs35.mkdirSync(agentDir, { recursive: true });
@@ -471379,7 +471386,7 @@ function cacheControlFor(url) {
 }
 
 // ../server/src/index.ts
-var VERSION4 = true ? "0.27.1" : "dev";
+var VERSION4 = true ? "0.28.0" : "dev";
 var PI_SDK_VERSION = true ? "0.86.1" : readInstalledPiSdkVersion();
 var LAUNCH_DIR = process.env.INIT_CWD ?? process.cwd();
 function complain(error) {
@@ -472115,8 +472122,8 @@ for (const root of config.openProjects) {
 }
 workspace.workPlan = await loadWorkPlan(workspace.agent.snapshot().sessionFile);
 workspace.workPlanSessionFile = workspace.agent.snapshot().sessionFile;
-publishWorkPlanTools(workspace, workspace.workPlan);
 withholdDocumentTools(workspace);
+publishWorkPlanTools(workspace, workspace.workPlan);
 function withholdDocumentTools(workspace2) {
   for (const tool of [...DOCUMENT_TOOLS, PROJECT_MODEL_TOOL]) workspace2.agent.setToolPublished(tool, false);
   workspace2.documentToolIdleTurns.clear();
@@ -472144,11 +472151,12 @@ function unpublishDocumentTools(workspace2, tools) {
   }
 }
 var DOCUMENT_TOOL_IDLE_LIMIT = { unused: 1, used: 5 };
+var WORK_PLAN_EXTENDED_IDLE_LIMIT = 5;
 function ageDocumentTools(workspace2) {
   const used = workspace2.documentToolsUsedThisTurn;
   for (const [tool, idle] of workspace2.documentToolIdleTurns) {
     if (used.has(tool)) continue;
-    const limit3 = workspace2.documentToolsEverUsed.has(tool) ? DOCUMENT_TOOL_IDLE_LIMIT.used : DOCUMENT_TOOL_IDLE_LIMIT.unused;
+    const limit3 = tool === WORK_PLAN_EXTENDED_TOOL ? WORK_PLAN_EXTENDED_IDLE_LIMIT : workspace2.documentToolsEverUsed.has(tool) ? DOCUMENT_TOOL_IDLE_LIMIT.used : DOCUMENT_TOOL_IDLE_LIMIT.unused;
     if (idle + 1 < limit3) {
       workspace2.documentToolIdleTurns.set(tool, idle + 1);
       continue;
@@ -472159,7 +472167,10 @@ function ageDocumentTools(workspace2) {
   used.clear();
 }
 function publishWorkPlanTools(workspace2, plan) {
-  workspace2.agent.setToolPublished(WORK_PLAN_EXTENDED_TOOL, plan !== null);
+  const published = plan !== null;
+  if (!workspace2.agent.setToolPublished(WORK_PLAN_EXTENDED_TOOL, published)) return;
+  if (published) workspace2.documentToolIdleTurns.set(WORK_PLAN_EXTENDED_TOOL, 0);
+  else workspace2.documentToolIdleTurns.delete(WORK_PLAN_EXTENDED_TOOL);
 }
 function queueWorkPlanSessionSync(workspace2, after) {
   const sessionFile = workspace2.agent.snapshot().sessionFile;
@@ -472179,8 +472190,8 @@ function queueWorkPlanSessionSync(workspace2, after) {
     if (!sameSessionFile(workspace2.agent.snapshot().sessionFile, sessionFile)) return;
     workspace2.workPlan = plan;
     workspace2.workPlanSessionFile = sessionFile;
-    publishWorkPlanTools(workspace2, plan);
     withholdDocumentTools(workspace2);
+    publishWorkPlanTools(workspace2, plan);
     broadcast(workspace2, { type: "session_replaced", ...snapshot(workspace2) });
     if (inherited) broadcast(workspace2, { type: "work_plan_changed", workPlan: plan });
     announceWorkspaceActivity();
@@ -473154,8 +473165,8 @@ async function ensureStarted(target) {
     refreshExtensionRender(target);
     target.workPlan = await loadWorkPlan(runtime.snapshot().sessionFile);
     target.workPlanSessionFile = runtime.snapshot().sessionFile;
-    publishWorkPlanTools(target, target.workPlan);
     withholdDocumentTools(target);
+    publishWorkPlanTools(target, target.workPlan);
     target.lastUsedAt = Date.now();
     void refreshPiPackages(target);
   })();

package/dist/providerStackHook.mjs

@@ -0,0 +1,61 @@
+/**
+ * Arm the provider stack probe, or do nothing at all.
+ *
+ * Passed with `--import`, because the whole module graph is loaded before any of
+ * pi-outpost's own code evaluates: a `register()` call from inside `index.ts` would run
+ * after the SDK was already parsed, and rewrite nothing. This is the only slot early
+ * enough, which is why it is a module of its own rather than a few lines somewhere.
+ *
+ * Inert unless `PI_OUTPOST_PROVIDER_STACK` is set to something meaning yes. Off, this
+ * file costs one environment read and returns; nothing is registered, no module is
+ * rewritten, and the process runs exactly as it did before. That is the point of the
+ * flag: a diagnostic nobody asked for should not be in the path of everybody's turns.
+ *
+ * On, it also raises `Error.stackTraceLimit`. V8's default of 10 frames is nothing on a
+ * recursion — the repeated frame is the answer, and ten of it says only that something
+ * repeated.
+ */
+import { register } from "node:module";
+import { MessageChannel } from "node:worker_threads";
+
+export const ENV_VAR = "PI_OUTPOST_PROVIDER_STACK";
+
+/** How many frames are worth keeping. A recursion shows its cycle long before this. */
+export const STACK_TRACE_LIMIT = 200;
+
+/** Whether the flag's value means yes. Unset, empty, `0`, `false` and `no` mean no. */
+export function isEnabled(value) {
+  if (typeof value !== "string") return false;
+  const normalized = value.trim().toLowerCase();
+  if (normalized.length === 0) return false;
+  return normalized !== "0" && normalized !== "false" && normalized !== "no" && normalized !== "off";
+}
+
+/**
+ * Registers the load hook and returns the port arming announcements arrive on.
+ *
+ * Exported so a test can drive it without a second process, and so the caller decides
+ * what to do with the announcements — this module only prints them.
+ */
+export function armProviderStackProbe(env = process.env) {
+  if (!isEnabled(env[ENV_VAR])) return undefined;
+  Error.stackTraceLimit = STACK_TRACE_LIMIT;
+  const { port1, port2 } = new MessageChannel();
+  port1.on("message", (url) => {
+    console.error(`[pi-outpost] provider stack probe armed on ${url}`);
+  });
+  // Nothing should wait on this port: an armed probe must not hold the event loop open.
+  port1.unref();
+  register("./providerStackRewrite.mjs", {
+    parentURL: import.meta.url,
+    data: port2,
+    transferList: [port2],
+  });
+  console.error(
+    `[pi-outpost] provider stack probe on (${ENV_VAR}). If no probe reports in by the first` +
+      " model call, the SDK's catch has moved and there was nothing to read.",
+  );
+  return port1;
+}
+
+armProviderStackProbe();

package/dist/providerStackRewrite.mjs

@@ -0,0 +1,62 @@
+/**
+ * The module-load hook that puts a provider's lost stack back on stderr.
+ *
+ * Every pi-ai provider's stream loop ends in the same catch:
+ *
+ *   catch (error) { output.errorMessage = formatProviderError(normalizeProviderError(error)); … }
+ *
+ * The message is kept and the `Error` is dropped, so by the time `assistant_end`
+ * crosses the runtime seam there is no `.stack` left anywhere in the process — which is
+ * the gap `turnFailureLog.ts` was written around, and why it records a census of the
+ * *input* rather than a trace. `normalizeProviderError` returns a flat
+ * `{ status, body, message, messageCarriesBody }`; it never carries the stack either.
+ * No extension hook reaches this: `after_provider_response` fires before the stream is
+ * consumed, and V8 offers no hook at an `Error`'s construction — `prepareStackTrace`
+ * runs on the first read of `.stack`, which never happens.
+ *
+ * So the stack is read here, at module load, before the catch can drop it. The source
+ * is rewritten **in memory**: nothing under `node_modules` is touched, `npm ci` has
+ * nothing to undo, and a machine running without the flag runs the bytes it installed.
+ *
+ * Matched on the catch's own line rather than on a filename, so it arms every provider
+ * that shares it — and arms none if a future SDK rewrites that line. That silence is
+ * reported rather than left to be discovered: each arming is announced through the
+ * port, and a run that announces nothing is a hook that found nothing.
+ *
+ * Hooks run off-thread, so `console.error` from here would not interleave with the
+ * server's own output; the port is how this side talks back. The injected probe itself
+ * runs in the module's own context on the main thread, where stderr is the real one.
+ */
+
+/** The assignment that drops the error, verbatim from every pi-ai provider. */
+const NEEDLE = "output.errorMessage = formatProviderError(normalizeProviderError(error));";
+
+/**
+ * Only stack exhaustion. Deliberately the same test as `isStackExhaustion` in
+ * `turnFailureLog.ts`: every other provider failure is already legible in the red
+ * bubble, and dumping 200 frames for a rate limit would bury the rare event in the
+ * common ones.
+ */
+const PROBE = [
+  "try { if (/maximum call stack size exceeded|call stack size exceeded|stack overflow/i.test(String(error && error.message)))",
+  ' console.error("[pi-outpost] provider stack:\\n" + ((error && error.stack) || String(error)));',
+  " } catch { }",
+].join("");
+
+/** Set by `initialize`, which `module.register` calls with the port it was given. */
+let port;
+
+export function initialize(data) {
+  port = data;
+}
+
+export async function load(url, context, nextLoad) {
+  const result = await nextLoad(url, context);
+  if (result.source === undefined || result.source === null) return result;
+  const source = result.source.toString();
+  if (!source.includes(NEEDLE)) return result;
+  port?.postMessage(url);
+  // Prepended, not replacing: the assignment still runs and the turn still fails the
+  // way it did. This hook observes, it does not change what the agent sees.
+  return { ...result, source: source.replaceAll(NEEDLE, `${PROBE} ${NEEDLE}`) };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-outpost",
-  "version": "0.27.1",
+  "version": "0.28.0",
   "type": "module",
   "description": "A web interface for the pi coding agent: a browser chat UI you run with npx — no clone, no build.",
   "license": "MIT",