@akagilnc/pi-workflow-roles 0.1.2521 → 0.1.2653-next.71811ca

package/src/dossier-resolution.ts

@@ -5,8 +5,6 @@
 import { existsSync, statSync } from "node:fs";
 import { resolve } from "node:path";
 
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-
 import { JUDGE_OUTPUT_TOOL_NAME as JUDGE_OUTPUT_TOOL } from "./package-contracts/judge-output.ts";
 
 export const JUDGE_OUTPUT_TOOL_NAME = JUDGE_OUTPUT_TOOL;
@@ -71,24 +69,26 @@ function isRecord(value: unknown): value is Record<string, unknown> {
  * Judge subjects must already be on the parent session books before audit starts:
  * assignment (user message) + candidate verdict (sole judge output tool call).
  */
-export function readJudgeAuditSubjects(context: ExtensionContext): SubjectResolution {
+type AuditSubjectContext = { sessionManager: { getEntries?(): Iterable<unknown> } };
+
+export function readJudgeAuditSubjects(context: AuditSubjectContext): SubjectResolution {
   const entries = context.sessionManager.getEntries?.() ?? [];
   let hasAssignment = false;
   let hasCandidate = false;
   for (const entry of entries) {
-    if (entry.type !== "message") continue;
+    if (!isRecord(entry) || entry.type !== "message" || !isRecord(entry.message)) continue;
     const message = entry.message;
     if (message.role === "user") {
       const text = typeof message.content === "string"
         ? message.content
         : Array.isArray(message.content)
-          ? message.content.map((part) => (part.type === "text" ? part.text : "")).join("")
+          ? message.content.map((part) => (isRecord(part) && part.type === "text" && typeof part.text === "string" ? part.text : "")).join("")
           : "";
       if (text.trim().length > 0) hasAssignment = true;
     }
     if (message.role === "assistant" && Array.isArray(message.content)) {
       for (const part of message.content) {
-        if (part.type === "toolCall" && part.name === JUDGE_OUTPUT_TOOL_NAME && isRecord(part.arguments)) {
+        if (isRecord(part) && part.type === "toolCall" && part.name === JUDGE_OUTPUT_TOOL_NAME && isRecord(part.arguments)) {
           hasCandidate = true;
         }
       }
@@ -106,10 +106,10 @@ export function readJudgeAuditSubjects(context: ExtensionContext): SubjectResolu
 /**
  * Doctor candidate testimony must be recorded before audit.
  */
-export function readDoctorAuditSubjects(context: ExtensionContext): SubjectResolution {
+export function readDoctorAuditSubjects(context: AuditSubjectContext): SubjectResolution {
   const entries = context.sessionManager.getEntries?.() ?? [];
   for (const entry of entries) {
-    if (entry.type === "custom" && entry.customType === DOCTOR_CANDIDATE_ENTRY_TYPE) {
+    if (isRecord(entry) && entry.type === "custom" && entry.customType === DOCTOR_CANDIDATE_ENTRY_TYPE) {
       return { status: "ok" };
     }
   }

package/src/engine-detour-tool.ts

@@ -5,15 +5,11 @@
  * Engine process failures stop through the host infrastructure-failure seam.
  * Caller AbortSignal cancellation propagates unchanged.
  */
-import type {
-  AgentToolResult,
-  ExtensionAPI,
-  ExtensionContext,
-  ToolDefinition,
-} from "@earendil-works/pi-coding-agent";
 import { Type, type Static } from "typebox";
+import type { HostContext, HostToolDefinition, HostToolResult, RoleHost } from "./host-contracts.ts";
 
 import {
+  ENGINE_DETOUR_ALREADY_USED_DIAGNOSTIC,
   ENGINE_DETOUR_TOOL_NAME,
   engineDetourFailureDiagnostic,
   engineNameFromEnv,
@@ -33,14 +29,23 @@ const engineDetourArgsSchema = Type.Object(
 
 type EngineDetourArgs = Static<typeof engineDetourArgsSchema>;
 
+type EngineDetourContext = Pick<HostContext, "cwd" | "mode" | "abort">;
+
 export type EngineDetourHostActions = {
   failInfrastructure(
     error: unknown,
-    ctx: ExtensionContext,
+    ctx: EngineDetourContext,
     toolCallId?: string,
   ): never;
 };
 
+export type EngineDetourToolRegistration = {
+  /** True when the tool definition was installed on this ExtensionAPI. */
+  readonly registered: boolean;
+};
+
+type EngineDetourLatch = { used: boolean };
+
 /** Caller/upper-layer cancellation must propagate unchanged. */
 function isCallerCancellation(
   error: unknown,
@@ -58,21 +63,24 @@ function isCallerCancellation(
 }
 
 /**
- * Build one detour tool definition for a configured engine name.
+ * Build one once-latch detour tool definition for a configured engine name.
+ * `latch` is shared so parent registration can reset between activations.
  * `fail` owns host abort (parent) vs throw (evidence child) for tool misuse only.
  * Engine process failures (nonzero/empty/spawn) stop via `fail` with their cause.
  * Caller AbortSignal cancellation propagates unchanged.
  */
 export function createEngineDetourToolDefinition(input: {
   engineName: string;
-  fail: (error: Error, toolCallId: string, ctx: ExtensionContext) => never;
-}): ToolDefinition {
+  latch?: EngineDetourLatch;
+  fail: (error: Error, toolCallId: string, ctx: EngineDetourContext) => never;
+}): HostToolDefinition<typeof engineDetourArgsSchema, unknown, EngineDetourContext> {
+  const latch = input.latch ?? { used: false };
   const engineName = input.engineName;
   return {
     name: ENGINE_DETOUR_TOOL_NAME,
     label: "劳务引擎",
     description:
-      `运行一次劳务引擎子进程（engine=${engineName}），stdout 返回本 session。`,
+      `运行一次劳务引擎子进程（engine=${engineName}），stdout 返回本 session；每次激活至多一次。`,
     promptSnippet: "运行配置的劳务引擎一次并返回 stdout",
     parameters: engineDetourArgsSchema,
     async execute(
@@ -81,7 +89,16 @@ export function createEngineDetourToolDefinition(input: {
       signal,
       _onUpdate,
       ctx,
-    ): Promise<AgentToolResult<unknown>> {
+    ): Promise<HostToolResult> {
+      if (latch.used) {
+        input.fail(
+          new Error(ENGINE_DETOUR_ALREADY_USED_DIAGNOSTIC),
+          toolCallId,
+          ctx,
+        );
+      }
+      latch.used = true;
+
       const args = params as EngineDetourArgs;
       const argv = Array.isArray(args.argv) ? args.argv : [];
       if (argv.length === 0 || argv.some((part) => typeof part !== "string" || part.length === 0)) {
@@ -120,33 +137,45 @@ export function createEngineDetourToolDefinition(input: {
         details: {
           tool: ENGINE_DETOUR_TOOL_NAME,
           code: result.code,
-          stderr: result.stderr,
         },
       };
     },
-  } as ToolDefinition;
+  };
 }
 
 /**
  * Register the engine-generic detour tool once for this process when any role has
  * an engine activation signal. Returns whether registration occurred.
+ * Once-latch is activation-scoped via the returned reset handle.
  */
 export function registerEngineDetourTool(
-  pi: ExtensionAPI,
+  roleHost: RoleHost,
   hostActions: EngineDetourHostActions,
-): boolean {
+): EngineDetourToolRegistration & { resetLatch(): void } {
   const engineName = engineNameFromEnv();
   if (engineName === undefined) {
-    return false;
+    return {
+      registered: false,
+      resetLatch() {
+        /* no-op when unregistered */
+      },
+    };
   }
 
+  const latch: EngineDetourLatch = { used: false };
   const definition = createEngineDetourToolDefinition({
     engineName,
+    latch,
     fail(error, toolCallId, ctx) {
       hostActions.failInfrastructure(error, ctx, toolCallId);
     },
   });
-  pi.registerTool(definition);
+  roleHost.registerTool(definition);
 
-  return true;
+  return {
+    registered: true,
+    resetLatch() {
+      latch.used = false;
+    },
+  };
 }

package/src/engine-detour.ts

@@ -30,6 +30,9 @@ export function applyEngineChildEnv(
 export const ENGINE_DETOUR_EMPTY_STDOUT_DIAGNOSTIC =
   "劳务引擎 stdout 为空" as const;
 
+export const ENGINE_DETOUR_ALREADY_USED_DIAGNOSTIC =
+  "本激活内劳务引擎已使用" as const;
+
 export type EngineDetourResult = Readonly<{
   code: number;
   stdout: string;