@osolmaz/pi-workflows 0.12.0 → 0.12.1

package/src/builtins/sanity-check.workflow.ts

@@ -4,8 +4,13 @@ import {
   type CommandBatchItemResult,
 } from "../workflows/command-batch.js";
 import { action, compute, defineWorkflow, notify } from "../workflows/definition.js";
-import type { WorkflowActionContext } from "../workflows/types.js";
-import { runIsolatedReviewSessions, type IsolatedReviewRequest } from "./sanity-check-session.js";
+import { extractJsonValue } from "../workflows/json.js";
+import type { WorkflowActionContext, WorkflowProgressStatus } from "../workflows/types.js";
+import {
+  runPiAgentGroup,
+  type PiAgentLifecycleEvent,
+  type PiAgentRequest,
+} from "./pi-agent-group.js";
 
 const REVIEW_TIMEOUT_MS = 20 * 60_000;
 const MAX_STRING_CHARS = 4_000;
@@ -237,21 +242,37 @@ export async function collectContributionEvidence(
   };
 }
 
+type SanityCheckAgentPrompt = Pick<PiAgentRequest, "id" | "role" | "prompt">;
+
 export function buildReviewRequests(
   mode: SanityCheckMode,
   evidence: ContributionEvidence,
-): IsolatedReviewRequest[] {
+): SanityCheckAgentPrompt[] {
   if (mode === "serial") {
-    return [{ id: "review", prompt: reviewPrompt(reviewAreas, evidence) }];
+    return [{ id: "review", role: "Combined review", prompt: reviewPrompt(reviewAreas, evidence) }];
   }
-  return reviewAreas.map((area) => ({ id: area, prompt: reviewPrompt([area], evidence) }));
+  const roles: Record<SanityCheckArea, string> = {
+    necessity: "Necessity",
+    duplication: "Duplication and refactoring",
+    contracts: "Data models and public APIs",
+    scope_tests: "Scope and tests",
+  };
+  return reviewAreas.map((area) => ({
+    id: area,
+    role: roles[area],
+    prompt: reviewPrompt([area], evidence),
+  }));
 }
 
 export function buildVerificationRequest(
   evidence: ContributionEvidence,
   reviews: SanityCheckReview[],
-): IsolatedReviewRequest {
-  return { id: "verification", prompt: verificationPrompt(evidence, reviews) };
+): SanityCheckAgentPrompt {
+  return {
+    id: "verification",
+    role: "Verification",
+    prompt: verificationPrompt(evidence, reviews),
+  };
 }
 
 export function parseReviewOutput(
@@ -321,53 +342,177 @@ async function runReviews(context: WorkflowActionContext): Promise<SanityCheckRe
   const config = context.outputs.prepare as SanityCheckConfig;
   const evidence = context.outputs.collectEvidence as ContributionEvidence;
   const requests = buildReviewRequests(config.mode, evidence);
-  await publishProgress(context, "review", 0, requests.length);
-  const outputs = await runIsolatedReviewSessions(requests, evidence.repository, context.signal, {
-    maxConcurrency: config.mode === "parallel" ? 4 : 1,
-  });
-  const reviews = requests.map((request) =>
-    parseReviewOutput(
-      outputs[request.id],
-      config.mode === "serial" ? reviewAreas : [request.id as SanityCheckArea],
-    ),
-  );
-  await publishProgress(context, "review", requests.length, requests.length);
-  return reviews;
+  const progress = await createAgentProgress(context, "review", requests);
+  try {
+    const results = await runPiAgentGroup(agentRequests(requests, evidence.repository), {
+      maxConcurrency: config.mode === "parallel" ? 4 : 1,
+      signal: context.signal,
+      onLifecycle: progress.onLifecycle,
+    });
+    const reviews = results.map((result, index) =>
+      parseReviewOutput(
+        parseAgentJsonOutput(result.text, result.id),
+        config.mode === "serial" ? reviewAreas : [requests[index]!.id as SanityCheckArea],
+      ),
+    );
+    await progress.complete();
+    return reviews;
+  } catch (error) {
+    await progress.fail();
+    throw error;
+  }
 }
 
 async function verifyReviews(context: WorkflowActionContext): Promise<SanityCheckResult> {
   const evidence = context.outputs.collectEvidence as ContributionEvidence;
   const reviews = context.outputs.review as SanityCheckReview[];
-  await publishProgress(context, "verification", 0, 1);
-  const outputs = await runIsolatedReviewSessions(
-    [buildVerificationRequest(evidence, reviews)],
-    evidence.repository,
-    context.signal,
-    { maxConcurrency: 1 },
+  const requests = [buildVerificationRequest(evidence, reviews)];
+  const progress = await createAgentProgress(context, "verification", requests);
+  try {
+    const [result] = await runPiAgentGroup(agentRequests(requests, evidence.repository), {
+      maxConcurrency: 1,
+      signal: context.signal,
+      onLifecycle: progress.onLifecycle,
+    });
+    const parsed = parseSanityCheckResult(parseAgentJsonOutput(result!.text, result!.id));
+    await progress.complete();
+    return parsed;
+  } catch (error) {
+    await progress.fail();
+    throw error;
+  }
+}
+
+export function parseAgentJsonOutput(text: string, agentId: string): unknown {
+  try {
+    return extractJsonValue(text);
+  } catch {
+    throw new Error(`Sanity Check agent ${agentId} returned invalid JSON`);
+  }
+}
+
+function agentRequests(requests: SanityCheckAgentPrompt[], cwd: string): PiAgentRequest[] {
+  return requests.map((request) => ({
+    ...request,
+    cwd,
+    tools: ["read", "grep", "find", "ls"],
+    timeoutMs: REVIEW_TIMEOUT_MS,
+  }));
+}
+
+type AgentProgress = {
+  onLifecycle(event: PiAgentLifecycleEvent): Promise<void>;
+  complete(): Promise<void>;
+  fail(): Promise<void>;
+};
+
+async function createAgentProgress(
+  context: WorkflowActionContext,
+  group: "review" | "verification",
+  requests: SanityCheckAgentPrompt[],
+): Promise<AgentProgress> {
+  const aggregateKey = `agents/${group}`;
+  const settled = new Set<string>();
+  await safeProgress(context, aggregateKey, "running", group, 0, requests.length);
+  await Promise.all(
+    requests.map(
+      async (request) =>
+        await safeProgress(
+          context,
+          `${aggregateKey}/${request.id}`,
+          "pending",
+          "pending",
+          0,
+          1,
+          request.role,
+        ),
+    ),
   );
-  const result = parseSanityCheckResult(outputs.verification);
-  await publishProgress(context, "verification", 1, 1);
-  return result;
+  let updateWork = Promise.resolve();
+  const enqueue = (update: () => Promise<void>) => {
+    updateWork = updateWork.then(update).catch(() => undefined);
+    return updateWork;
+  };
+  return {
+    async onLifecycle(event) {
+      await enqueue(async () => {
+        const terminal = event.state !== "running";
+        if (terminal) settled.add(event.id);
+        const label = event.model === undefined ? event.role : `${event.role} · ${event.model}`;
+        await safeProgress(
+          context,
+          `${aggregateKey}/${event.id}`,
+          event.state,
+          event.phase,
+          terminal ? 1 : 0,
+          1,
+          label,
+        );
+        if (terminal) {
+          await safeProgress(
+            context,
+            aggregateKey,
+            "running",
+            group,
+            settled.size,
+            requests.length,
+          );
+        }
+      });
+    },
+    async complete() {
+      await enqueue(
+        async () =>
+          await safeProgress(
+            context,
+            aggregateKey,
+            "completed",
+            group,
+            requests.length,
+            requests.length,
+          ),
+      );
+    },
+    async fail() {
+      await enqueue(
+        async () =>
+          await safeProgress(
+            context,
+            aggregateKey,
+            context.signal.aborted ? "cancelled" : "failed",
+            group,
+            settled.size,
+            requests.length,
+          ),
+      );
+    },
+  };
 }
 
-async function publishProgress(
+async function safeProgress(
   context: WorkflowActionContext,
+  key: string,
+  status: WorkflowProgressStatus,
   phase: string,
   completed: number,
   total: number,
+  label?: string,
 ): Promise<void> {
-  await context.publishUpdate({
-    type: "progress",
-    key: phase,
-    data: {
-      schema: "pi-workflows.progress.v1",
-      status: completed === total ? "completed" : "running",
-      phase,
-      completed,
-      total,
-      unit: "sessions",
-    },
-  });
+  await context
+    .publishUpdate({
+      type: "progress",
+      key,
+      data: {
+        schema: "pi-workflows.progress.v1",
+        status,
+        phase,
+        completed,
+        total,
+        unit: "sessions",
+        ...(label !== undefined ? { label: label.slice(0, 200) } : {}),
+      },
+    })
+    .catch(() => undefined);
 }
 
 function reviewPrompt(areas: readonly SanityCheckArea[], evidence: ContributionEvidence): string {

package/src/extension/decision-channels.ts

@@ -14,7 +14,7 @@ import {
 } from "../workflows/decision-presentation.js";
 import { HumanDecisionStore, createHumanDecisionAttemptId } from "../workflows/human-decision.js";
 import type {
-  AcceptedHumanDecision,
+  ResolvedHumanDecision,
   HumanDecisionAnswerSource,
   HumanDecisionCancellationRecord,
   HumanDecisionChannelRequest,
@@ -47,7 +47,7 @@ export type HumanDecisionDeliveryResult = {
   errorCode?: string;
 };
 
-export type SettledHumanDecision = AcceptedHumanDecision | HumanDecisionCancellationRecord;
+export type SettledHumanDecision = ResolvedHumanDecision | HumanDecisionCancellationRecord;
 
 export interface HumanDecisionChannel {
   readonly id: string;
@@ -162,7 +162,7 @@ export class PiDecisionChannel implements HumanDecisionChannel {
       await this.options.store.recordDelivery(
         request,
         this.id,
-        v2DeliveryRecord(request, this.id, attemptId, "intent", "intent", createdAt),
+        deliveryRecord(request, this.id, attemptId, "intent", "intent", createdAt),
       );
       const entries = Object.entries(request.choices);
       const selectedChoice = await this.options.ui.custom<string | undefined>(
@@ -241,7 +241,7 @@ export class PiDecisionChannel implements HumanDecisionChannel {
         await this.options.store.recordDelivery(
           request,
           this.id,
-          v2DeliveryRecord(
+          deliveryRecord(
             request,
             this.id,
             `${attemptId}-cancelled`,
@@ -267,7 +267,7 @@ export class PiDecisionChannel implements HumanDecisionChannel {
           await this.options.store.recordDelivery(
             request,
             this.id,
-            v2DeliveryRecord(
+            deliveryRecord(
               request,
               this.id,
               `${attemptId}-cancelled`,
@@ -291,7 +291,7 @@ export class PiDecisionChannel implements HumanDecisionChannel {
       await this.options.store.recordDelivery(
         request,
         this.id,
-        v2DeliveryRecord(
+        deliveryRecord(
           request,
           this.id,
           `${attemptId}-confirmed`,
@@ -684,7 +684,7 @@ export class TelegramDecisionChannel implements HumanDecisionChannel {
     await this.store.recordDelivery(
       request,
       channelPath,
-      v2DeliveryRecord(request, this.id, attemptId, "intent", "intent", createdAt, {
+      deliveryRecord(request, this.id, attemptId, "intent", "intent", createdAt, {
         partCount: parts.length,
       }),
     );
@@ -704,7 +704,6 @@ export class TelegramDecisionChannel implements HumanDecisionChannel {
         );
         const confirmed = prior.some(
           (record) =>
-            record.schema === "pi-workflows.human-decision-delivery.v2" &&
             record.phase === "part" &&
             record.state === "confirmed" &&
             record.recipientIndex === recipientIndex &&
@@ -724,7 +723,7 @@ export class TelegramDecisionChannel implements HumanDecisionChannel {
           await this.store.recordDelivery(
             request,
             channelPath,
-            v2DeliveryRecord(
+            deliveryRecord(
               request,
               this.id,
               `${attemptId}-r${recipientIndex}-p${partIndex}-unknown`,
@@ -740,15 +739,12 @@ export class TelegramDecisionChannel implements HumanDecisionChannel {
         await this.store.recordDelivery(
           request,
           channelPath,
-          v2DeliveryRecord(
-            request,
-            this.id,
-            `${partAttemptId}-intent`,
-            "part",
-            "intent",
-            createdAt,
-            { recipientIndex, partIndex, partCount: parts.length, contentDigest },
-          ),
+          deliveryRecord(request, this.id, `${partAttemptId}-intent`, "part", "intent", createdAt, {
+            recipientIndex,
+            partIndex,
+            partCount: parts.length,
+            contentDigest,
+          }),
         );
         try {
           const result = await this.call("sendMessage", {
@@ -769,7 +765,7 @@ export class TelegramDecisionChannel implements HumanDecisionChannel {
           await this.store.recordDelivery(
             request,
             channelPath,
-            v2DeliveryRecord(
+            deliveryRecord(
               request,
               this.id,
               `${partAttemptId}-confirmed`,
@@ -785,7 +781,7 @@ export class TelegramDecisionChannel implements HumanDecisionChannel {
           await this.store.recordDelivery(
             request,
             channelPath,
-            v2DeliveryRecord(
+            deliveryRecord(
               request,
               this.id,
               `${partAttemptId}-${state}`,
@@ -804,7 +800,7 @@ export class TelegramDecisionChannel implements HumanDecisionChannel {
           await this.store.recordDelivery(
             request,
             channelPath,
-            v2DeliveryRecord(
+            deliveryRecord(
               request,
               this.id,
               `${attemptId}-${state}`,
@@ -821,7 +817,7 @@ export class TelegramDecisionChannel implements HumanDecisionChannel {
     await this.store.recordDelivery(
       request,
       channelPath,
-      v2DeliveryRecord(
+      deliveryRecord(
         request,
         this.id,
         `${attemptId}-confirmed`,
@@ -1234,29 +1230,26 @@ function parseCredentialConfig(value: unknown): DecisionCredentialConfig {
   return { schema: "pi-workflows.credentials.v1", telegram };
 }
 
-type DeliveryV2 = Extract<
-  HumanDecisionDeliveryRecord,
-  { schema: "pi-workflows.human-decision-delivery.v2" }
->;
+type DeliveryRecord = HumanDecisionDeliveryRecord;
 
-type DeliveryV2Extra = Partial<
+type DeliveryRecordExtra = Partial<
   Pick<
-    DeliveryV2,
+    DeliveryRecord,
     "recipientIndex" | "partIndex" | "partCount" | "contentDigest" | "messageCount" | "errorCode"
   >
 >;
 
-function v2DeliveryRecord(
+function deliveryRecord(
   request: HumanDecisionChannelRequest,
   channel: string,
   attemptId: string,
-  phase: DeliveryV2["phase"],
-  state: DeliveryV2["state"],
+  phase: DeliveryRecord["phase"],
+  state: DeliveryRecord["state"],
   createdAt: string,
-  extra: DeliveryV2Extra = {},
-): DeliveryV2 {
+  extra: DeliveryRecordExtra = {},
+): DeliveryRecord {
   return {
-    schema: "pi-workflows.human-decision-delivery.v2",
+    schema: "pi-workflows.human-decision-delivery.v1",
     attemptId,
     decisionId: request.decisionId,
     requestDigest: request.requestDigest,
@@ -1271,37 +1264,14 @@ function v2DeliveryRecord(
 }
 
 function isCompleteDelivery(record: HumanDecisionDeliveryRecord): boolean {
-  return (
-    record.state === "confirmed" &&
-    (record.schema === "pi-workflows.human-decision-delivery.v1" || record.phase === "complete")
-  );
+  return record.state === "confirmed" && record.phase === "complete";
 }
 
 function hasUnsettledDeliveryIntent(records: HumanDecisionDeliveryRecord[]): boolean {
-  const hasLegacyIntent = records.some(
-    (record) =>
-      record.schema === "pi-workflows.human-decision-delivery.v1" && record.state === "intent",
-  );
-  if (
-    hasLegacyIntent &&
-    !records.some(
-      (record) =>
-        record.schema === "pi-workflows.human-decision-delivery.v1" && record.state !== "intent",
-    )
-  ) {
-    return true;
-  }
   return records.some((record) => {
-    if (
-      record.schema !== "pi-workflows.human-decision-delivery.v2" ||
-      record.phase !== "part" ||
-      record.state !== "intent"
-    ) {
-      return false;
-    }
+    if (record.phase !== "part" || record.state !== "intent") return false;
     return !records.some(
       (other) =>
-        other.schema === "pi-workflows.human-decision-delivery.v2" &&
         other.phase === "part" &&
         other.state !== "intent" &&
         other.recipientIndex === record.recipientIndex &&