@akagilnc/pi-workflow-roles 0.1.4528 → 0.1.4620

package/src/reviewer-role.ts

@@ -13,7 +13,6 @@ export type { ReviewerIntent };
 /** Frozen admitted inputs the behavior layer may consume — no flag surface. */
 export type ReviewerAdmittedInputs = Readonly<{
   baseRevision: string;
-  /** Caller-selected single lens; required, no default. */
   lens: "completeness" | "correctness";
   authorityRefs?: readonly string[];
   /** Typed #176 ticketNumber from admitted invocation (Spec self-fetch primary). */
@@ -32,7 +31,7 @@ const reviewerAmendmentsSchema = Type.Object({
 }, {
   additionalProperties: true,
   description:
-    "所选 lens 的 amendments 承载 candidates、逐条处置与 verdict 的完整报告（非仅 verdict 行）；未选 lens 可省略。hard-stop／usage error 为 refused 时，已产出报告仍照录进所选 lens 字段。形状指引，非 schema 闸。",
+    "已运行 lens 的 amendments 承载 candidates、逐条处置与 verdict 的完整报告（非仅 verdict 行）；显式单轴时另一轴可省略。hard-stop／usage error 为 refused 时，已产出报告仍照录对应 lens 字段。形状指引，非 schema 闸。",
 });
 // #836 r16 class 1: diagnostic is LLM/human-read narrative content — no code
 // branches on its length (src/reviewer-role.ts consumer: reviewer content is

package/src/role-envelope.ts

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { mkdir, writeFile } from "node:fs/promises";
+import { appendFile, mkdir, writeFile } from "node:fs/promises";
 import { createServer, type Server, type Socket } from "node:net";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -115,7 +115,11 @@ export async function prepareRoleEnvelope(options: {
   await mkdir(request.runDirectory, { recursive: true });
 
   // Durable principal file for isAvailable / resumable settlement (public-cli).
-  // #617 DK-4: header layout only — never host conversation/tool writeback into Pi JSONL.
+  // #617 DK-4: never host conversation/tool writeback into Pi JSONL.
+  // #959: package-owned custom entries (invocation marker, submission-closure,
+  // navigator attendance, no-receipt) MUST flush so parent settlement can read
+  // them after the headless process ends — memory-only books left extractNavigatorFact
+  // with no durable terminal / attendance on codex/claude/ACP parents.
   let sessionFile = options.sessionFile ?? join(request.runDirectory, "session", "session.jsonl");
   await mkdir(dirname(sessionFile), { recursive: true });
   if (request.continuation.kind !== "resume") {
@@ -135,6 +139,31 @@ export async function prepareRoleEnvelope(options: {
       if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
     }
   }
+  // Settlement reads the durable file after the turn; write must complete before
+  // closeRound returns. Sync-order via chained promise kept on the envelope.
+  // Chain itself never rejects (closeRound/dispose stay orderly). Required package
+  // entry flush failure arms the existing typed infrastructure-failure slot —
+  // never log-and-continue into accepted (#959 失败诚实).
+  let durableWriteChain: Promise<void> = Promise.resolve();
+  /** Filled by rememberInfrastructureFailure; declared later, closed over here. */
+  let armDurableWriteFailure: ((customType: string, diagnostic: string) => void) | undefined;
+  /** Append one package-owned session entry to the durable principal (fire-and-order). */
+  const persistPackageSessionEntry = (entry: Record<string, unknown>): void => {
+    const customType = typeof entry.customType === "string" ? entry.customType : "unknown";
+    const line = `${JSON.stringify({
+      ...entry,
+      id: typeof entry.id === "string" ? entry.id : randomUUID(),
+      timestamp: typeof entry.timestamp === "string" ? entry.timestamp : new Date().toISOString(),
+    })}\n`;
+    durableWriteChain = durableWriteChain.then(async () => {
+      try {
+        await appendFile(sessionFile, line, "utf8");
+      } catch (error) {
+        const diagnostic = error instanceof Error ? error.message : String(error);
+        armDurableWriteFailure?.(customType, diagnostic);
+      }
+    });
+  };
   const context: HostContext = {
     cwd: request.cwd,
     mode: "print",
@@ -155,6 +184,7 @@ export async function prepareRoleEnvelope(options: {
         const entry = { type: "custom", customType, data };
         sessionEntries.push(entry);
         customEntries.push({ customType, data });
+        persistPackageSessionEntry(entry);
       },
     },
     abort() {
@@ -170,6 +200,7 @@ export async function prepareRoleEnvelope(options: {
     const entry = { type: "custom_message", customType, ...payload, message: payload };
     sessionEntries.push(entry);
     customEntries.push({ customType, data: message.details ?? message.content });
+    persistPackageSessionEntry(entry);
   };
 
   const emit = async (event: string, value: unknown): Promise<unknown[]> => {
@@ -304,6 +335,17 @@ export async function prepareRoleEnvelope(options: {
     };
     hostAbort.abort();
   }
+  armDurableWriteFailure = (customType, diagnostic) => {
+    rememberInfrastructureFailure(
+      {
+        cause: "infrastructure",
+        kind: "role_infrastructure_failure",
+        code: "durable-session-write-failed",
+        customType,
+      },
+      [{ type: "text", text: `ak-role: durable session entry flush failed (${customType}): ${diagnostic}` }],
+    );
+  };
   /**
    * One non-correctable infra pathway for execute throws and pre-execution emits:
    * build fact → fill closeRound slot → arm hostAbort. Projection may follow.
@@ -500,15 +542,50 @@ export async function prepareRoleEnvelope(options: {
   let disposed = false;
   // Per-turn run/court identity lives on HostContext (request-scoped). Engine
   // axis is already a RoleHost flag — never process.env (#818 P1 / #879).
+
+  /** True once closeRound returned an infrastructure failure to the host. */
+  let durableFailureHandedToCloseRound = false;
+  /** Drain required package-owned writes; infrastructure outranks every close outcome. */
+  const settleDurableWrites = async (): Promise<
+    | { readonly accepted: false; readonly failure: RoleTurnKnownFailure }
+    | undefined
+  > => {
+    await durableWriteChain;
+    if (infrastructureRoundFailure !== undefined) {
+      durableFailureHandedToCloseRound = true;
+      return { accepted: false as const, failure: infrastructureRoundFailure };
+    }
+    return undefined;
+  };
+
   const dispose = async (): Promise<void> => {
     if (disposed) return;
     disposed = true;
     const cleanupFailures: unknown[] = [];
+    // session_shutdown may still append package durable entries (navigator
+    // attendance when agent_settled was skipped). Drain only after those
+    // handlers — single terminal judgment via settleDurableWrites (#959).
     try {
       await emit("session_shutdown", {});
     } catch (error) {
       cleanupFailures.push(error);
     }
+    try {
+      // Always drain post-shutdown writes. Only throw when the host has not
+      // already received this infrastructure failure via closeRound.
+      const alreadyHanded = durableFailureHandedToCloseRound;
+      const durableFailure = await settleDurableWrites();
+      if (durableFailure !== undefined && !alreadyHanded) {
+        cleanupFailures.push(
+          Object.assign(
+            new Error(durableFailure.failure.diagnostic ?? "durable session entry flush failed"),
+            { code: durableFailure.failure.identity?.code ?? "durable-session-write-failed" },
+          ),
+        );
+      }
+    } catch (error) {
+      cleanupFailures.push(error);
+    }
     try {
       const closeAll = (server as unknown as { closeAllConnections?: () => void }).closeAllConnections;
       if (typeof closeAll === "function") closeAll.call(server);
@@ -532,8 +609,7 @@ export async function prepareRoleEnvelope(options: {
     // duplicate so structured_output + tool-call does not arm non-sole.
     if (calls.some((call) => call.toolName === terminatingToolName)) return;
     await invokeAkTool(terminatingToolName, params ?? {});
-  }
-
+  };
   const closeRound: PreparedRoleTurn["closeRound"] = async () => {
     // Typed round boundary: hand the complete call list to the shared ledger once.
     if (calls.length > 0) {
@@ -543,6 +619,7 @@ export async function prepareRoleEnvelope(options: {
     }
     // Infrastructure failure outranks accepted closure / correctable retry (#593).
     if (infrastructureRoundFailure !== undefined) {
+      durableFailureHandedToCloseRound = true;
       return { accepted: false as const, failure: infrastructureRoundFailure };
     }
     let closure: { customType: string; data: unknown } | undefined;
@@ -553,6 +630,8 @@ export async function prepareRoleEnvelope(options: {
       // Pi flushes navigator attendance on agent_settled; session/prompt
       // resolution is the ACP host equivalent round boundary.
       await emit("agent_settled", {});
+      const durableFailure = await settleDurableWrites();
+      if (durableFailure !== undefined) return durableFailure;
       return { accepted: true as const };
     }
     if (rejection !== undefined) {
@@ -562,11 +641,17 @@ export async function prepareRoleEnvelope(options: {
         message: rejection.message,
       };
       rejection = undefined;
+      // Drain write chain before retry: a package-owned append may still fail after
+      // the correctable rejection was booked; infrastructure outranks retry.
+      const durableFailure = await settleDurableWrites();
+      if (durableFailure !== undefined) return durableFailure;
       return { accepted: false as const, retry };
     }
     // #836: host ended without a recorded submission is not a failure.
     // Settlement presents ledger contents; empty ledger → no_receipt.
     await emit("agent_settled", {});
+    const durableFailure = await settleDurableWrites();
+    if (durableFailure !== undefined) return durableFailure;
     return { accepted: true as const };
   };
 

package/src/role-runtime.ts

@@ -1,3 +1,4 @@
+import { randomUUID } from "node:crypto";
 import { readFileSync, writeSync } from "node:fs";
 import { join } from "node:path";
 import {
@@ -12,7 +13,7 @@ import {
 
 import { Value } from "typebox/value";
 import { sitianReport } from "./sitian-facade.ts";
-import { createSubmissionLedgerHost } from "./submission-ledger.ts";
+import { createSubmissionLedgerHost, sealAcceptedSubmission } from "./submission-ledger.ts";
 import { createCollectorLedger } from "./collector-ledger.ts";
 
 import { activationTraceRecordSchema, namedActivationCause, type ActivationTraceRecord, type ActivationTraceWriter } from "./activation-trace.ts";
@@ -156,7 +157,7 @@ const REVIEWER_TRANSPORT_FLAGS = Object.freeze([
   Object.freeze({
     name: "ak-review-lens",
     definition: Object.freeze({
-      description: "Caller-selected single review lens: completeness or correctness",
+      description: "Single review lens: completeness or correctness",
       type: "string" as const,
     }),
   }),
@@ -441,7 +442,7 @@ type ActivationRuntime = {
   };
   /** Envelope decodes Reviewer transport flags inside the activation stage. */
   decodeReviewerAdmitted(): ReviewerAdmittedInputs;
-  /** Envelope stores live parent activation for agent_start prompt assembly. */
+  /** Envelope stores live Reviewer activation for agent_start prompt assembly. */
   bindReviewerParent(activation: ReviewerActivation): void;
   collector: {
     activate(context: HostContext, event: { reason: string }): Promise<void>;
@@ -1225,6 +1226,28 @@ export function createCountersignRoleRuntime(
   );
 }
 
+/**
+ * #959: last assistant text parts as navigator prose exit.
+ * Tool-call-only messages yield undefined — those already ride the tool path.
+ */
+function lastAssistantProse(
+  messages: readonly { role: string; content?: readonly { type: string; text?: string }[] }[],
+): string | undefined {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (message?.role !== "assistant" || !Array.isArray(message.content)) continue;
+    const texts: string[] = [];
+    for (const part of message.content) {
+      if (part.type === "text" && typeof part.text === "string" && part.text.length > 0) {
+        texts.push(part.text);
+      }
+    }
+    if (texts.length === 0) continue;
+    return texts.join("");
+  }
+  return undefined;
+}
+
 export function createRoleRuntimeExtension(
   dependencies: RoleRuntimeDependencies,
 ): (envelopeHost: RoleEnvelopeHost) => void {
@@ -1299,10 +1322,9 @@ export function createRoleRuntimeExtension(
       if (settlement === undefined || attendance === undefined) return;
       const workContext = navigatorWorkContext;
       const pending = (async () => {
-        if (settlement.kind !== "accepted") {
-          await attendance.settle(settlement);
-          return;
-        }
+        // ADR 0052 / #959: every settlement that starts a post-role feed host round
+        // (accepted, human_decision, role_infrastructure_failure) shares one grace
+        // and the same honest unavailable projection — no unbounded parallel branch.
         const settlePromise = attendance.settle(settlement);
         // Attach catch immediately so a late rejection after grace timeout cannot
         // surface as unhandledRejection / stale-ctx after session dispose (#675).
@@ -1557,18 +1579,12 @@ export function createRoleRuntimeExtension(
         pendingSubmissionNonPassByToolCallId.delete(event.toolCallId);
         return { details: submissionNonPass, isError: true };
       }
-      // Recommendation rides the accepted settlement record's content so the one
-      // mandatory last-ak_*_output extraction surfaces route/next/reason without
-      // a second file, grep, or nesting step. Receipt details stay contract-pure;
-      // unavailable/no-advice leave the settlement untouched.
-      if (event.isError) return;
-      return;
     });
     // Queue receipt delivery before `agent_settled`: that event means Pi has
     // already decided no queued continuation will run, so a triggerTurn there is
     // too late for print/json sessions. `agent_end` is the last production seam
     // whose queued next turn is consumed before settlement.
-    roleHost.on("agent_end", (event, ctx) => {
+    roleHost.on("agent_end", async (event, ctx) => {
       const lastMessage = event.messages.at(-1);
       if (lastMessage?.role === "assistant"
         && (lastMessage.stopReason === "error" || lastMessage.stopReason === "aborted")) {
@@ -1578,6 +1594,50 @@ export function createRoleRuntimeExtension(
         }
         return;
       }
+      const role = selectedRole ?? roleHost.getFlag(ROLE_FLAG.name);
+      // #959: navigator prose exit — final assistant text is the receipt.
+      // No typed-tool 催交; no JSON required. Tool path still wins when already accepted.
+      if (role === "navigator" && receiptDelivery.nextAction() !== "accepted") {
+        const prose = lastAssistantProse(event.messages);
+        if (prose !== undefined && prose.trim() !== "") {
+          const accepted = { prose };
+          await sealAcceptedSubmission({
+            context: ctx,
+            role: "navigator",
+            accepted,
+            toolCallId: `navigator-prose-exit:${randomUUID()}`,
+          });
+          await projectClosedSubmission(
+            { role: "navigator", kind: "accepted", accepted },
+            ctx,
+          );
+          return;
+        }
+        // Attended with neither tool nor prose → honest no_receipt (not typed 催交).
+        // Exhaust delivery budget without sending the typed prompt so facts() stays lawful.
+        if (!noReceiptRecorded) {
+          const runPointer = runDirectoryFromHostContext(ctx);
+          if (runPointer !== undefined) {
+            noReceiptRecorded = true;
+            while (receiptDelivery.nextAction() === "request-delivery") {
+              receiptDelivery.recordDeliveryRequest();
+            }
+            const facts = receiptDelivery.facts({ runPointer, attemptPointer: `current:${runPointer}` });
+            envelopeHost.appendEntry(NO_RECEIPT_LIFECYCLE_ENTRY_TYPE, facts);
+            try {
+              sitianReport({
+                level: "event",
+                kind: "no-receipt-lifecycle",
+                cwd: ctx.cwd,
+                sessionParent: ctx.sessionManager.getSessionFile(),
+                payload: facts,
+                source: "role-runtime",
+              });
+            } catch {}
+          }
+        }
+        return;
+      }
       if (receiptDelivery.nextAction() === "request-delivery") {
         receiptDelivery.recordDeliveryRequest();
         // Keep the package-owned continuation off the public input lifecycle:
@@ -1657,8 +1717,8 @@ export function createRoleRuntimeExtension(
           process.exitCode = 1;
         }
       }
-      // Flush any still-pending affirmative attendance before teardown. Accepted
-      // grace-timeout paths normally emit on agent_settled; abort can skip that hook.
+      // Flush any still-pending affirmative attendance before teardown.
+      // Grace-timeout paths normally emit on agent_settled; abort can skip that hook.
       const presentation = pendingNavigatorPresentation;
       pendingNavigatorPresentation = undefined;
       if (presentation !== undefined) {

package/src/submission-ledger.ts

@@ -517,6 +517,65 @@ async function restoreState(cwd: string, runId: string, scope: SubmissionLedgerR
   };
 }
 
+/** Sole HostContext-derived session parent for ledger restore/append (never process.env). */
+function sessionParentFromHostContext(context: HostContext): string | undefined {
+  const runDirectory = runDirectoryFromHostContext(context);
+  if (runDirectory !== undefined) return join(runDirectory, "session", "session.jsonl");
+  const sessionFile = context.sessionManager.getSessionFile?.();
+  if (typeof sessionFile === "string" && sessionFile.length > 0) return sessionFile;
+  const sessionDir = context.sessionManager.getSessionDir?.();
+  if (typeof sessionDir === "string" && sessionDir.length > 0) {
+    return join(sessionDir, "session.jsonl");
+  }
+  return undefined;
+}
+
+function homeFromHostContext(context: HostContext, home?: string): string | undefined {
+  if (home !== undefined) return home;
+  const sessionParent = sessionParentFromHostContext(context);
+  return sessionParent !== undefined ? tryHomeFromAkRolesPath(sessionParent) : undefined;
+}
+
+/**
+ * #959: seal one accepted submission without a model tool call.
+ * Same ledger row shape and priorEventId chain as the terminating-tool wrap.
+ * Used when a prose-exit seat (navigator) harvests the final assistant text.
+ */
+export async function sealAcceptedSubmission(options: {
+  readonly context: HostContext;
+  readonly role: TerminalRoleName;
+  readonly accepted: unknown;
+  readonly toolCallId: string;
+  readonly home?: string;
+}): Promise<void> {
+  const runId = runIdentity(options.context);
+  const attemptId = attemptIdentity(options.context, runId);
+  const sessionParent = sessionParentFromHostContext(options.context);
+  const home = homeFromHostContext(options.context, options.home);
+  const state = await restoreState(options.context.cwd, runId, {
+    ...(home === undefined ? {} : { home }),
+    ...(sessionParent === undefined ? {} : { sessionParent }),
+  });
+  const pointer = sitianReport({
+    level: "event",
+    kind: "sealed",
+    subject: { runId, attemptId },
+    ...(state.prior === undefined ? {} : { priorEventId: state.prior.identity }),
+    payload: {
+      type: "sealed",
+      attemptId,
+      toolCallId: options.toolCallId,
+      role: options.role,
+      accepted: options.accepted,
+    },
+    source: "role-runtime",
+    cwd: options.context.cwd,
+    ...(home !== undefined ? { home } : {}),
+    ...(sessionParent === undefined ? {} : { sessionParent }),
+  });
+  state.prior = pointer;
+}
+
 /**
  * Submission ledger host — record only (#836).
  * Each terminating submission is appended with the role's original payload.
@@ -531,28 +590,11 @@ export function createSubmissionLedgerHost(
   options?: { home?: string },
 ): RoleHost {
   const states = new Map<string, Promise<LedgerState>>();
-  /** Sole HostContext-derived run coordinate for restore and append (never process.env). */
-  const sessionParentFromContext = (context: HostContext): string | undefined => {
-    const runDirectory = runDirectoryFromHostContext(context);
-    if (runDirectory !== undefined) {
-      return join(runDirectory, "session", "session.jsonl");
-    }
-    const sessionFile = context.sessionManager.getSessionFile?.();
-    if (typeof sessionFile === "string" && sessionFile.length > 0) return sessionFile;
-    const sessionDir = context.sessionManager.getSessionDir?.();
-    if (typeof sessionDir === "string" && sessionDir.length > 0) {
-      return join(sessionDir, "session.jsonl");
-    }
-    return undefined;
-  };
-  const resolveHomeFromContext = (context: HostContext): string | undefined => {
-    if (options?.home !== undefined) return options.home;
-    const sessionParent = sessionParentFromContext(context);
-    return sessionParent !== undefined ? tryHomeFromAkRolesPath(sessionParent) : undefined;
-  };
+  const resolveHomeFromContext = (context: HostContext): string | undefined =>
+    homeFromHostContext(context, options?.home);
   const stateFor = (context: HostContext, runId: string) => states.get(runId) ?? (() => {
     const home = resolveHomeFromContext(context);
-    const sessionParent = sessionParentFromContext(context);
+    const sessionParent = sessionParentFromHostContext(context);
     const pending = restoreState(context.cwd, runId, {
       ...(home === undefined ? {} : { home }),
       ...(sessionParent === undefined ? {} : { sessionParent }),
@@ -562,7 +604,7 @@ export function createSubmissionLedgerHost(
   })();
   const appendFor = (state: LedgerState, context: HostContext, runId: string, attemptId: string, event: SubmissionLedgerEvent): RecordPointer => {
     const home = resolveHomeFromContext(context);
-    const sessionParent = sessionParentFromContext(context);
+    const sessionParent = sessionParentFromHostContext(context);
     const pointer = sitianReport({
       level: "event",
       kind: event.type,

package/dist/public-cli/command-renderer.js

@@ -1,5 +0,0 @@
-/**
- * Public CLI re-export of the shared registry-owned command renderer.
- * Single implementation lives in src/public-command-renderer.ts.
- */
-export { isPublicCallableRole, renderPublicAkRoleCommand, } from "../public-command-renderer.js";

package/dist/public-command-renderer.js

@@ -1,29 +0,0 @@
-import {
-  PACKAGED_ROLE_REGISTRY,
-  packagedRoleMetadata
-} from "./packaged-role-registry.js";
-const PUBLIC_CALLABLE_ROLES = new Set(
-  PACKAGED_ROLE_REGISTRY.map((entry) => entry.role)
-);
-function isPublicCallableRole(role) {
-  return PUBLIC_CALLABLE_ROLES.has(role);
-}
-function renderPublicAkRoleCommand(target) {
-  if (!isPublicCallableRole(target.role)) return void 0;
-  const role = target.role;
-  const metadata = packagedRoleMetadata(role);
-  if (metadata !== void 0 && "bareCommand" in metadata && metadata.bareCommand === false) {
-    return void 0;
-  }
-  if (target.phase === null || target.phase === void 0) {
-    return `ak-role ${role}`;
-  }
-  if (role === "coder" || role === "fixer") {
-    return `ak-role ${role} ${target.phase}`;
-  }
-  return `ak-role ${role}`;
-}
-export {
-  isPublicCallableRole,
-  renderPublicAkRoleCommand
-};

package/src/public-cli/command-renderer.ts

@@ -1,9 +0,0 @@
-/**
- * Public CLI re-export of the shared registry-owned command renderer.
- * Single implementation lives in src/public-command-renderer.ts.
- */
-export {
-  isPublicCallableRole,
-  renderPublicAkRoleCommand,
-  type PublicCommandTarget,
-} from "../public-command-renderer.ts";

package/src/public-command-renderer.ts

@@ -1,55 +0,0 @@
-/**
- * Registry-owned public command renderer (ADR 0052 / #106).
- * Typed role/phase facts → public `ak-role` command text.
- * Model-authored command prose is never executable output.
- *
- * Low-level shared owner: Navigator attendance and the public CLI both import
- * this module so dist/navigator-attendance.js keeps a complete dependency closure
- * without duplicating renderer logic into the preparation graph or bin bundle.
- */
-import {
-  PACKAGED_ROLE_REGISTRY,
-  packagedRoleMetadata,
-  type PackagedRole,
-} from "./packaged-role-registry.ts";
-
-export type PublicCommandPhase = "plan" | "apply" | null;
-
-export type PublicCommandTarget = {
-  role: string;
-  phase: PublicCommandPhase;
-};
-
-const PUBLIC_CALLABLE_ROLES = new Set<string>(
-  PACKAGED_ROLE_REGISTRY.map((entry) => entry.role),
-);
-
-export function isPublicCallableRole(role: string): role is PackagedRole {
-  return PUBLIC_CALLABLE_ROLES.has(role);
-}
-
-/**
- * Render one public ak-role invocation from typed next-role facts.
- * Returns undefined when the role is not callable or role/phase cannot supply
- * all required admission values for a truthful command.
- */
-export function renderPublicAkRoleCommand(
-  target: PublicCommandTarget,
-): string | undefined {
-  if (!isPublicCallableRole(target.role)) return undefined;
-  const role = target.role as PackagedRole;
-  const metadata = packagedRoleMetadata(role);
-  // A role whose admission requires typed values outside role/phase has no
-  // truthful bare command. Navigator may still recommend the typed direction.
-  if (metadata !== undefined && "bareCommand" in metadata && metadata.bareCommand === false) {
-    return undefined;
-  }
-  if (target.phase === null || target.phase === undefined) {
-    return `ak-role ${role}`;
-  }
-  // Coder/Fixer expose plan|apply; other roles have no public phase selector.
-  if (role === "coder" || role === "fixer") {
-    return `ak-role ${role} ${target.phase}`;
-  }
-  return `ak-role ${role}`;
-}