@arbiterforge/ca-pi 0.15.7 → 0.15.10

package/README.md

@@ -10,7 +10,7 @@ project context. You decide. codeArbiter enforces.
 <img alt="Claude Code plugin" src="https://img.shields.io/badge/Claude_Code-plugin-d97757">
 <img alt="Codex plugin" src="https://img.shields.io/badge/OpenAI_Codex-plugin-10a37f">
 <img alt="Pi Feature Forge preview" src="https://img.shields.io/badge/ca--pi-Feature_Forge_preview-d97757">
-<img alt="version 2.23.0" src="https://img.shields.io/badge/version-2.23.0-2b7489">
+<img alt="version 2.23.2" src="https://img.shields.io/badge/version-2.23.2-2b7489">
 <img alt="core lanes" src="https://img.shields.io/badge/core_lanes-18-555">
 <img alt="skills" src="https://img.shields.io/badge/skills-22-555">
 <img alt="agents" src="https://img.shields.io/badge/agents-20-555">
@@ -183,7 +183,7 @@ Replace `<version>` with the numeric suffix from the chosen tag while retaining
 it is a partial install that cannot author typed HTML specs and plans; use the npm channel for
 that.
 
-Pi 0.84.1 is the supported host for this release line. Generated aliases use `/ca-*`;
+Pi 1.0.0 is the supported host for this release line. Generated aliases use `/ca-*`;
 `/skill:ca-*` is the host-native fallback. Every `ca-pi-v*` tag is also published to npm as
 `npm:@arbiterforge/ca-pi` with provenance (ADR-0029); the pinned Git tag remains the reproducible
 install. The [Pi runbook](./docs/pi-parity-testing.md) covers isolated install, trust, verification,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arbiterforge/ca-pi",
-  "version": "0.15.7",
+  "version": "0.15.10",
   "license": "AGPL-3.0-only",
   "repository": {
     "type": "git",

package/plugins/ca-pi/CHANGELOG.md

@@ -4,6 +4,38 @@ All notable changes to `ca-pi` are documented in this file.
 
 ## [Unreleased]
 
+## [0.15.10] - 2026-10-03
+
+### Changed
+
+- Promote the verified Pi host window through exact Pi 1.0.0. Pi 1.0.0 closes the
+  undici advisories present in 0.84.1; the brace-expansion advisories it still pins
+  were already present in 0.84.1 and are recorded as accepted under ADR-0041.
+
+### Fixed
+
+- Child dispatch no longer degrades on Pi 1.0.0: the runner accepts the 1.0.0 JSON
+  wire (`message_update` usage, named `toolcall_start`, `deferred` completion).
+- `/ca-doctor` validates the Pi 1.0.0 CLI at its declared `dist/bundle/cli.js` bin.
+
+## [0.15.9] - 2026-10-03
+
+### Fixed
+
+- Named verification now supports a root npm script delegating once to a uniquely
+  selected workspace runner. The declared root command remains intact, both npm
+  argument boundaries are honored, and every inspected manifest is retained in
+  launch provenance. Unsupported or ambiguous delegation fails before execution.
+
+## [0.15.8] - 2026-09-27
+
+### Fixed
+
+- The statusline's git dirty-state probe no longer takes `.git/index.lock`. It is killed at a
+  100 ms budget, and a plain `git status` killed while rewriting a stale index could leave a
+  stale lock that blocked the next commit (reproduced: 5 of 200 renders at that timing, 0 of 200
+  with the fix).
+
 ## [0.15.7] - 2026-09-27
 
 ### Changed

package/plugins/ca-pi/extensions/codearbiter-child.js

@@ -629,7 +629,7 @@ function resolvePythonCommand(platform = process.platform, probe = systemPythonP
 }
 
 // src/compatibility.ts
-var SUPPORTED_PI_VERSIONS = /* @__PURE__ */ new Set(["0.84.1"]);
+var SUPPORTED_PI_VERSIONS = /* @__PURE__ */ new Set(["1.0.0"]);
 var MINIMUM_NODE = [22, 19, 0];
 var SEMVER_PREFIX = /^(\d+)\.(\d+)\.(\d+)(?:$|[-+])/u;
 function atLeast(version, minimum) {
@@ -644,7 +644,7 @@ function atLeast(version, minimum) {
 }
 function compatibilityDirection(input) {
   if (!SUPPORTED_PI_VERSIONS.has(input.piVersion)) {
-    return "codeArbiter requires Pi 0.84.1; install a supported Pi version and run /ca-doctor.";
+    return "codeArbiter requires Pi 1.0.0; install a supported Pi version and run /ca-doctor.";
   }
   if (!atLeast(input.nodeVersion, MINIMUM_NODE)) {
     return "codeArbiter requires Node >=22.19.0 for Pi; upgrade Node and run /ca-doctor.";

package/plugins/ca-pi/extensions/codearbiter.js

@@ -2,7 +2,7 @@
 var define_CODEARBITER_PI_PERMISSION_POLICY_SURFACES_default = { "ca-plan": "planning-write", codearbiter_background_bash: "background-launch" };
 
 // <define:__CODEARBITER_PI_SKILL_EXPANSION_FINGERPRINTS__>
-var define_CODEARBITER_PI_SKILL_EXPANSION_FINGERPRINTS_default = { "0.84.1": "12632f365440b07d5183cff871d889b796a3c711b6b49df20f95d9bc198d6c51" };
+var define_CODEARBITER_PI_SKILL_EXPANSION_FINGERPRINTS_default = { "1.0.0": "12632f365440b07d5183cff871d889b796a3c711b6b49df20f95d9bc198d6c51" };
 
 // <define:__CODEARBITER_PI_TOOL_CLASSES__>
 var define_CODEARBITER_PI_TOOL_CLASSES_default = { bash: "EXEC", codearbiter_background_bash: "EXEC", codearbiter_dispatch: "EXEC", codearbiter_farm_preview: "EXEC", write: "WRITE", edit: "EDIT", read: "READ" };
@@ -16,7 +16,7 @@ import { fileURLToPath as fileURLToPath5, pathToFileURL as pathToFileURL2 } from
 import { types as utilTypes9 } from "node:util";
 
 // src/compatibility.ts
-var SUPPORTED_PI_VERSIONS = /* @__PURE__ */ new Set(["0.84.1"]);
+var SUPPORTED_PI_VERSIONS = /* @__PURE__ */ new Set(["1.0.0"]);
 var MINIMUM_NODE = [22, 19, 0];
 var SEMVER_PREFIX = /^(\d+)\.(\d+)\.(\d+)(?:$|[-+])/u;
 function atLeast(version, minimum) {
@@ -31,7 +31,7 @@ function atLeast(version, minimum) {
 }
 function compatibilityDirection(input) {
   if (!SUPPORTED_PI_VERSIONS.has(input.piVersion)) {
-    return "codeArbiter requires Pi 0.84.1; install a supported Pi version and run /ca-doctor.";
+    return "codeArbiter requires Pi 1.0.0; install a supported Pi version and run /ca-doctor.";
   }
   if (!atLeast(input.nodeVersion, MINIMUM_NODE)) {
     return "codeArbiter requires Node >=22.19.0 for Pi; upgrade Node and run /ca-doctor.";
@@ -6881,10 +6881,10 @@ async function collectPiDoctorInput(dependencies) {
 var REMEDIATION = {
   package: "Reinstall ca-pi from the approved pinned Git tag, then restart Pi.",
   trust: "Run /trust in Pi, inspect the project, grant trust only if you accept it, then start a new session.",
-  version: "Upgrade Pi to 0.84.1 and Node to >=22.19.0, then restart Pi.",
+  version: "Upgrade Pi to 1.0.0 and Node to >=22.19.0, then restart Pi.",
   python: "Upgrade or install Python 3, then run /ca-doctor again.",
   core: "Reinstall ca-pi to restore the generated shared core, then run /ca-doctor again.",
-  commands: "Remove conflicting command owners or run Pi 0.84.1, then restart Pi and run /ca-doctor.",
+  commands: "Remove conflicting command owners or run Pi 1.0.0, then restart Pi and run /ca-doctor.",
   bridge: "Reinstall ca-pi and Python 3, then run /ca-doctor again.",
   child: "Reinstall ca-pi if the hardened child artifact is missing or tampered, then run /ca-doctor again.",
   "ambient-marker": "Remove CODEARBITER_SUBAGENT from the parent environment and restart Pi.",
@@ -6913,7 +6913,7 @@ function diagnosePi(input) {
   const packageHealthy = input.package.declared && input.package.name === "@arbiterforge/ca-pi" && existsSync(input.package.root) && existsSync(input.package.extensionPath) && samePath2(input.package.extensionPath, expectedExtension) && canonicallyInside(input.package.extensionPath, input.package.root);
   const trustHealthy = input.trust.inspected && (!input.trust.required || input.trust.projectTrusted);
   const waitingForTrust = input.trust.required && !input.trust.projectTrusted;
-  const versionHealthy = input.runtime.piVersion === "0.84.1" && atLeast(input.runtime.nodeVersion, [22, 19, 0]);
+  const versionHealthy = input.runtime.piVersion === "1.0.0" && atLeast(input.runtime.nodeVersion, [22, 19, 0]);
   const piBelowMinimum = !atLeast(input.runtime.piVersion, [0, 80, 5]);
   const supportedExpansion = input.commands.expansionVerifiedVersions.includes(input.runtime.piVersion);
   const expectedDoctorSkill = resolve9(input.package.root, "skills", "ca-doctor", "SKILL.md");
@@ -6924,7 +6924,7 @@ function diagnosePi(input) {
     resolve9(input.package.root, "extensions", "codearbiter-child.js")
   ) && canonicallyInside(input.child.path, input.package.root) && existsSync(input.child.path);
   const coreHealthy = input.core.present && existsSync(input.core.bridgeScript) && samePath2(input.core.bridgeScript, resolve9(input.package.root, "hooks", "pi-bridge.py")) && canonicallyInside(input.core.bridgeScript, input.package.root);
-  const runtimeIdentityHealthy = existsSync(input.runtime.cliEntry) && existsSync(input.runtime.moduleEntry) && canonicallyInside(input.runtime.cliEntry, input.runtime.packageRoot) && canonicallyInside(input.runtime.moduleEntry, input.runtime.packageRoot) && samePath2(input.runtime.cliEntry, resolve9(input.runtime.packageRoot, "dist", "cli.js")) && samePath2(input.runtime.moduleEntry, resolve9(input.runtime.packageRoot, "dist", "index.js"));
+  const runtimeIdentityHealthy = existsSync(input.runtime.cliEntry) && existsSync(input.runtime.moduleEntry) && canonicallyInside(input.runtime.cliEntry, input.runtime.packageRoot) && canonicallyInside(input.runtime.moduleEntry, input.runtime.packageRoot) && samePath2(input.runtime.cliEntry, resolve9(input.runtime.packageRoot, "dist", "bundle", "cli.js")) && samePath2(input.runtime.moduleEntry, resolve9(input.runtime.packageRoot, "dist", "index.js"));
   const mutators = ["bash", "write", "edit"];
   const wrapperHealthy = input.finalArguments.wrapperSourcePath !== void 0 && existsSync(input.finalArguments.wrapperSourcePath) && samePath2(input.finalArguments.wrapperSourcePath, expectedExtension) && mutators.every((name) => input.finalArguments.activeTools?.includes(name) === true) && mutators.every((name) => {
     const path = input.finalArguments.toolSources?.[name];
@@ -7034,7 +7034,7 @@ function diagnosePi(input) {
     {
       id: "active-dispatch",
       state: "degraded",
-      message: "Supported Pi 0.84.1 public extension APIs cannot submit this deterministic self-test through the active dispatcher; the wrapper self-test does not exercise active dispatch.",
+      message: "Supported Pi 1.0.0 public extension APIs cannot submit this deterministic self-test through the active dispatcher; the wrapper self-test does not exercise active dispatch.",
       remediation: REMEDIATION["active-dispatch"]
     }
   ];
@@ -8296,17 +8296,17 @@ function validContentBlock(value, kind) {
     case "text":
       return exactKeys4(value, ["type", "text", "textSignature"], ["type", "text"]) && boundedString2(value.text) && (value.textSignature === void 0 || boundedString2(value.textSignature));
     case "image":
-      return kind !== "assistant" && exactKeys4(value, ["type", "data", "mimeType"]) && boundedString2(value.data) && boundedString2(value.mimeType);
+      return (kind === "user" || kind === "toolResult") && exactKeys4(value, ["type", "data", "mimeType"]) && boundedString2(value.data) && boundedString2(value.mimeType);
     case "thinking":
       return kind === "assistant" && exactKeys4(value, ["type", "thinking", "thinkingSignature", "redacted"], ["type", "thinking"]) && boundedString2(value.thinking) && (value.thinkingSignature === void 0 || boundedString2(value.thinkingSignature)) && (value.redacted === void 0 || typeof value.redacted === "boolean");
     case "toolCall":
-      return kind === "assistant" && exactKeys4(value, ["type", "id", "name", "arguments", "thoughtSignature"], ["type", "id", "name", "arguments"]) && boundedString2(value.id) && boundedString2(value.name) && validOpaqueJson(value.arguments) && (value.thoughtSignature === void 0 || boundedString2(value.thoughtSignature));
+      return kind === "assistant" && exactKeys4(value, ["type", "id", "name", "arguments", "thoughtSignature", "namespace"], ["type", "id", "name", "arguments"]) && boundedString2(value.id) && boundedString2(value.name) && validOpaqueJson(value.arguments) && (value.thoughtSignature === void 0 || boundedString2(value.thoughtSignature)) && (value.namespace === void 0 || boundedString2(value.namespace));
     default:
       return false;
   }
 }
 function validContent(value, kind) {
-  if (kind === "user" && typeof value === "string") return boundedString2(value);
+  if ((kind === "user" || kind === "system") && typeof value === "string") return boundedString2(value);
   return Array.isArray(value) && value.length <= MAX_JSON_ARRAY && value.every((block) => validContentBlock(block, kind));
 }
 function validUsage(value) {
@@ -8335,24 +8335,32 @@ function validDeferredHandle(value) {
     ["provider", "modelId", "api", "id"]
   ) && ["provider", "modelId", "api", "id"].every((key) => boundedString2(value[key])) && (value.expiresAt === void 0 || typeof value.expiresAt === "number" && Number.isFinite(value.expiresAt)) && (value.pollAfterMs === void 0 || typeof value.pollAfterMs === "number" && Number.isFinite(value.pollAfterMs)) && (value.data === void 0 || validOpaqueJson(value.data));
 }
+function validNestedCalls(value) {
+  return isRecord(value) && exactKeys4(value, ["calls", "complete"]) && typeof value.complete === "boolean" && Array.isArray(value.calls) && value.calls.length <= MAX_JSON_ARRAY && value.calls.every((call) => isRecord(call) && exactKeys4(call, ["id", "name", "arguments", "argumentsBytes", "status", "durationMs", "error"], ["id", "name", "status"]) && boundedString2(call.id) && boundedString2(call.name) && (call.status === "ok" || call.status === "error" || call.status === "unfinished") && (call.arguments === void 0 || isRecord(call.arguments) && validOpaqueJson(call.arguments)) && (call.argumentsBytes === void 0 || typeof call.argumentsBytes === "number" && Number.isFinite(call.argumentsBytes)) && (call.durationMs === void 0 || typeof call.durationMs === "number" && Number.isFinite(call.durationMs)) && (call.error === void 0 || boundedString2(call.error)));
+}
+function validSystemMessage(value) {
+  const sections = value.sections;
+  return exactKeys4(value, ["role", "content", "sections", "toolsAdded", "toolsRemoved", "timestamp"], ["role", "content", "timestamp"]) && validContent(value.content, "system") && (sections === void 0 || isRecord(sections) && Object.keys(sections).length <= MAX_JSON_KEYS && Object.keys(sections).every((key) => boundedString2(key) && (sections[key] === null || boundedString2(sections[key])))) && (value.toolsAdded === void 0 || Array.isArray(value.toolsAdded) && value.toolsAdded.length <= MAX_JSON_ARRAY && value.toolsAdded.every((tool) => isRecord(tool) && boundedString2(tool.name) && validOpaqueJson(tool))) && (value.toolsRemoved === void 0 || Array.isArray(value.toolsRemoved) && value.toolsRemoved.length <= MAX_JSON_ARRAY && value.toolsRemoved.every((tool) => isRecord(tool) && exactKeys4(tool, ["name"]) && boundedString2(tool.name))) && typeof value.timestamp === "number" && Number.isFinite(value.timestamp);
+}
 function validMessage(value) {
   if (!isRecord(value) || typeof value.role !== "string") return false;
+  if (value.role === "system") return validSystemMessage(value);
   if (value.role === "user") {
     return exactKeys4(value, ["role", "content", "timestamp"]) && validContent(value.content, "user") && typeof value.timestamp === "number" && Number.isFinite(value.timestamp);
   }
   if (value.role === "assistant") {
     return exactKeys4(
       value,
-      ["role", "content", "api", "provider", "model", "responseModel", "responseId", "diagnostics", "usage", "stopReason", "errorMessage", "rawStopReason", "deferred", "timestamp"],
+      ["role", "content", "api", "provider", "model", "responseModel", "responseId", "providerThinkingLevel", "thinkingLevel", "diagnostics", "usage", "stopReason", "errorMessage", "rawStopReason", "deferred", "endTurn", "timestamp"],
       ["role", "content", "api", "provider", "model", "usage", "stopReason", "timestamp"]
-    ) && validContent(value.content, "assistant") && ["api", "provider", "model", "stopReason"].every((key) => typeof value[key] === "string") && (value.responseModel === void 0 || boundedString2(value.responseModel)) && (value.responseId === void 0 || boundedString2(value.responseId)) && (value.errorMessage === void 0 || boundedString2(value.errorMessage)) && (value.rawStopReason === void 0 || boundedString2(value.rawStopReason)) && (value.deferred === void 0 || validDeferredHandle(value.deferred)) && (value.diagnostics === void 0 || Array.isArray(value.diagnostics) && value.diagnostics.length <= MAX_JSON_ARRAY && value.diagnostics.every(validDiagnostic)) && validUsage(value.usage) && typeof value.timestamp === "number" && Number.isFinite(value.timestamp);
+    ) && validContent(value.content, "assistant") && ["api", "provider", "model", "stopReason"].every((key) => typeof value[key] === "string") && (value.responseModel === void 0 || boundedString2(value.responseModel)) && (value.responseId === void 0 || boundedString2(value.responseId)) && (value.errorMessage === void 0 || boundedString2(value.errorMessage)) && (value.rawStopReason === void 0 || boundedString2(value.rawStopReason)) && (value.providerThinkingLevel === void 0 || boundedString2(value.providerThinkingLevel)) && (value.thinkingLevel === void 0 || boundedString2(value.thinkingLevel)) && (value.endTurn === void 0 || typeof value.endTurn === "boolean") && (value.deferred === void 0 || validDeferredHandle(value.deferred)) && (value.diagnostics === void 0 || Array.isArray(value.diagnostics) && value.diagnostics.length <= MAX_JSON_ARRAY && value.diagnostics.every(validDiagnostic)) && validUsage(value.usage) && typeof value.timestamp === "number" && Number.isFinite(value.timestamp);
   }
   if (value.role === "toolResult") {
     return exactKeys4(
       value,
-      ["role", "toolCallId", "toolName", "content", "details", "isError", "usage", "timestamp"],
+      ["role", "toolCallId", "toolName", "content", "details", "isError", "usage", "nestedCalls", "timestamp"],
       ["role", "toolCallId", "toolName", "content", "isError", "timestamp"]
-    ) && typeof value.toolCallId === "string" && typeof value.toolName === "string" && validContent(value.content, "toolResult") && (value.details === void 0 || validOpaqueJson(value.details)) && (value.usage === void 0 || validUsage(value.usage)) && typeof value.isError === "boolean" && typeof value.timestamp === "number" && Number.isFinite(value.timestamp);
+    ) && typeof value.toolCallId === "string" && typeof value.toolName === "string" && validContent(value.content, "toolResult") && (value.details === void 0 || validOpaqueJson(value.details)) && (value.usage === void 0 || validUsage(value.usage)) && (value.nestedCalls === void 0 || validNestedCalls(value.nestedCalls)) && typeof value.isError === "boolean" && typeof value.timestamp === "number" && Number.isFinite(value.timestamp);
   }
   return false;
 }
@@ -8401,8 +8409,9 @@ function validAssistantEvent(value) {
       return exactWithOptionalPartial(["type"]);
     case "text_start":
     case "thinking_start":
-    case "toolcall_start":
       return exactWithOptionalPartial(["type", "contentIndex"]) && contentIndex();
+    case "toolcall_start":
+      return ("id" in value || "toolName" in value ? exactKeys4(value, ["type", "contentIndex", "id", "toolName"]) && boundedString2(value.id) && boundedString2(value.toolName) : exactWithOptionalPartial(["type", "contentIndex"])) && contentIndex();
     case "text_delta":
     case "thinking_delta":
     case "toolcall_delta":
@@ -8413,7 +8422,7 @@ function validAssistantEvent(value) {
     case "toolcall_end":
       return exactWithOptionalPartial(["type", "contentIndex", "toolCall"]) && contentIndex() && validContentBlock(value.toolCall, "assistant");
     case "done":
-      return exactKeys4(value, ["type", "reason", "message"]) && ["stop", "length", "toolUse"].includes(value.reason) && validMessage(value.message) && value.message.role === "assistant";
+      return exactKeys4(value, ["type", "reason", "message"]) && ["stop", "length", "toolUse", "deferred"].includes(value.reason) && validMessage(value.message) && value.message.role === "assistant";
     case "error":
       return exactKeys4(value, ["type", "reason", "error"]) && ["aborted", "error"].includes(value.reason) && validMessage(value.error) && value.error.role === "assistant";
     default:
@@ -8435,7 +8444,8 @@ function parseChildJsonLine(line) {
     case "response":
       if (typeof record2.id !== "string" || record2.command !== "prompt" || typeof record2.success !== "boolean") invalidProtocol();
       if (record2.success === true) {
-        if (!exactKeys4(record2, ["type", "id", "command", "success"])) invalidProtocol();
+        const data = record2.data;
+        if (!exactKeys4(record2, ["type", "id", "command", "success", "data"], ["type", "id", "command", "success"]) || data !== void 0 && !(isRecord(data) && exactKeys4(data, ["disposition"]) && (data.disposition === "started" || data.disposition === "handled" || data.disposition === "queued"))) invalidProtocol();
       } else if (!exactKeys4(record2, ["type", "id", "command", "success", "error"]) || typeof record2.error !== "string") invalidProtocol();
       break;
     case "agent_start":
@@ -8454,16 +8464,16 @@ function parseChildJsonLine(line) {
       if (!exactKeys4(record2, ["type", "message"]) || !validMessage(record2.message) && !validPartialAssistantMessage(record2.message)) invalidProtocol();
       break;
     case "message_update":
-      if ("message" in record2 ? !exactKeys4(record2, ["type", "message", "assistantMessageEvent"]) || !validPartialAssistantMessage(record2.message) || !validAssistantEvent(record2.assistantMessageEvent) : !exactKeys4(record2, ["type", "assistantMessageEvent"]) || !validAssistantEvent(record2.assistantMessageEvent)) invalidProtocol();
+      if ("message" in record2 ? !exactKeys4(record2, ["type", "message", "assistantMessageEvent"]) || !validPartialAssistantMessage(record2.message) || !validAssistantEvent(record2.assistantMessageEvent) : "usage" in record2 ? !exactKeys4(record2, ["type", "usage", "assistantMessageEvent"]) || !validUsage(record2.usage) || !validAssistantEvent(record2.assistantMessageEvent) : !exactKeys4(record2, ["type", "assistantMessageEvent"]) || !validAssistantEvent(record2.assistantMessageEvent)) invalidProtocol();
       break;
     case "tool_execution_start":
-      if (!exactKeys4(record2, ["type", "toolCallId", "toolName", "args"]) || typeof record2.toolCallId !== "string" || typeof record2.toolName !== "string" || !validOpaqueJson(record2.args)) invalidProtocol();
+      if (!exactKeys4(record2, ["type", "toolCallId", "toolName", "args", "parentToolCallId"], ["type", "toolCallId", "toolName", "args"]) || record2.parentToolCallId !== void 0 && !boundedString2(record2.parentToolCallId) || typeof record2.toolCallId !== "string" || typeof record2.toolName !== "string" || !validOpaqueJson(record2.args)) invalidProtocol();
       break;
     case "tool_execution_update":
-      if (!exactKeys4(record2, ["type", "toolCallId", "toolName", "args", "partialResult"]) || typeof record2.toolCallId !== "string" || typeof record2.toolName !== "string" || !validOpaqueJson(record2.args) || !validOpaqueJson(record2.partialResult)) invalidProtocol();
+      if (!exactKeys4(record2, ["type", "toolCallId", "toolName", "args", "partialResult", "parentToolCallId"], ["type", "toolCallId", "toolName", "args", "partialResult"]) || record2.parentToolCallId !== void 0 && !boundedString2(record2.parentToolCallId) || typeof record2.toolCallId !== "string" || typeof record2.toolName !== "string" || !validOpaqueJson(record2.args) || !validOpaqueJson(record2.partialResult)) invalidProtocol();
       break;
     case "tool_execution_end":
-      if (!exactKeys4(record2, ["type", "toolCallId", "toolName", "result", "isError"]) || typeof record2.toolCallId !== "string" || typeof record2.toolName !== "string" || !validOpaqueJson(record2.result) || typeof record2.isError !== "boolean") invalidProtocol();
+      if (!exactKeys4(record2, ["type", "toolCallId", "toolName", "result", "isError", "parentToolCallId"], ["type", "toolCallId", "toolName", "result", "isError"]) || record2.parentToolCallId !== void 0 && !boundedString2(record2.parentToolCallId) || typeof record2.toolCallId !== "string" || typeof record2.toolName !== "string" || !validOpaqueJson(record2.result) || typeof record2.isError !== "boolean") invalidProtocol();
       break;
     case "extension_error":
       if (!exactKeys4(record2, ["type", "extensionPath", "event", "error"]) || typeof record2.extensionPath !== "string" || typeof record2.event !== "string" || typeof record2.error !== "string") invalidProtocol();
@@ -10588,7 +10598,7 @@ async function codeArbiterPi(pi) {
         activeTools: pi.getActiveTools(),
         allTools: pi.getAllTools(),
         expansionFingerprints,
-        childFingerprint: "22e5231b36a0af4a4202ced48a20e7dc9de435b6c6af985c6007bff96c5e04d1"
+        childFingerprint: "86a08a0d5c29aa6693a07065f4ab2d6ad1d43293c65277cee944389886363d67"
       });
       const wrapperSelfTest = await runPiWrapperSelfTest({
         enabled: enabledForDoctor,

package/plugins/ca-pi/helpers/artifacts/release.json

@@ -6,32 +6,32 @@
   "binaries": {
     "darwin/amd64": {
       "file": "ca-artifact-darwin-amd64",
-      "sha256": "645fbde59c9db28a51d52dd7c975750f97613516c4003b7f4a3057359893687d",
+      "sha256": "f25d64dc4fae4874f97c6a982382fcd0685552b62ecc29714d2f8f41280c20b1",
       "native_tested": true
     },
     "darwin/arm64": {
       "file": "ca-artifact-darwin-arm64",
-      "sha256": "390a6e9b65c2220bf52a6459eab4ec79283d4d560715a305280027f20e7a9d47",
+      "sha256": "92eb0c6394176508ed569d4969f2d5058b45c0b650cf538e6ea43f011ade5e1c",
       "native_tested": true
     },
     "linux/amd64": {
       "file": "ca-artifact-linux-amd64",
-      "sha256": "65d39e119b446987ad8e8bdd592a1819165a95fe2c00ed887a1349a4fe692f86",
+      "sha256": "57135caf8e274ea0929a0ddae8d3f520473b9342398ab7db25c5688ebcb77347",
       "native_tested": true
     },
     "linux/arm64": {
       "file": "ca-artifact-linux-arm64",
-      "sha256": "c5ae37567f9929b58beba88a3cd11e9e2de66bbb11a8f0fafbbae3bbcb0ba53f",
+      "sha256": "265c2d77b074017b30a2a979fd8926add4f0ede19a73bc83b77eb8a1147fecdc",
       "native_tested": true
     },
     "windows/amd64": {
       "file": "ca-artifact-windows-amd64.exe",
-      "sha256": "b381d900520c5024ec20c86333a29f007fb6f8a2737214c77916912836c3e762",
+      "sha256": "a4ec0eeccca1c840a19ad8a0da57a660f365c20d565e72edfae8f1bf18498e7e",
       "native_tested": true
     },
     "windows/arm64": {
       "file": "ca-artifact-windows-arm64.exe",
-      "sha256": "ccf2ca3a3ed103d247baee0275a8ce2c62af050a6af46d39c4186d8fd8ff2872",
+      "sha256": "3ac1d16a8030ffb8f12565f39b4a70245aa263048efa91e2f6fb5f613b3361f7",
       "native_tested": true
     }
   }

package/plugins/ca-pi/hooks/_artifactauthoritylib.py

@@ -933,8 +933,11 @@ def _bind_commands(
                 raise AuthorityError("UNSUPPORTED_EXECUTABLE", "declared Node runner entrypoint is unavailable") from exc
             launch_files.append(_launch_file(script, "runner-entrypoint"))
         if definition["required_tests"] and _command_name(definition["argv"][0]) in {"npm", "npm.cmd"}:
-            _runner, manifest = _npm_runner(definition["argv"], cwd)
-            launch_files.append(_launch_file(manifest, "npm-manifest"))
+            _runner, manifests = _npm_runner(definition["argv"], cwd)
+            if len(manifests) > 1:
+                launch_files.extend(_validate_nested_npm_launch(executable, manifests[0].parent))
+            launch_files.extend(_launch_file(manifest, "npm-manifest" if index == 0 else "npm-workspace-manifest")
+                                for index, manifest in enumerate(manifests))
         bindings.append({
             "definition_sha256": command["definition_sha256"],
             "argv": argv,
@@ -1433,7 +1436,147 @@ def _command_tokens(command: str) -> list[str]:
     return list(lexer)
 
 
-def _npm_runner(argv: list[str], cwd: Path | None) -> tuple[list[str], Path]:
+def _npm_package(manifest: Path) -> dict[str, Any]:
+    _path_identity(manifest)
+    with manifest.open("rb") as stream:
+        raw = stream.read(MAX_STATE + 1)
+    if len(raw) > MAX_STATE:
+        raise ValueError("oversized manifest")
+    package = json.loads(raw.decode("utf-8"), object_pairs_hook=_unique_json_pairs,
+                         parse_constant=_invalid_json_constant)
+    if not isinstance(package, dict):
+        raise ValueError("manifest is not an object")
+    return package
+
+
+def _npm_script(package: dict[str, Any], name: str) -> list[str]:
+    scripts = package["scripts"]
+    script = scripts[name]
+    if not isinstance(script, str) or any(marker in script for marker in ("\n", "\r", ";", "&", "|", ">", "<", "`", "$")):
+        raise ValueError("compound script")
+    if os.name == "nt" and any(marker in script for marker in ("^", "%", "!", "'")):
+        raise ValueError("unsupported cmd.exe expansion or quoting")
+    if scripts.get("pre" + name) or scripts.get("post" + name):
+        raise ValueError("lifecycle scripts")
+    tokens = _command_tokens(script)
+    if not tokens:
+        raise ValueError("empty script")
+    return tokens
+
+
+def _npm_workspace_runner(tokens: list[str], package: dict[str, Any], manifest: Path) -> tuple[list[str], list[Path]]:
+    # Exactly one explicit workspace selector and one delegation level. These
+    # tokens select a collector; they never replace the declared root invocation.
+    if (tokens[0] not in {"npm", "npm.cmd"} or (tokens[0] == "npm.cmd" and os.name != "nt")
+            or len(tokens) < 5 or tokens[1] not in {"-w", "--workspace"}
+            or tokens[3] not in {"run", "run-script"}
+            or not re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9:._-]*", tokens[4])):
+        raise ValueError("unsupported workspace delegation")
+    selector = tokens[2]
+    name_pattern = r"(?:@[a-z0-9._-]+/)?[a-z0-9][a-z0-9._-]*"
+    if not re.fullmatch(name_pattern, selector):
+        raise ValueError("workspace selector must be an exact package name")
+    forwarded = tokens[5:]
+    if forwarded:
+        if forwarded[0] != "--":
+            raise ValueError("workspace runner arguments must follow --")
+        forwarded = forwarded[1:]
+    workspaces = package.get("workspaces")
+    if not isinstance(workspaces, list) or not 1 <= len(workspaces) <= 32:
+        raise ValueError("workspaces must be a bounded array of explicit directories")
+    inspected, names, paths, selected = [], set(), set(), None
+    root = manifest.parent
+    selector_path = root / selector
+    for value in workspaces:
+        if (not isinstance(value, str) or not value or any(c in value for c in "\\!*?[]{}()")
+                or Path(value).anchor or PureWindowsPath(value).anchor
+                or any(part in {"", ".", ".."} for part in value.split("/"))):
+            raise ValueError("workspace path is not an explicit contained directory")
+        directory = root
+        for part in value.split("/"):
+            directory /= part
+            _path_identity(directory)
+        directory.resolve(strict=True).relative_to(root.resolve(strict=True))
+        workspace_manifest = directory / "package.json"
+        identity = _path_identity(workspace_manifest)
+        if identity in paths:
+            raise ValueError("duplicate workspace directory")
+        paths.add(identity)
+        workspace = _npm_package(workspace_manifest)
+        name = workspace.get("name")
+        if not isinstance(name, str) or not re.fullmatch(name_pattern, name) or name in names:
+            raise ValueError("missing or duplicate workspace name")
+        names.add(name)
+        inspected.append(workspace_manifest)
+        # npm also treats selectors as directory filters. Refuse a name that
+        # could select an additional workspace by its path or parent directory.
+        if name != selector and (directory == selector_path or selector_path in directory.parents):
+            raise ValueError("ambiguous workspace name and directory selector")
+        if name == selector:
+            selected = workspace
+    if selected is None:
+        raise ValueError("workspace name was not found")
+    runner = _npm_script(selected, tokens[4])
+    if _command_name(runner[0]) in {"npm", "npm.cmd"}:
+        raise ValueError("recursive npm delegation")
+    return [*runner, *forwarded], inspected
+
+
+def _validate_nested_npm_launch(executable: Path, cwd: Path) -> list[dict[str, str]]:
+    # npm prepends every ancestor's node_modules/.bin to its script PATH.
+    # A nested npm must resolve to the same qualified executable as its parent.
+    names = ("npm", "npm.cmd", "npm.bat", "npm.exe", "npm.com") if os.name == "nt" else ("npm",)
+    directories = [parent / "node_modules" / ".bin" for parent in (cwd, *cwd.parents)]
+    if os.name == "nt":
+        directories.insert(0, cwd)  # cmd.exe searches its working directory first.
+    if any(os.path.lexists(directory / name) for directory in directories for name in names):
+        raise AuthorityError("UNSUPPORTED_EXECUTABLE", "nested npm is shadowed by a local executable")
+    if _resolve_executable("npm", cwd) != executable:
+        raise AuthorityError("UNSUPPORTED_EXECUTABLE", "nested npm resolves to a different executable")
+    if os.name != "nt":
+        return []
+    # The outer launch pins npm-cli.js directly, but a script's npm.cmd consults
+    # npm-prefix.js and may redirect to another installation. Qualify that same
+    # helper in the manifest directory, and retain its identity with the CLI.
+    node = executable.parent / "node.exe"
+    cli = executable.parent / "node_modules" / "npm" / "bin" / "npm-cli.js"
+    helper = cli.with_name("npm-prefix.js")
+    try:
+        helper_binding = _launch_file(helper, "npm-prefix")
+    except (OSError, AuthorityError) as exc:
+        raise AuthorityError("UNSUPPORTED_EXECUTABLE", "nested npm prefix helper is unavailable") from exc
+    environment, _environment_digest = _minimal_environment()
+
+    def probe(arguments: list[str]) -> list[str]:
+        try:
+            result = _run_contained([str(node), *arguments], cwd=str(cwd), env=environment,
+                                    timeout_seconds=15)
+            if result.returncode or result.stderr or len(result.stdout) > 32768:
+                raise ValueError("unsuccessful or oversized qualification output")
+            return result.stdout.decode("utf-8", errors="strict").splitlines()
+        except (OSError, ValueError, subprocess.SubprocessError, AuthorityError) as exc:
+            raise AuthorityError("UNSUPPORTED_EXECUTABLE", "nested npm launch qualification failed") from exc
+
+    config = probe([str(cli), "config", "get", "script-shell", "node-options"])
+    if config != ["script-shell=null", "node-options=null"]:
+        raise AuthorityError("UNSUPPORTED_EXECUTABLE", "nested npm requires default script-shell and node-options")
+    prefixes = probe([str(helper)])
+    if (len(prefixes) != 1 or not Path(prefixes[0]).is_absolute()
+            or any(ord(character) < 32 or character in '\"<>|?*' for character in prefixes[0])):
+        raise AuthorityError("UNSUPPORTED_EXECUTABLE", "nested npm prefix qualification returned an invalid path")
+    redirected_cli = Path(prefixes[0]) / "node_modules" / "npm" / "bin" / "npm-cli.js"
+    if (os.path.lexists(redirected_cli)
+            and os.path.normcase(os.path.normpath(redirected_cli)) != os.path.normcase(os.path.normpath(cli))):
+        raise AuthorityError("UNSUPPORTED_EXECUTABLE", "nested npm prefix would redirect to a different CLI")
+    try:
+        if _launch_file(helper, "npm-prefix") != helper_binding:
+            raise OSError("prefix helper changed during qualification")
+    except (OSError, AuthorityError) as exc:
+        raise AuthorityError("UNSUPPORTED_EXECUTABLE", "nested npm prefix helper changed during qualification") from exc
+    return [helper_binding]
+
+
+def _npm_runner(argv: list[str], cwd: Path | None) -> tuple[list[str], list[Path]]:
     message = "declare a direct test runner with an explicit supported reporter; npm scripts must be a single runner command"
     if cwd is None:
         raise AuthorityError("UNSUPPORTED_COLLECTOR", "npm runner requires an inspectable package.json; " + message)
@@ -1468,25 +1611,22 @@ def _npm_runner(argv: list[str], cwd: Path | None) -> tuple[list[str], Path]:
             directory /= part
             _path_identity(directory)
         manifest.parent.resolve(strict=True).relative_to(cwd.resolve(strict=True))
-        _path_identity(manifest)
-        with manifest.open("rb") as stream:
-            raw = stream.read(MAX_STATE + 1)
-        if len(raw) > MAX_STATE:
-            raise ValueError("oversized manifest")
-        package = json.loads(raw.decode("utf-8"), object_pairs_hook=_unique_json_pairs,
-                             parse_constant=_invalid_json_constant)
-        scripts = package["scripts"]
-        script = scripts[script_name]
-        if not isinstance(script, str) or any(marker in script for marker in ("\n", "\r", ";", "&", "|", ">", "<", "`", "$")):
-            raise ValueError("compound script")
-        if scripts.get("pre" + script_name) or scripts.get("post" + script_name):
-            raise ValueError("lifecycle scripts")
-        tokens = _command_tokens(script)
-        if not tokens or _command_name(tokens[0]) in {"npm", "npm.cmd"}:
-            raise ValueError("nested npm script")
+        package = _npm_package(manifest)
+        tokens = _npm_script(package, script_name)
+        manifests = [manifest]
     except (OSError, ValueError, KeyError, TypeError, RecursionError, AuthorityError) as exc:
         raise AuthorityError("UNSUPPORTED_COLLECTOR", "npm package script is unavailable or compound; " + message) from exc
-    return [*tokens, *forwarded], manifest
+    if _command_name(tokens[0]) in {"npm", "npm.cmd"}:
+        # --prefix changes npm's config lookup and the environment inherited by
+        # its script. Until those contexts are bound, qualify root delegation only.
+        if relative != Path("."):
+            raise AuthorityError("UNSUPPORTED_COLLECTOR", "nested npm workspace delegation requires --prefix .")
+        try:
+            runner, inspected = _npm_workspace_runner([*tokens, *forwarded], package, manifest)
+            return runner, [manifest, *inspected]
+        except (OSError, ValueError, KeyError, TypeError, RecursionError, AuthorityError) as exc:
+            raise AuthorityError("UNSUPPORTED_COLLECTOR", "npm package script is unavailable or compound; " + message) from exc
+    return [*tokens, *forwarded], manifests
 
 
 def validate_command_definition(definition: dict[str, Any], *, cwd: Path | None = None) -> str:

package/plugins/ca-pi/hooks/_gitlib.py

@@ -99,9 +99,15 @@ def head_branch(root):
 
 
 def git_dirty(root):
-    """Return dirty state, suppressing the marker when Git fails or times out."""
+    """Return dirty state, suppressing the marker when Git fails or times out.
+
+    --no-optional-locks: the probe is killed at DIRTY_CHECK_TIMEOUT_SECONDS, and a
+    plain `git status` opportunistically rewrites a stale index under
+    .git/index.lock; a kill inside that write strands the lock and blocks the
+    user's next commit. A read-only probe must never take it."""
     try:
-        out = subprocess.run([git_executable(), "-C", root, "status", "--porcelain"],
+        out = subprocess.run([git_executable(), "--no-optional-locks", "-C", root,
+                              "status", "--porcelain"],
                              capture_output=True, text=True,
                              timeout=DIRTY_CHECK_TIMEOUT_SECONDS,
                              encoding="utf-8", errors="replace")

package/plugins/ca-pi/hooks/_host.py

@@ -11,7 +11,7 @@ import hostapi  # noqa: E402
 class PiHost(hostapi.Host):
     name = "pi"
     adapter_name = "@arbiterforge/ca-pi"
-    adapter_version = "0.15.7"
+    adapter_version = "0.15.10"
     update_target = "ca-pi"
     update_tag_prefix = "ca-pi-v"
     update_command = "pi update npm:@arbiterforge/ca-pi"

package/plugins/ca-pi/hooks/hostapi.py

@@ -313,7 +313,7 @@ class Host:
 
     name = "claude"
     adapter_name = "ca"
-    adapter_version = "2.23.0"
+    adapter_version = "2.23.2"
 
     # Update-notifier descriptor. Each independently versioned host overrides
     # these three values in its per-plugin _host.py. Keeping the target,

package/plugins/ca-pi/includes/artifacts.md

@@ -262,13 +262,27 @@ the filename, not a leaf-name alias. Named unittest commands require `-v` or
 Plain exit checks cannot attest named tests.
 
 Named npm commands support inspectable single-runner scripts, a contained
-repository-relative `--prefix`, and arguments forwarded after `--`. Compound
+repository-relative `--prefix`, and arguments forwarded after `--`. A root script
+may delegate once through `npm -w <name> run <script>` or
+`npm --workspace <name> run <script>` when the name resolves uniquely in an array
+of at most 32 explicit, contained workspace directories. The runner binds the root
+manifest and every inspected workspace manifest. Globs, linked directories,
+multiple workspace selectors and recursive npm delegation are unsupported.
+Workspace delegation uses the declared cwd; a non-dot `--prefix` is unsupported
+for this shape.
+Preserve both npm argument boundaries when adding a reporter: for a root
+`test:client` script containing `npm -w @example/client run test`, declare
+`npm run test:client -- -- --reporter=verbose` to forward the reporter to Vitest.
+The original root command still executes the full script. Compound
 scripts and pre/post lifecycle scripts require separately declared direct-runner
 commands; retain every check from the original suite when splitting commands.
 On Windows, only the qualified standard `npm.cmd` layout is adapted: the runner
 pins the wrapper, sibling `node.exe`, sibling `node_modules/npm/bin/npm-cli.js`,
 and script manifest. It deliberately selects that sibling CLI rather than the
 shim's optional global-prefix redirection. Unknown batch wrappers fail closed.
+For workspace delegation, it also pins `npm-prefix.js` and checks that the nested
+wrapper uses the same CLI, the default script shell, and no configured Node
+options. Local executables shadowing nested npm are rejected.
 Direct Node script entrypoints are also pinned. These launch-file bindings do
 not establish transitive dependency closure for deliberately excluded inputs.
 

package/plugins/ca-pi/includes/pi-host-notes.md

@@ -74,7 +74,7 @@ file maps those actions to Pi's extension API.
   operator-launched Pi CLI, imported module, package root, and reported version.
   It does not prove publisher authenticity. Verify the source separately with
   `pi list` and `pi config`.
-- The supported promotion target is exact Pi 0.84.1. The package is
+- The supported promotion target is exact Pi 1.0.0. The package is
   published as `npm:@arbiterforge/ca-pi` on every `ca-pi-v*` tag (ADR-0029);
   the pinned Git tag remains the reproducible install. A Pi-native embedded
   farm worker is a future spike, not an installed dependency.

package/plugins/ca-pi/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arbiterforge/ca-pi",
-  "version": "0.15.7",
+  "version": "0.15.10",
   "private": true,
   "license": "AGPL-3.0-only",
   "type": "module",

package/plugins/ca-pi/skills/ca-doctor/SKILL.md

@@ -32,7 +32,7 @@ repository binary, mutate an artifact, or silently fall back to Markdown.
    Pi bash wrapper. The exact shared-core `[H-03]` block is healthy and cannot stage files; execution
    or a different block is unhealthy. This self-test does not traverse Pi's active dispatcher. Do not
    rerun or respell it.
-4. Its `active-dispatch` row remains degraded because supported Pi 0.84.1 public extension
+4. Its `active-dispatch` row remains degraded because supported Pi 1.0.0 public extension
    APIs cannot submit that deterministic call through the active dispatcher. PI-AC-28 remains blocked
    until supported-version real-host promotion/CI evidence closes the gap.
 5. Resolve Python once, run `<plugin-root>/hooks/doctor.py`, and present its mechanical report