@emiliosp/pi-maestro 0.11.0 → 0.12.0

package/src/tools/main/run-simplifier.ts

@@ -4,14 +4,16 @@
  */
 
 import { randomUUID } from 'node:crypto';
+
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
 import type { SubagentDelegationRequest } from 'pi-subagents/delegation';
 import { Type } from 'typebox';
+
 import { readSimplifierHandoff } from '#artifacts/simplifier-handoff/readSimplifierHandoff.ts';
 import { AGENTS } from '#config/schema.ts';
 import { SPEC_ID_PATTERN } from '#ids/isValidSpecId.ts';
-import type { MaestroPaths } from '#MaestroPaths.ts';
 import { refreshMaestroStatus } from '#maestro/status/refreshMaestroStatus.ts';
+import type { MaestroPaths } from '#MaestroPaths.ts';
 import {
   assertDelegationResponse,
   waitForDelegationResponse,
@@ -44,16 +46,11 @@ type GitReadinessInput = {
   projectRoot: string;
 };
 
-const isGitReady = async ({
-  pi,
-  projectRoot,
-}: GitReadinessInput): Promise<boolean> => {
+const isGitReady = async ({ pi, projectRoot }: GitReadinessInput): Promise<boolean> => {
   try {
-    const result = await pi.exec(
-      'git',
-      ['rev-parse', '--is-inside-work-tree'],
-      { cwd: projectRoot },
-    );
+    const result = await pi.exec('git', ['rev-parse', '--is-inside-work-tree'], {
+      cwd: projectRoot,
+    });
 
     return result.code === 0 && result.stdout.trim() === 'true';
   } catch {
@@ -66,17 +63,12 @@ type ReadSimplifierResultInput = {
   specId: string;
 };
 
-const readSimplifierResult = async ({
-  paths,
-  specId,
-}: ReadSimplifierResultInput) => {
+const readSimplifierResult = async ({ paths, specId }: ReadSimplifierResultInput) => {
   try {
     const state = await readWorkflowState(paths.getWorkflowPath(specId));
 
     if (state.specId !== specId) {
-      throw new Error(
-        `Workflow spec ID mismatch: expected "${specId}", found "${state.specId}".`,
-      );
+      throw new Error(`Workflow spec ID mismatch: expected "${specId}", found "${state.specId}".`);
     }
 
     if (state.phase !== WORKFLOW_PHASES.CANDIDATE_READY) {
@@ -105,9 +97,7 @@ export const registerRunSimplifierTool = (pi: ExtensionAPI): void => {
     description: RUN_SIMPLIFIER_TOOL.DESCRIPTION,
     parameters: RunSimplifierToolParameters,
     async execute(toolCallId, { specId }, _signal, _onUpdate, context) {
-      const { paths, config, projectRoot } = await resolveToolRunContext(
-        context.cwd,
-      );
+      const { paths, config, projectRoot } = await resolveToolRunContext(context.cwd);
 
       const workflowPath = paths.getWorkflowPath(specId);
       const state = await readWorkflowState(workflowPath);

package/src/tools/main/run-verifier.ts

@@ -4,15 +4,17 @@
  */
 
 import { randomUUID } from 'node:crypto';
+
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
 import type { SubagentDelegationRequest } from 'pi-subagents/delegation';
 import { Type } from 'typebox';
+
 import { readVerifierHandoff } from '#artifacts/verifier-handoff/readVerifierHandoff.ts';
 import type { VerifierHandoff } from '#artifacts/verifier-handoff/schema.ts';
 import { AGENTS } from '#config/schema.ts';
 import { SPEC_ID_PATTERN } from '#ids/isValidSpecId.ts';
-import type { MaestroPaths } from '#MaestroPaths.ts';
 import { refreshMaestroStatus } from '#maestro/status/refreshMaestroStatus.ts';
+import type { MaestroPaths } from '#MaestroPaths.ts';
 import {
   assertDelegationResponse,
   waitForDelegationResponse,
@@ -20,7 +22,7 @@ import {
 import { resolveToolRunContext } from '#tools/utils/resolveToolRunContext.ts';
 import { WORKFLOW_ROLES } from '#workflow/roles.ts';
 import { readWorkflowState } from '#workflow/state/readWorkflowState.ts';
-import { WORKFLOW_PHASES, type WorkflowState } from '#workflow/state/schema.ts';
+import { WORKFLOW_PHASES } from '#workflow/state/schema.ts';
 import { prepareVerifierRun } from '#workflow/verifier/prepareVerifierRun.ts';
 
 export const RUN_VERIFIER_TOOL = {
@@ -50,50 +52,6 @@ type VerifierRunResult = {
   handoff: VerifierHandoff;
 };
 
-type ReadTerminalVerifierResultInput = {
-  paths: MaestroPaths;
-  specId: string;
-  state: WorkflowState;
-};
-
-const readTerminalVerifierResult = async ({
-  paths,
-  specId,
-  state,
-}: ReadTerminalVerifierResultInput): Promise<VerifierRunResult> => {
-  if (
-    state.phase !== WORKFLOW_PHASES.SIMPLIFIER_RUNNING &&
-    state.phase !== WORKFLOW_PHASES.FINDING_DECISIONS
-  ) {
-    throw new Error(
-      `Verifier returned with unexpected workflow phase "${state.phase}".`,
-    );
-  }
-
-  const handoff = await readVerifierHandoff({
-    path: await paths.getActiveVerifierHandoffPath(specId),
-    specId,
-  });
-
-  const expectedPhase =
-    handoff.findings.length > 0
-      ? WORKFLOW_PHASES.FINDING_DECISIONS
-      : WORKFLOW_PHASES.SIMPLIFIER_RUNNING;
-
-  if (state.phase !== expectedPhase) {
-    throw new Error(
-      `Verifier handoff findings do not match workflow phase "${state.phase}".`,
-    );
-  }
-
-  return {
-    specId,
-    handoff,
-    outcome: state.phase,
-    phase: state.phase,
-  };
-};
-
 type ReadVerifierResultInput = {
   paths: MaestroPaths;
   specId: string;
@@ -107,22 +65,40 @@ const readVerifierResult = async ({
     const state = await readWorkflowState(paths.getWorkflowPath(specId));
 
     if (state.specId !== specId) {
-      throw new Error(
-        `Workflow spec ID mismatch: expected "${specId}", found "${state.specId}".`,
-      );
+      throw new Error(`Workflow spec ID mismatch: expected "${specId}", found "${state.specId}".`);
     }
 
     if (state.phase === WORKFLOW_PHASES.VERIFIER_RUNNING) {
-      throw new Error(
-        'The verifier returned without recording a valid terminal handoff.',
-      );
+      throw new Error('The verifier returned without recording a valid terminal handoff.');
     }
 
-    return await readTerminalVerifierResult({
-      paths,
+    if (
+      state.phase !== WORKFLOW_PHASES.SIMPLIFIER_RUNNING &&
+      state.phase !== WORKFLOW_PHASES.FINDING_DECISIONS
+    ) {
+      throw new Error(`Verifier returned with unexpected workflow phase "${state.phase}".`);
+    }
+
+    const handoff = await readVerifierHandoff({
+      path: await paths.getActiveVerifierHandoffPath(specId),
       specId,
-      state,
     });
+
+    const expectedPhase =
+      handoff.findings.length > 0
+        ? WORKFLOW_PHASES.FINDING_DECISIONS
+        : WORKFLOW_PHASES.SIMPLIFIER_RUNNING;
+
+    if (state.phase !== expectedPhase) {
+      throw new Error(`Verifier handoff findings do not match workflow phase "${state.phase}".`);
+    }
+
+    return {
+      specId,
+      handoff,
+      outcome: state.phase,
+      phase: state.phase,
+    };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
 

package/src/tools/utils/pi-subagent-delegation.ts

@@ -50,8 +50,7 @@ export const matchesDelegationRequest = ({
 
   return (
     response.requestId === request.requestId &&
-    (response.ownerRunId === undefined ||
-      response.ownerRunId === request.ownerRunId) &&
+    (response.ownerRunId === undefined || response.ownerRunId === request.ownerRunId) &&
     (response.nodeId === undefined || response.nodeId === request.nodeId)
   );
 };
@@ -65,20 +64,16 @@ export const waitForDelegationResponse = async ({
   piEventsBus,
   request,
 }: WaitForDelegationResponseInput): Promise<SubagentDelegationResponse> => {
-  const { promise, resolve } =
-    Promise.withResolvers<SubagentDelegationResponse>();
-
-  const unsubscribe = piEventsBus.on(
-    SUBAGENT_DELEGATION_RESPONSE_EVENT,
-    (payload) => {
-      if (!matchesDelegationRequest({ request, payload })) {
-        return;
-      }
-
-      // JUSTIFICATION: matchesDelegationRequest accepts only the response for this pi-subagents request.
-      resolve(payload as SubagentDelegationResponse);
-    },
-  );
+  const { promise, resolve } = Promise.withResolvers<SubagentDelegationResponse>();
+
+  const unsubscribe = piEventsBus.on(SUBAGENT_DELEGATION_RESPONSE_EVENT, (payload) => {
+    if (!matchesDelegationRequest({ request, payload })) {
+      return;
+    }
+
+    // JUSTIFICATION: matchesDelegationRequest accepts only the response for this pi-subagents request.
+    resolve(payload as SubagentDelegationResponse);
+  });
 
   try {
     try {
@@ -97,9 +92,7 @@ export const waitForDelegationResponse = async ({
   }
 };
 
-export function assertDelegationResponse(
-  response: SubagentDelegationResponse,
-): void {
+export function assertDelegationResponse(response: SubagentDelegationResponse): void {
   if (response.status === DELEGATION_STATUSES.COMPLETED) {
     return;
   }
@@ -121,7 +114,5 @@ export function assertDelegationResponse(
     throw new Error(`Delegation error: ${error}`);
   }
 
-  throw new Error(
-    `Protocol error: unsupported final response status "${response.status}".`,
-  );
+  throw new Error(`Protocol error: unsupported final response status "${response.status}".`);
 }

package/src/tools/utils/resolveToolRunContext.ts

@@ -4,6 +4,7 @@
  */
 
 import { realpath } from 'node:fs/promises';
+
 import { loadConfiguration } from '#config/loadConfiguration.ts';
 import type { MaestroConfig } from '#config/schema.ts';
 import { MaestroPaths } from '#MaestroPaths.ts';
@@ -14,9 +15,7 @@ export type ToolRunContext = {
   paths: MaestroPaths;
 };
 
-export const resolveToolRunContext = async (
-  cwd: string,
-): Promise<ToolRunContext> => {
+export const resolveToolRunContext = async (cwd: string): Promise<ToolRunContext> => {
   const projectRoot = await realpath(cwd);
   const config = await loadConfiguration(projectRoot);
 

package/src/utils/is-errno-exception.ts

@@ -3,7 +3,5 @@
  * Used: When filesystem operations handle specific error codes.
  */
 
-export const isErrnoException = (
-  error: unknown,
-): error is NodeJS.ErrnoException =>
+export const isErrnoException = (error: unknown): error is NodeJS.ErrnoException =>
   error instanceof Error && 'code' in error && typeof error.code === 'string';

package/src/utils/path-exists.ts

@@ -4,6 +4,7 @@
  */
 
 import { access } from 'node:fs/promises';
+
 import { isErrnoException } from '#utils/is-errno-exception.ts';
 
 export const pathExists = async (path: string): Promise<boolean> => {

package/src/utils/path-strictly-within.ts

@@ -4,6 +4,7 @@
  */
 
 import { relative } from 'node:path';
+
 import { isPathWithinOrEqual } from '#utils/path-within-or-equal.ts';
 
 type IsPathStrictlyWithinInput = {
@@ -11,9 +12,5 @@ type IsPathStrictlyWithinInput = {
   path: string;
 };
 
-export const isPathStrictlyWithin = ({
-  parent,
-  path,
-}: IsPathStrictlyWithinInput): boolean =>
-  relative(parent, path) !== '' &&
-  isPathWithinOrEqual({ parent, candidate: path });
+export const isPathStrictlyWithin = ({ parent, path }: IsPathStrictlyWithinInput): boolean =>
+  relative(parent, path) !== '' && isPathWithinOrEqual({ parent, candidate: path });

package/src/utils/path-within-or-equal.ts

@@ -10,10 +10,7 @@ type IsPathWithinOrEqualInput = {
   candidate: string;
 };
 
-export const isPathWithinOrEqual = ({
-  parent,
-  candidate,
-}: IsPathWithinOrEqualInput): boolean => {
+export const isPathWithinOrEqual = ({ parent, candidate }: IsPathWithinOrEqualInput): boolean => {
   const pathToCandidate = relative(parent, candidate);
 
   return (

package/src/utils/read-json.ts

@@ -10,10 +10,7 @@ type ReadJsonFileInput = {
   description: string;
 };
 
-export const readJsonFile = async ({
-  path,
-  description,
-}: ReadJsonFileInput): Promise<unknown> => {
+export const readJsonFile = async ({ path, description }: ReadJsonFileInput): Promise<unknown> => {
   const content = await readFile(path, 'utf8');
 
   try {

package/src/utils/write-json.ts

@@ -10,10 +10,7 @@ type WriteJsonInput = {
   data: unknown;
 };
 
-export const writeJson = async ({
-  path,
-  data,
-}: WriteJsonInput): Promise<void> => {
+export const writeJson = async ({ path, data }: WriteJsonInput): Promise<void> => {
   const content = JSON.stringify(data, null, 2);
 
   if (content === undefined) {

package/src/workflow/builder/completeBuilderPass.ts

@@ -4,7 +4,9 @@
  */
 
 import { mkdir, readFile } from 'node:fs/promises';
+
 import { Value } from 'typebox/value';
+
 import { assertBuilderHandoff } from '#artifacts/builder-handoff/assertBuilderHandoff.ts';
 import {
   BUILDER_HANDOFF_VERSION,
@@ -33,8 +35,7 @@ function assertBuilderHandoffSubmission(
 ): asserts input is BuilderHandoffSubmissionInput {
   const [error] = Value.Errors(BuilderHandoffSubmissionSchema, input);
 
-  if (error !== undefined)
-    throw new Error(`Invalid builder submission: ${error.message}.`);
+  if (error !== undefined) throw new Error(`Invalid builder submission: ${error.message}.`);
 }
 
 type CompleteBuilderPassInput = {

package/src/workflow/builder/prepareBuilderRun.ts

@@ -3,8 +3,8 @@
  * Used: Before Maestro runs a builder pass.
  */
 
-import type { MaestroPaths } from '#MaestroPaths.ts';
 import maestroSessionState from '#maestro/session/MaestroSessionState.ts';
+import type { MaestroPaths } from '#MaestroPaths.ts';
 import { pathExists } from '#utils/path-exists.ts';
 import { readWorkflowState } from '#workflow/state/readWorkflowState.ts';
 import { WORKFLOW_EVENTS, WORKFLOW_PHASES } from '#workflow/state/schema.ts';
@@ -21,16 +21,11 @@ type AssertBuilderRunBaseInput = {
   specId: string;
 };
 
-async function assertBuilderRunBase({
-  paths,
-  specId,
-}: AssertBuilderRunBaseInput): Promise<void> {
+async function assertBuilderRunBase({ paths, specId }: AssertBuilderRunBaseInput): Promise<void> {
   const state = await readWorkflowState(paths.getWorkflowPath(specId));
 
   if (state.specId !== specId) {
-    throw new Error(
-      `Workflow spec ID mismatch: expected "${specId}", found "${state.specId}".`,
-    );
+    throw new Error(`Workflow spec ID mismatch: expected "${specId}", found "${state.specId}".`);
   }
 
   if (state.phase !== WORKFLOW_PHASES.READY_FOR_BUILDER) {

package/src/workflow/builder/resolveEscalations.ts

@@ -26,16 +26,12 @@ type ApplyEscalationDecisionsInput = {
   decisions: EscalationDecision[];
 };
 
-const applyEscalationDecisions = ({
-  escalations,
-  decisions,
-}: ApplyEscalationDecisionsInput) => {
+const applyEscalationDecisions = ({ escalations, decisions }: ApplyEscalationDecisionsInput) => {
   if (escalations.some(({ resolution }) => resolution !== null)) {
     throw new Error('Current questions already contain an owner resolution.');
   }
 
-  if (decisions.length === 0)
-    throw new Error('At least one escalation decision is required.');
+  if (decisions.length === 0) throw new Error('At least one escalation decision is required.');
 
   const expectedIds = new Set(escalations.map(({ id }) => id));
   const resolutions = new Map<string, EscalationResolution>();

package/src/workflow/builder/utils/getWorkflowEventByBuilderHandoff.ts

@@ -9,9 +9,7 @@ import {
 } from '#artifacts/builder-handoff/schema.ts';
 import { WORKFLOW_EVENTS, type WorkflowEvent } from '#workflow/state/schema.ts';
 
-export const getWorkflowEventByBuilderHandoff = ({
-  status,
-}: BuilderHandoff): WorkflowEvent => {
+export const getWorkflowEventByBuilderHandoff = ({ status }: BuilderHandoff): WorkflowEvent => {
   if (status === BUILDER_HANDOFF_STATUSES.DONE) {
     return WORKFLOW_EVENTS.BUILDER_DONE;
   }

package/src/workflow/simplifier/completeSimplifierPass.ts

@@ -5,6 +5,7 @@
 
 import { mkdir } from 'node:fs/promises';
 import { dirname } from 'node:path';
+
 import { assertSimplifierHandoff } from '#artifacts/simplifier-handoff/assertSimplifierHandoff.ts';
 import type { MaestroPaths } from '#MaestroPaths.ts';
 import { writeJson } from '#utils/write-json.ts';
@@ -28,9 +29,7 @@ export const completeSimplifierPass = async ({
   const state = await readWorkflowState(workflowPath);
 
   if (state.specId !== specId) {
-    throw new Error(
-      `Workflow spec ID mismatch: expected "${specId}", found "${state.specId}".`,
-    );
+    throw new Error(`Workflow spec ID mismatch: expected "${specId}", found "${state.specId}".`);
   }
 
   if (state.phase !== WORKFLOW_PHASES.SIMPLIFIER_RUNNING) {

package/src/workflow/spec/markSpecReady.ts

@@ -4,6 +4,7 @@
  */
 
 import { readFile } from 'node:fs/promises';
+
 import type { MaestroPaths } from '#MaestroPaths.ts';
 import { pathExists } from '#utils/path-exists.ts';
 import { readWorkflowState } from '#workflow/state/readWorkflowState.ts';
@@ -12,7 +13,8 @@ import { writeWorkflowState } from '#workflow/state/writeWorkflowState.ts';
 import { transitionWorkflow } from '#workflow/transitions.ts';
 
 function assertAcceptanceCriterionOrdering(markdown: string): void {
-  const criteria = [...markdown.matchAll(/^### AC(\d+):/gm)];
+  // Match standalone ACs (###), including regression checks, and ACs nested under requirements (####).
+  const criteria = [...markdown.matchAll(/^#{3,4} AC(\d+):/gm)];
 
   if (criteria.some((match, index) => Number(match[1]) !== index + 1)) {
     throw new Error('Fix acceptance criterion ordering in spec.md.');
@@ -46,13 +48,17 @@ export const markSpecReady = async ({
     throw new Error(`Spec file is missing: ${specFilePath}.`);
   }
 
+  const proposalFilePath = paths.getProposalFilePath(specId);
+
+  if (!(await pathExists(proposalFilePath))) {
+    throw new Error(`Proposal file is missing: ${proposalFilePath}.`);
+  }
+
   const workflowPath = paths.getWorkflowPath(specId);
   const current = await readWorkflowState(workflowPath);
 
   if (current.specId !== specId) {
-    throw new Error(
-      `Workflow spec ID mismatch: expected "${specId}", found "${current.specId}".`,
-    );
+    throw new Error(`Workflow spec ID mismatch: expected "${specId}", found "${current.specId}".`);
   }
 
   const state = transitionWorkflow({

package/src/workflow/state/readWorkflowState.ts

@@ -4,14 +4,9 @@
  */
 
 import { readJsonFile } from '#utils/read-json.ts';
-import {
-  assertWorkflowState,
-  type WorkflowState,
-} from '#workflow/state/schema.ts';
+import { assertWorkflowState, type WorkflowState } from '#workflow/state/schema.ts';
 
-export const readWorkflowState = async (
-  path: string,
-): Promise<WorkflowState> => {
+export const readWorkflowState = async (path: string): Promise<WorkflowState> => {
   const state = await readJsonFile({ path, description: 'Workflow state' });
   assertWorkflowState(state);
 

package/src/workflow/state/schema.ts

@@ -5,6 +5,7 @@
 
 import { type Static, Type } from 'typebox';
 import { Value } from 'typebox/value';
+
 import { isValidSpecId, SPEC_ID_PATTERN } from '#ids/isValidSpecId.ts';
 
 export const WORKFLOW_STATE_VERSION = '1.0.0';
@@ -58,17 +59,13 @@ export const WorkflowStateSchema = Type.Object(
   { additionalProperties: false },
 );
 
-export type WorkflowPhase =
-  (typeof WORKFLOW_PHASES)[keyof typeof WORKFLOW_PHASES];
+export type WorkflowPhase = (typeof WORKFLOW_PHASES)[keyof typeof WORKFLOW_PHASES];
 
-export type WorkflowEvent =
-  (typeof WORKFLOW_EVENTS)[keyof typeof WORKFLOW_EVENTS];
+export type WorkflowEvent = (typeof WORKFLOW_EVENTS)[keyof typeof WORKFLOW_EVENTS];
 
 export type WorkflowState = Static<typeof WorkflowStateSchema>;
 
-function assertWorkflowStateSchema(
-  input: unknown,
-): asserts input is WorkflowState {
+function assertWorkflowStateSchema(input: unknown): asserts input is WorkflowState {
   if (typeof input !== 'object' || input === null || Array.isArray(input)) {
     throw new Error('Workflow state must be a JSON object.');
   }
@@ -80,9 +77,7 @@ function assertWorkflowStateSchema(
   }
 }
 
-export function assertWorkflowState(
-  input: unknown,
-): asserts input is WorkflowState {
+export function assertWorkflowState(input: unknown): asserts input is WorkflowState {
   assertWorkflowStateSchema(input);
 
   if (!isValidSpecId(input.specId)) {

package/src/workflow/state/writeWorkflowState.ts

@@ -4,10 +4,7 @@
  */
 
 import { writeJson } from '#utils/write-json.ts';
-import {
-  assertWorkflowState,
-  type WorkflowState,
-} from '#workflow/state/schema.ts';
+import { assertWorkflowState, type WorkflowState } from '#workflow/state/schema.ts';
 
 type WriteWorkflowStateInput = {
   path: string;

package/src/workflow/transitions.ts

@@ -35,10 +35,7 @@ export const WORKFLOW_TRANSITIONS: Record<WorkflowEvent, WorkflowTransition> = {
     to: WORKFLOW_PHASES.READY_FOR_BUILDER,
   },
   [WORKFLOW_EVENTS.OWNER_REQUEST_SPEC_REVISION]: {
-    from: [
-      WORKFLOW_PHASES.ESCALATION_DECISIONS,
-      WORKFLOW_PHASES.FINDING_DECISIONS,
-    ],
+    from: [WORKFLOW_PHASES.ESCALATION_DECISIONS, WORKFLOW_PHASES.FINDING_DECISIONS],
     to: WORKFLOW_PHASES.DRAFTING_SPEC,
   },
   [WORKFLOW_EVENTS.BUILDER_DONE]: {
@@ -80,10 +77,7 @@ type TransitionWorkflowInput = {
   event: WorkflowEvent;
 };
 
-export const transitionWorkflow = ({
-  state,
-  event,
-}: TransitionWorkflowInput): WorkflowState => {
+export const transitionWorkflow = ({ state, event }: TransitionWorkflowInput): WorkflowState => {
   assertWorkflowState(state);
   const transition = WORKFLOW_TRANSITIONS[event];
 
@@ -92,9 +86,7 @@ export const transitionWorkflow = ({
   }
 
   if (!transition.from.includes(state.phase)) {
-    throw new Error(
-      `Workflow event "${event}" is not allowed from phase "${state.phase}".`,
-    );
+    throw new Error(`Workflow event "${event}" is not allowed from phase "${state.phase}".`);
   }
 
   return {

package/src/workflow/utils/assertSpecAcceptanceCriteria.ts

@@ -12,7 +12,8 @@ export function assertSpecAcceptanceCriteria({
   markdown,
   criterionIds,
 }: AssertSpecAcceptanceCriteriaInput): void {
-  const missingIds = [...markdown.matchAll(/^### AC(\d+):/gm)]
+  // Match standalone ACs (###), including regression checks, and ACs nested under requirements (####).
+  const missingIds = [...markdown.matchAll(/^#{3,4} AC(\d+):/gm)]
     .map((match) => `AC${match[1]}`)
     .filter((id) => !criterionIds.has(id));
 

package/src/workflow/utils/getAgentRole.ts

@@ -18,9 +18,7 @@ const VERIFIER_PHASES: readonly WorkflowState['phase'][] = [
   WORKFLOW_PHASES.FINDING_DECISIONS,
 ];
 
-export const getAgentRole = (
-  phase: WorkflowState['phase'],
-): WorkflowRole | null => {
+export const getAgentRole = (phase: WorkflowState['phase']): WorkflowRole | null => {
   if (BUILDER_PHASES.includes(phase)) {
     return WORKFLOW_ROLES.BUILDER;
   }

package/src/workflow/verifier/completeVerifierPass.ts

@@ -4,6 +4,7 @@
  */
 
 import { mkdir, readFile } from 'node:fs/promises';
+
 import { assertVerifierHandoff } from '#artifacts/verifier-handoff/assertVerifierHandoff.ts';
 import type { VerifierHandoff } from '#artifacts/verifier-handoff/schema.ts';
 import { writeVerifierHandoff } from '#artifacts/verifier-handoff/writeVerifierHandoff.ts';