@awebai/oats-pi 0.35.3 → 0.35.5

package/README.md

@@ -10,6 +10,14 @@ from the same release tag). This bridge registers no operational tools. It only:
   acquisition funnel);
 - contributes the instance-local `.agents/skills` set inside a spawned
   instance;
+- holds an instance's opening task (`@TASK.md`) on pi's own path until no
+  turn another extension started is active, so pi runs it exactly once,
+  as its input processing made it, instead of refusing it. It never sends,
+  re-sends or alters a message. The exception: an extension loaded behind
+  the bridge that starts a turn (or awaits I/O while one starts) inside its
+  own input or before_agent_start handling of the opening prompt can still
+  make pi refuse it, because pi's interactive mode sends the initial
+  message with no streamingBehavior. @awebai/pi has no such handler;
 - journals compaction summaries and sends resume nudges when the active
   knowledge capability created `STATE.md`/`log.md`. Knowledge ownership,
   read/capture instructions, judgment and delivery remain capability-owned.

package/extension/index.ts

@@ -6,7 +6,7 @@
  * pre-workspace oats-getting-started bootstrap outside one, and drives the
  * memory session events. Ambient skills coexist with the OATS-composed set.
  */
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { appendLogEntry, PACKAGED_SKILLS_DIR } from "./core-loader.mjs";
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
@@ -25,6 +25,8 @@ export default function (pi: ExtensionAPI) {
   });
 
   if (isInstance) {
+    holdOpeningTask(pi);
+
     pi.on("session_compact", async (event) => {
       if (!existsSync(join(agentHome!, "STATE.md"))) return;
       try {
@@ -57,3 +59,58 @@ export default function (pi: ExtensionAPI) {
     });
   }
 }
+
+/**
+ * The opening task runs once, after any turn another extension starts, as
+ * pi's input processing made it. pi sends the launch's `@TASK.md` as the
+ * session's first prompt with no streamingBehavior (pi 0.85.1
+ * modes/interactive/interactive-mode.js:816) and refuses it while another
+ * extension's run (the @awebai/pi welcome) is active. The bridge never sends
+ * or alters a message: it holds that prompt on pi's own path, in its input
+ * handler and again in before_agent_start (a run can start during the
+ * prompt's preflight), until no run is active. A run that an extension behind
+ * the bridge starts (or that starts while one awaits) in its own input or
+ * before_agent_start handling of the prompt can still make pi refuse it, and
+ * pi says nothing an extension could act on. Every later prompt is left to pi.
+ */
+function holdOpeningTask(pi: ExtensionAPI) {
+  let taken = false;
+  // The opening prompt has yet to reach before_agent_start.
+  let awaitingStart = false;
+  const waiters: (() => void)[] = [];
+  // pi refuses a prompt while pi-agent-core holds a run (ctx.signal is that
+  // run's), and one with no streamingBehavior while the session is not idle.
+  const busy = (ctx: ExtensionContext) => ctx.signal !== undefined || !ctx.isIdle();
+  const untilFree = async (ctx: ExtensionContext) => {
+    while (busy(ctx)) await new Promise<void>((resolve) => waiters.push(resolve));
+  };
+  const wake = () => { for (const resume of waiters.splice(0)) resume(); };
+  // Waiters re-check on agent_settled (pi 0.80.4 and later). A pi without it
+  // releases a run only once every agent_end listener has finished, which no
+  // event marks: from agent_end, waiters re-check every 25 ms until none is
+  // left waiting or another run starts.
+  let recheck: ReturnType<typeof setTimeout> | undefined;
+  const stopRechecking = () => { clearTimeout(recheck); recheck = undefined; };
+  const recheckWaiters = () => {
+    recheck = undefined;
+    if (!waiters.length) return;
+    wake();
+    recheck = setTimeout(recheckWaiters, 25);
+  };
+
+  pi.on("input", async (event, ctx) => {
+    if (taken || event.source !== "interactive" || event.streamingBehavior !== undefined) return { action: "continue" };
+    taken = true;
+    awaitingStart = true;
+    await untilFree(ctx);
+    return { action: "continue" };
+  });
+  pi.on("before_agent_start", async (_event, ctx) => {
+    if (!awaitingStart) return;
+    awaitingStart = false;
+    await untilFree(ctx);
+  });
+  pi.on("agent_start", stopRechecking);
+  pi.on("agent_end", () => { stopRechecking(); recheck = setTimeout(recheckWaiters, 0); });
+  pi.on("agent_settled", () => { stopRechecking(); wake(); });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awebai/oats-pi",
-  "version": "0.35.3",
+  "version": "0.35.5",
   "description": "OATS pi runtime bridge — memory session events and pre-workspace bootstrap over the runtime-neutral @awebai/oats kernel",
   "keywords": [
     "pi-package",