crewx-pi-kit 0.1.12 → 0.1.14

package/README.md

@@ -10,7 +10,7 @@ work, safety boundaries, and agent handoffs.
 Install it with Pi:
 
 ```sh
-pi install npm:crewx-pi-kit@0.1.12
+pi install npm:crewx-pi-kit@0.1.13
 ```
 
 CrewX injects short-lived `CREWX_URL` and `CREWX_TOKEN` capabilities only while

package/extensions/crewx-tools.ts

@@ -151,8 +151,7 @@ function wait(milliseconds: number, signal?: AbortSignal): Promise<void> {
 export default function crewxTools(pi: ExtensionAPI) {
   const protectedValues = new Set<string>();
   const deliveredSecretRequests = new Set<string>();
-  const computerReleases = new Map<string, () => void>();
-  let computerTail = Promise.resolve();
+  const computerCalls = new Set<string>();
   let computerLease: string | undefined;
   let computerTimer: ReturnType<typeof setTimeout> | undefined;
   let computerOperations = Promise.resolve();
@@ -179,8 +178,8 @@ export default function crewxTools(pi: ExtensionAPI) {
     if (computerTimer) clearTimeout(computerTimer);
     computerTimer = setTimeout(async () => {
       if (!computerLease || computerClosed) return;
-      try { await updateComputer(computerReleases.size > 0); renewComputer(); }
-      catch { computerLease = undefined; if (computerReleases.size > 0) abortComputerAction?.(); }
+      try { await updateComputer(computerCalls.size > 0); renewComputer(); }
+      catch { computerLease = undefined; if (computerCalls.size > 0) abortComputerAction?.(); }
     }, 20_000);
     computerTimer.unref();
   };
@@ -188,8 +187,7 @@ export default function crewxTools(pi: ExtensionAPI) {
     computerClosed = true;
     if (computerTimer) clearTimeout(computerTimer);
     if (computerLease) await updateComputer(false, true).catch(() => {});
-    for (const release of computerReleases.values()) release();
-    computerReleases.clear();
+    computerCalls.clear();
   };
   pi.on('agent_start', () => { computerClosed = false; });
   pi.on('agent_end', closeComputer);
@@ -226,26 +224,30 @@ export default function crewxTools(pi: ExtensionAPI) {
     }
 
     if (!isComputerTool(event.toolName, event.input)) return;
-    const previous = computerTail;
-    let release!: () => void;
-    computerTail = new Promise<void>((resolve) => { release = resolve; });
-    await previous;
+    // Pi prepares every parallel call before executing any of them. Waiting
+    // here for an earlier result deadlocks the whole batch. Admit one computer
+    // action and return a retryable tool error for the others instead.
+    if (computerCalls.size > 0) {
+      return { block: true, terminate: false, reason: 'Another computer action is already prepared in this batch. Wait for its result, then retry this action in the next turn. Computer actions must be sequential.' };
+    }
+    computerCalls.add(event.toolCallId);
     try { await updateComputer(true); }
     catch (error) {
-      computerLease = undefined; release();
+      computerLease = undefined; computerCalls.delete(event.toolCallId);
       return { block: true, terminate: false, reason: error instanceof Error ? error.message : 'Computer ownership is unavailable. No browser action was performed.' };
     }
     abortComputerAction = () => ctx.abort();
-    computerReleases.set(event.toolCallId, release);
     renewComputer();
   });
-  pi.on("tool_result", async (event) => {
-    const release = computerReleases.get(event.toolCallId);
-    if (release) {
-      computerReleases.delete(event.toolCallId);
+  const finishComputerCall = async (toolCallId: string) => {
+    if (computerCalls.delete(toolCallId)) {
       if (computerLease) await updateComputer(false).catch(() => { computerLease = undefined; });
-      release();
     }
+  };
+  // Also covers a later extension blocking a call after our preflight passed.
+  pi.on('tool_execution_end', async (event) => { await finishComputerCall(event.toolCallId); });
+  pi.on("tool_result", async (event) => {
+    await finishComputerCall(event.toolCallId);
     return {
       content: event.content.map((item) =>
         item.type === "text" ? { ...item, text: scrub(item.text) } : item,

package/extensions/session-context.ts

@@ -0,0 +1,36 @@
+import type { ContextEvent, ExtensionAPI } from '@earendil-works/pi-coding-agent';
+
+const SNAPSHOT = '\n\n## Workspace snapshot\n\n```json\n';
+
+function isEnvelope(text: string): boolean {
+  return text.startsWith('# CrewX assignment\n') &&
+    text.includes('\n# Operating context\n') &&
+    text.includes(SNAPSHOT) && text.endsWith('\n```');
+}
+
+/** Model-facing projection only: never rewrite Pi's persisted session ledger. */
+export function latestWorkspaceSnapshot(messages: ContextEvent['messages']): ContextEvent['messages'] {
+  let latest = -1;
+  for (let index = 0; index < messages.length; index++) {
+    const message = messages[index];
+    if (message.role !== 'user') continue;
+    const texts = typeof message.content === 'string'
+      ? [message.content] : message.content.filter(item => item.type === 'text').map(item => item.text);
+    if (texts.some(isEnvelope)) latest = index;
+  }
+  if (latest < 0) return messages;
+  const trim = (text: string): string => isEnvelope(text)
+    ? text.slice(0, text.lastIndexOf(SNAPSHOT)) +
+      '\n\n[Historical CrewX workspace snapshot omitted. Use the latest assignment snapshot; the original task and tool history are retained.]'
+    : text;
+  return messages.map((message, index) => {
+    if (index >= latest || message.role !== 'user') return message;
+    return { ...message, content: typeof message.content === 'string'
+      ? trim(message.content)
+      : message.content.map(item => item.type === 'text' ? { ...item, text: trim(item.text) } : item) };
+  });
+}
+
+export default function sessionContext(pi: ExtensionAPI): void {
+  pi.on('context', event => ({ messages: latestWorkspaceSnapshot(event.messages) }));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "crewx-pi-kit",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "description": "Typed CrewX tools and operating skills for managed Pi agents.",
   "type": "module",
   "files": [