@akagilnc/pi-workflow-roles 0.1.1751

package/src/public-cli/public-run-credentials.ts

@@ -0,0 +1,71 @@
+/**
+ * Shared public-run credential seam: one owner for missing selected-provider
+ * detection, typed failure construction, pre-dispatch fail-closed payload, and
+ * post-run credential annotation. Role runners supply model/credential facts only.
+ */
+import {
+  missingPublicProviderCredential,
+  type CredentialProviders,
+  type SeatModelConfig,
+} from "./config.ts";
+import type { ExplicitInternalKnownFailure } from "./explicit-internal.ts";
+
+/**
+ * Production-owned provider failure when the selected public seat provider has
+ * no configured credential. Cause/identity come from CredentialProviders, not
+ * stderr wording. Runner-supplied knownFailure still wins over this annotation.
+ */
+export function knownFailureForMissingProviderCredential(
+  model: SeatModelConfig | undefined,
+  credentials: CredentialProviders | undefined,
+): ExplicitInternalKnownFailure | undefined {
+  if (model === undefined || credentials === undefined) return undefined;
+  // Only the public credential catalog is fail-closed here; offline/test providers
+  // are not represented in auth.json shape and must not be washed into MissingProviderCredential.
+  if (model.provider !== "openai-codex" && model.provider !== "xai") return undefined;
+  if (!missingPublicProviderCredential(model.provider, credentials)) {
+    return undefined;
+  }
+  return {
+    cause: "provider",
+    identity: {
+      name: "MissingProviderCredential",
+      code: model.provider,
+    },
+  };
+}
+
+/** Pre-dispatch fail-closed payload when selected public provider lacks credentials. */
+export type MissingCredentialPreDispatchFailure = Readonly<{
+  timedOut: false;
+  code: 1;
+  stderr: string;
+  knownFailure: ExplicitInternalKnownFailure;
+}>;
+
+export function missingCredentialPreDispatchFailure(
+  model: SeatModelConfig | undefined,
+  credentials: CredentialProviders | undefined,
+): MissingCredentialPreDispatchFailure | undefined {
+  const knownFailure = knownFailureForMissingProviderCredential(model, credentials);
+  if (knownFailure === undefined) return undefined;
+  return {
+    timedOut: false,
+    code: 1,
+    stderr: `Missing credential for provider ${String(knownFailure.identity?.code ?? "unknown")}`,
+    knownFailure,
+  };
+}
+
+/**
+ * Post-run credential annotation for the shared evidence-priority chain.
+ * Only annotates nonzero/timeout exits; never invents a credential failure on success.
+ */
+export function postRunMissingCredentialFailure(
+  result: Readonly<{ timedOut: boolean; code: number | null }>,
+  model: SeatModelConfig | undefined,
+  credentials: CredentialProviders | undefined,
+): ExplicitInternalKnownFailure | undefined {
+  if (!(result.timedOut || result.code !== 0)) return undefined;
+  return knownFailureForMissingProviderCredential(model, credentials);
+}

package/src/public-cli/registry.ts

@@ -0,0 +1,153 @@
+/**
+ * Typed public CLI registry — sole source for discoverable commands, seats,
+ * and startup model candidates (ADR 0052 / #105).
+ */
+import {
+  PACKAGED_ROLE_REGISTRY,
+  type PackagedRole,
+} from "../packaged-role-registry.ts";
+
+/** Package-relative path of the Internal role entrypoint (explicit load only). */
+export const INTERNAL_ROLE_ENTRYPOINT_RELATIVE = "extensions/role-runtime.ts" as const;
+
+export const PUBLIC_CALLABLE_ROLES = PACKAGED_ROLE_REGISTRY.map(
+  (entry) => entry.role,
+) as readonly PackagedRole[];
+
+export type PublicCallableRole = (typeof PUBLIC_CALLABLE_ROLES)[number];
+
+/** Automatic attendance seat — configurable, never a caller-selected command. */
+export const AUTOMATIC_NAVIGATOR_SEAT = "navigator" as const;
+
+export type PublicConfigurableSeat =
+  | PublicCallableRole
+  | typeof AUTOMATIC_NAVIGATOR_SEAT;
+
+export const PUBLIC_CONFIGURABLE_SEATS = [
+  ...PUBLIC_CALLABLE_ROLES,
+  AUTOMATIC_NAVIGATOR_SEAT,
+] as const satisfies readonly PublicConfigurableSeat[];
+
+export const PUBLIC_CLI_SUPPORT_COMMANDS = [
+  "roles",
+  "config",
+  "help",
+  "resume",
+] as const;
+
+export type PublicCliSupportCommand = (typeof PUBLIC_CLI_SUPPORT_COMMANDS)[number];
+
+export type PublicThinkingLevel =
+  | "off"
+  | "minimal"
+  | "low"
+  | "medium"
+  | "high"
+  | "xhigh"
+  | "max";
+
+export type ModelRef = {
+  provider: string;
+  model: string;
+  thinking: PublicThinkingLevel;
+};
+
+/**
+ * Package startup candidates (#11): Codex family first, then Grok 4.5.
+ * Selection among candidates is credential-driven at resolve time.
+ */
+const STARTUP_CANDIDATES: Record<PublicConfigurableSeat, readonly ModelRef[]> = {
+  judge: [
+    { provider: "openai-codex", model: "gpt-5.6-sol", thinking: "high" },
+    { provider: "xai", model: "grok-4.5", thinking: "high" },
+  ],
+  reviewer: [
+    { provider: "openai-codex", model: "gpt-5.6-sol", thinking: "medium" },
+    { provider: "xai", model: "grok-4.5", thinking: "high" },
+  ],
+  coder: [
+    { provider: "openai-codex", model: "gpt-5.6-luna", thinking: "high" },
+    { provider: "xai", model: "grok-4.5", thinking: "high" },
+  ],
+  fixer: [
+    { provider: "openai-codex", model: "gpt-5.6-luna", thinking: "high" },
+    { provider: "xai", model: "grok-4.5", thinking: "high" },
+  ],
+  collector: [
+    { provider: "openai-codex", model: "gpt-5.6-luna", thinking: "high" },
+    { provider: "xai", model: "grok-4.5", thinking: "high" },
+  ],
+  doctor: [
+    { provider: "openai-codex", model: "gpt-5.6-luna", thinking: "high" },
+    { provider: "xai", model: "grok-4.5", thinking: "high" },
+  ],
+  merger: [
+    { provider: "openai-codex", model: "gpt-5.6-luna", thinking: "high" },
+    { provider: "xai", model: "grok-4.5", thinking: "high" },
+  ],
+  navigator: [
+    { provider: "openai-codex", model: "gpt-5.6-luna", thinking: "medium" },
+    { provider: "xai", model: "grok-4.5", thinking: "high" },
+  ],
+};
+
+export function publicStartupCandidates(
+  seat: PublicConfigurableSeat,
+): readonly ModelRef[] {
+  return STARTUP_CANDIDATES[seat];
+}
+
+export type HelpCapability =
+  | {
+      kind: "support";
+      name: PublicCliSupportCommand;
+    }
+  | {
+      kind: "role";
+      name: PublicCallableRole;
+      phases: readonly (string | null)[];
+      defaultPhase: string | null;
+    };
+
+/**
+ * Typed help surface. Presentation formats these facts; tests must not assert
+ * exact help prose or layout (锚定宪法 / ADR 0016 / #105 AC).
+ */
+export function listHelpCapabilities(): readonly HelpCapability[] {
+  const support: HelpCapability[] = PUBLIC_CLI_SUPPORT_COMMANDS.map((name) => ({
+    kind: "support" as const,
+    name,
+  }));
+  const roles: HelpCapability[] = PACKAGED_ROLE_REGISTRY.map((entry) => {
+    const phases = entry.phases as readonly (string | null)[];
+    const defaultPhase =
+      phases.length === 1 && phases[0] === null
+        ? null
+        : phases.includes("apply")
+        ? "apply"
+        : (phases[0] ?? null);
+    return {
+      kind: "role" as const,
+      name: entry.role,
+      phases,
+      defaultPhase,
+    };
+  });
+  return [...support, ...roles];
+}
+
+export function isPublicCallableRole(value: string): value is PublicCallableRole {
+  return (PUBLIC_CALLABLE_ROLES as readonly string[]).includes(value);
+}
+
+export function isPublicConfigurableSeat(
+  value: string,
+): value is PublicConfigurableSeat {
+  return (PUBLIC_CONFIGURABLE_SEATS as readonly string[]).includes(value);
+}
+
+export function isPublicCliSupportCommand(
+  value: string,
+): value is PublicCliSupportCommand {
+  return (PUBLIC_CLI_SUPPORT_COMMANDS as readonly string[]).includes(value);
+}