@akagilnc/pi-workflow-roles 0.1.4800 → 0.1.4870

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

@@ -1,167 +0,0 @@
-/**
- * Public Doctor Role run: admit Issue → retained case via #78 → shared post-admission
- * coordinator → settle Terminal result (#113 / #517). Lifecycle is the shared
- * post-admission seam; this module keeps only Doctor adapters.
- */
-import type { DurablePrincipalAuthority, RoleTurnRequest } from "../host-contracts.ts";
-import { engineSessionMaterialFromOptions, pickEngineAxis } from "../package-resources/engine-material.ts";
-import { CliUsageError } from "./cli-errors.ts";
-import {
-  admitDoctorInvocation,
-  buildDoctorTransportPrompt,
-  type AdmittedDoctorInvocation,
-  type ParseDoctorArgvResult
-} from "./invocation.ts";
-import {
-  runPostAdmissionOneShot,
-  type PostAdmissionAdapters,
-  type PostAdmissionEnv,
-  runPostAdmissionSeatResume,
-  resumeTurnRequestProjectionOptions,
-} from "./post-admission.ts";
-import {
-  loadResumableDoctorRun,
-  markRunAdmitted,
-  type PublicResumeRequest,
-} from "./run-lifecycle.ts";
-import {
-  presentStructuralRejection,
-  trySettleDoctorTerminalResult,
-} from "./settlement.ts";
-import type { CliIo } from "./cli-io.ts";
-import {
-  isLawfulTypedTerminalOutcome,
-  type TerminalResult,
-} from "./terminal.ts";
-import {
-  projectRoleTurnRequest,
-  type RoleTurnRequestProjectionOptions,
-} from "./turn-request.ts";
-
-export type DoctorRunEnv = PostAdmissionEnv & {
-  principalAuthority: DurablePrincipalAuthority;
-  createRunId?: () => string;
-};
-
-/** Project admitted invocation onto the host-neutral turn request. */
-export function buildDoctorTurnRequest(
-  admitted: AdmittedDoctorInvocation,
-  options: RoleTurnRequestProjectionOptions,
-): RoleTurnRequest {
-  return projectRoleTurnRequest(
-    admitted,
-    {
-      activation: { role: "doctor" as const, casePath: admitted.caseRunsPath },
-    },
-    options,
-  );
-}
-
-export async function runPublicDoctor(
-  argv: readonly string[],
-  env: DoctorRunEnv,
-  io: CliIo,
-  parseDoctorArgv: (args: readonly string[]) => ParseDoctorArgvResult,
-): Promise<{
-  exitCode: number;
-  admitted?: AdmittedDoctorInvocation;
-  terminal?: TerminalResult;
-}> {
-  let admitted: AdmittedDoctorInvocation;
-  try {
-    const parsed = parseDoctorArgv(argv);
-    admitted = await admitDoctorInvocation({
-      home: env.home,
-      principalAuthority: env.principalAuthority,
-      cwd: env.cwd,
-      issueNumber: parsed.issueNumber,
-      instruction: parsed.instruction,
-      attachmentPaths: parsed.attachmentPaths,
-      ...(parsed.project === undefined ? {} : { project: parsed.project }),
-      ...(parsed.runs === undefined ? {} : { runs: parsed.runs }),
-      ...(env.createRunId === undefined ? {} : { createRunId: env.createRunId }),
-      ...(env.model === undefined ? {} : { model: env.model }),
-    });
-  } catch (error) {
-    if (error instanceof CliUsageError) {
-      presentStructuralRejection(error, io);
-      return { exitCode: 2 };
-    }
-    throw error;
-  }
-
-  await markRunAdmitted(admitted, env.principalAuthority);
-
-  const turnRequest = buildDoctorTurnRequest(admitted, {
-    packageRoot: env.packageRoot,
-    home: env.home,
-    agentDir: env.agentDir,
-    ...(env.model === undefined ? {} : { model: env.model }),
-    ...pickEngineAxis(env),
-    ...(env.timeoutMs === undefined ? {} : { timeoutMs: env.timeoutMs }),
-    ...(env.correlationId === undefined || env.correlationId.trim() === ""
-      ? {}
-      : { correlationId: env.correlationId }),
-    continuation: {
-      kind: "initial",
-      prompt: buildDoctorTransportPrompt(
-        admitted,
-        engineSessionMaterialFromOptions({
-          ...pickEngineAxis(env),
-          packageRoot: env.packageRoot,
-        }),
-      ),
-    },
-  });
-
-  return await runPostAdmissionOneShot({
-    admitted,
-    env,
-    io,
-    request: turnRequest,
-    adapters: doctorAdapters(),
-    ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
-  });
-}
-
-function doctorAdapters(): PostAdmissionAdapters<AdmittedDoctorInvocation> {
-  return {
-    trySettle: (admitted, authority, scope) =>
-      trySettleDoctorTerminalResult(admitted, authority, scope),
-    shouldPresentSettled: (terminal) =>
-      isLawfulTypedTerminalOutcome(terminal.roleOutcome),
-  };
-}
-
-/**
- * Resume a previously admitted Doctor run (#633). Issue + retained case
- * identity restore from the durable admitted request; the session principal reopens.
- */
-export async function runPublicDoctorResume(
-  request: PublicResumeRequest,
-  env: DoctorRunEnv,
-  io: CliIo,
-): Promise<{
-  exitCode: number;
-  admitted?: AdmittedDoctorInvocation;
-  terminal?: TerminalResult;
-}> {
-  return await runPostAdmissionSeatResume({
-    request,
-    env,
-    io,
-    load: (effective) =>
-      loadResumableDoctorRun(
-      env.home,
-      effective.runId,
-      env.principalAuthority,
-    ),
-    buildTurnRequest: (admitted, effective) =>
-      buildDoctorTurnRequest(
-      admitted,
-      resumeTurnRequestProjectionOptions(admitted, effective, env),
-    ),
-    adapters: doctorAdapters(),
-    ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
-  });
-}

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

@@ -1,265 +0,0 @@
-/**
- * Public Fixer Role run: admit → post-admission coordinator → settle Terminal result (#110 / #517).
- * #110/#177: package-owned diagnosing-bugs and tdd methods (available, not forced),
- * common Invocation + structural prerequisites, default apply / explicit plan,
- * shared #106 success interface. Controlled-failure settlement reuses #107.
- * #526: execution via RoleTurnHost; argv is Pi adapter internal.
- */
-import type {
-  DurablePrincipalAuthority,
-  MethodBinding,
-  RoleTurnKnownFailure,
-  RoleTurnRequest,
-} from "../host-contracts.ts";
-import { engineSessionMaterialFromOptions, pickEngineAxis } from "../package-resources/engine-material.ts";
-import {
-  loadPackagedMethodSkillMaterial,
-  resolvePackagedMethodSkillPath,
-  type PackagedMethodSkillMaterial,
-  type PackagedMethodSkillProvenance,
-} from "../package-resources/method-skill.ts";
-import { CliUsageError } from "./cli-errors.ts";
-import {
-  admitFixerInvocation,
-  buildFixerTransportPrompt,
-  type AdmittedFixerInvocation,
-} from "./invocation.ts";
-import {
-  buildAutoResumeContinuationPrompt,
-  loadResumableFixerRun,
-  markRunAdmitted,
-  type PublicResumeRequest,
-} from "./run-lifecycle.ts";
-import {
-  presentStructuralRejection,
-  trySettleFixerTerminalResult,
-} from "./settlement.ts";
-import type { CliIo } from "./cli-io.ts";
-import type { TerminalResult } from "./terminal.ts";
-import {
-  projectRoleTurnRequest,
-  type RoleTurnRequestProjectionOptions,
-} from "./turn-request.ts";
-import {
-  presentControlledFailure,
-  resolveResumeMethodMaterialAdapters,
-  runPostAdmissionResumable,
-  runPostAdmissionSeatResume,
-  type PostAdmissionAdapters,
-  type PostAdmissionEnv,
-  resumeTurnRequestProjectionOptions,
-} from "./post-admission.ts";
-
-export type FixerRunEnv = PostAdmissionEnv & {
-  createRunId?: () => string;
-};
-
-function fixerMethods(packageRoot: string): readonly MethodBinding[] {
-  return [
-    { kind: "skill", path: resolvePackagedMethodSkillPath(packageRoot, "diagnosing-bugs") },
-    { kind: "skill", path: resolvePackagedMethodSkillPath(packageRoot, "tdd") },
-  ];
-}
-
-/** Project admitted Fixer invocation onto the host-neutral turn request. */
-export function buildFixerTurnRequest(
-  admitted: AdmittedFixerInvocation,
-  options: RoleTurnRequestProjectionOptions,
-): RoleTurnRequest {
-  return projectRoleTurnRequest(
-    admitted,
-    {
-      activation: {
-        role: "fixer",
-        phase: admitted.phase,
-        packetPath: admitted.packetPath,
-        ...(admitted.prerequisitesPath === undefined
-          ? {}
-          : { prerequisitesPath: admitted.prerequisitesPath }),
-      },
-      methods: fixerMethods(options.packageRoot),
-    },
-    options,
-  );
-}
-
-function fixerAdapters(
-  packageRoot: string,
-  methodMaterial?: PackagedMethodSkillMaterial,
-): PostAdmissionAdapters<AdmittedFixerInvocation> {
-  return {
-    trySettle: (admitted, authority, scope) =>
-      methodMaterial === undefined
-        ? Promise.resolve(undefined)
-        : trySettleFixerTerminalResult(
-            admitted,
-            authority,
-            {
-              methodProvenance: methodMaterial.provenance,
-              methodSkillPath: methodMaterial.skillPath,
-              methodSkillConfiguredPath: resolvePackagedMethodSkillPath(
-                packageRoot,
-                "diagnosing-bugs",
-              ),
-            },
-            scope,
-          ),
-  };
-}
-
-async function loadFixerMethodMaterial(
-  packageRoot: string,
-): Promise<PackagedMethodSkillMaterial> {
-  return await loadPackagedMethodSkillMaterial(packageRoot, "diagnosing-bugs");
-}
-
-export async function runPublicFixer(
-  argv: readonly string[],
-  env: FixerRunEnv,
-  io: CliIo,
-  parseFixerArgv: (args: readonly string[]) => {
-    phase: "plan" | "apply";
-    instruction: string;
-    attachmentPaths: string[];
-    prerequisitesPath?: string;
-    project?: string;
-  },
-): Promise<{
-  exitCode: number;
-  admitted?: AdmittedFixerInvocation;
-  terminal?: TerminalResult;
-}> {
-  let admitted: AdmittedFixerInvocation;
-  try {
-    const parsed = parseFixerArgv(argv);
-    admitted = await admitFixerInvocation({
-      home: env.home,
-      principalAuthority: env.principalAuthority,
-      cwd: env.cwd,
-      phase: parsed.phase,
-      instruction: parsed.instruction,
-      attachmentPaths: parsed.attachmentPaths,
-      ...(parsed.prerequisitesPath === undefined
-        ? {}
-        : { prerequisitesPath: parsed.prerequisitesPath }),
-      ...(parsed.project === undefined ? {} : { project: parsed.project }),
-      ...(env.createRunId === undefined ? {} : { createRunId: env.createRunId }),
-      ...(env.model === undefined ? {} : { model: env.model }),
-    });
-  } catch (error) {
-    if (error instanceof CliUsageError) {
-      presentStructuralRejection(error, io);
-      return { exitCode: 2 };
-    }
-    throw error;
-  }
-
-  await markRunAdmitted(admitted, env.principalAuthority);
-
-  let methodMaterial: PackagedMethodSkillMaterial;
-  try {
-    methodMaterial = await loadFixerMethodMaterial(env.packageRoot);
-  } catch (error) {
-    return (await presentControlledFailure(
-      admitted,
-      {
-        timedOut: false,
-        code: null,
-        stderr: "",
-        thrown: error,
-      },
-      fixerAdapters(env.packageRoot),
-      env.principalAuthority,
-      io,
-    )) as { exitCode: number; admitted: AdmittedFixerInvocation; terminal: TerminalResult };
-  }
-
-  return await runPostAdmissionResumable({
-    admitted,
-    env,
-    io,
-    buildInitialRequest: () =>
-      buildFixerTurnRequest(admitted, {
-        packageRoot: env.packageRoot,
-        home: env.home,
-        agentDir: env.agentDir,
-        ...(env.model === undefined ? {} : { model: env.model }),
-        ...pickEngineAxis(env),
-        ...(env.timeoutMs === undefined ? {} : { timeoutMs: env.timeoutMs }),
-        ...(admitted.correlationId === undefined && env.correlationId === undefined
-          ? {}
-          : { correlationId: admitted.correlationId ?? env.correlationId }),
-        continuation: {
-          kind: "initial",
-          prompt: buildFixerTransportPrompt(
-            admitted,
-            engineSessionMaterialFromOptions({
-              ...pickEngineAxis(env),
-              packageRoot: env.packageRoot,
-            }),
-          ),
-        },
-      }),
-    buildResumeRequest: () =>
-      buildFixerTurnRequest(admitted, {
-        packageRoot: env.packageRoot,
-        home: env.home,
-        agentDir: env.agentDir,
-        ...(env.model === undefined ? {} : { model: env.model }),
-        ...pickEngineAxis(env),
-        ...(env.timeoutMs === undefined ? {} : { timeoutMs: env.timeoutMs }),
-        ...(admitted.correlationId === undefined && env.correlationId === undefined
-          ? {}
-          : { correlationId: admitted.correlationId ?? env.correlationId }),
-        continuation: {
-          kind: "resume",
-          prompt: buildAutoResumeContinuationPrompt({
-            packageRoot: env.packageRoot,
-            ...pickEngineAxis(env),
-          }),
-        },
-      }),
-    adapters: fixerAdapters(env.packageRoot, methodMaterial),
-    ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
-  });
-}
-
-/**
- * Resume a previously admitted Fixer Role run after a typed HTTP 429.
- * Restores role/phase/packet/prerequisites/session identity; model override is temporary.
- */
-export async function runPublicFixerResume(
-  request: PublicResumeRequest,
-  env: FixerRunEnv,
-  io: CliIo,
-): Promise<{
-  exitCode: number;
-  admitted?: AdmittedFixerInvocation;
-  terminal?: TerminalResult;
-}> {
-  return await runPostAdmissionSeatResume({
-    request,
-    env,
-    io,
-    load: (effective) =>
-      loadResumableFixerRun(env.home, effective.runId, env.principalAuthority),
-    buildTurnRequest: (admitted, effective) =>
-      buildFixerTurnRequest(
-        admitted,
-        resumeTurnRequestProjectionOptions(admitted, effective, env),
-      ),
-    adapters: fixerAdapters(env.packageRoot),
-    afterAdmittedLoad: (admitted) =>
-      resolveResumeMethodMaterialAdapters({
-        admitted,
-        authority: env.principalAuthority,
-        io,
-        loadMaterial: () => loadFixerMethodMaterial(env.packageRoot),
-        adaptersWith: (material) => fixerAdapters(env.packageRoot, material),
-        emptyAdapters: fixerAdapters(env.packageRoot),
-      }),
-    ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
-  });
-}
-
-export type { RoleTurnKnownFailure, PackagedMethodSkillProvenance };

package/src/public-cli/gleaner-left-run.ts

@@ -1,167 +0,0 @@
-/**
- * Public Gleaner-Left Role run: admit (instruction may be empty; --base required)
- * → shared post-admission coordinator → settle Terminal result (#502 / ADR 0067).
- * #599: manual resume continues the exact session; 只上弹章.
- */
-import type { DurablePrincipalAuthority, RoleTurnRequest } from "../host-contracts.ts";
-import { engineSessionMaterialFromOptions, pickEngineAxis } from "../package-resources/engine-material.ts";
-import { CliUsageError } from "./cli-errors.ts";
-import {
-  admitGleanerLeftInvocation,
-  buildGleanerLeftTransportPrompt,
-  type AdmittedGleanerLeftInvocation,
-  type ParseGleanerLeftArgvResult,
-} from "./invocation.ts";
-import {
-  runPostAdmissionOneShot,
-  type PostAdmissionEnv,
-  runPostAdmissionSeatResume,
-  resumeTurnRequestProjectionOptions,
-} from "./post-admission.ts";
-import {
-  loadResumableGleanerLeftRun,
-  markRunAdmitted,
-  type PublicResumeRequest,
-} from "./run-lifecycle.ts";
-import {
-  presentStructuralRejection,
-  trySettleGleanerLeftTerminalResult,
-} from "./settlement.ts";
-import type { CliIo } from "./cli-io.ts";
-import type { TerminalResult } from "./terminal.ts";
-import {
-  projectRoleTurnRequest,
-  type RoleTurnRequestProjectionOptions,
-} from "./turn-request.ts";
-
-export type GleanerLeftRunEnv = PostAdmissionEnv & {
-  principalAuthority: DurablePrincipalAuthority;
-  createRunId?: () => string;
-};
-
-/** Project admitted invocation onto the host-neutral turn request. */
-export function buildGleanerLeftTurnRequest(
-  admitted: AdmittedGleanerLeftInvocation,
-  options: RoleTurnRequestProjectionOptions,
-): RoleTurnRequest {
-  return projectRoleTurnRequest(
-    admitted,
-    {
-      activation: {
-        role: "gleaner-left" as const,
-        baseRevision: admitted.baseRevision,
-      },
-    },
-    options,
-  );
-}
-
-export async function runPublicGleanerLeft(
-  argv: readonly string[],
-  env: GleanerLeftRunEnv,
-  io: CliIo,
-  parseGleanerLeftArgv: (args: readonly string[]) => ParseGleanerLeftArgvResult,
-): Promise<{
-  exitCode: number;
-  admitted?: AdmittedGleanerLeftInvocation;
-  terminal?: TerminalResult;
-}> {
-  let admitted: AdmittedGleanerLeftInvocation;
-  try {
-    const parsed = parseGleanerLeftArgv(argv);
-    admitted = await admitGleanerLeftInvocation({
-      home: env.home,
-      principalAuthority: env.principalAuthority,
-      cwd: env.cwd,
-      instruction: parsed.instruction,
-      baseRevision: parsed.baseRevision,
-      ...(parsed.project === undefined ? {} : { project: parsed.project }),
-      ...(env.createRunId === undefined ? {} : { createRunId: env.createRunId }),
-      ...(env.model === undefined ? {} : { model: env.model }),
-      ...(env.correlationId === undefined ? {} : { correlationId: env.correlationId }),
-    });
-  } catch (error) {
-    if (error instanceof CliUsageError) {
-      presentStructuralRejection(error, io);
-      return { exitCode: 2 };
-    }
-    throw error;
-  }
-
-  await markRunAdmitted(admitted, env.principalAuthority);
-
-  const turnRequest = buildGleanerLeftTurnRequest(admitted, {
-    packageRoot: env.packageRoot,
-    home: env.home,
-    agentDir: env.agentDir,
-    ...(env.model === undefined ? {} : { model: env.model }),
-    ...pickEngineAxis(env),
-    ...(env.timeoutMs === undefined ? {} : { timeoutMs: env.timeoutMs }),
-    ...(env.correlationId === undefined || env.correlationId.trim() === ""
-      ? {}
-      : { correlationId: env.correlationId }),
-    continuation: {
-      kind: "initial",
-      prompt: buildGleanerLeftTransportPrompt(
-        admitted,
-        engineSessionMaterialFromOptions({
-          ...pickEngineAxis(env),
-          packageRoot: env.packageRoot,
-        }),
-      ),
-    },
-  });
-
-  return await runPostAdmissionOneShot({
-    admitted,
-    env,
-    io,
-    request: turnRequest,
-    adapters: gleanerLeftAdapters(),
-    ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
-  });
-}
-
-function gleanerLeftAdapters() {
-  return {
-    trySettle: (
-      admitted: AdmittedGleanerLeftInvocation,
-      authority: DurablePrincipalAuthority,
-      scope?: { readonly courtAttemptId?: string },
-    ) => trySettleGleanerLeftTerminalResult(admitted, authority, scope),
-    shouldPresentSettled: () => true,
-  };
-}
-
-/**
- * Resume a previously admitted Gleaner-Left run (#599 / DK-3).
- * Restores role/base/session identity; model override is temporary.
- */
-export async function runPublicGleanerLeftResume(
-  request: PublicResumeRequest,
-  env: GleanerLeftRunEnv,
-  io: CliIo,
-): Promise<{
-  exitCode: number;
-  admitted?: AdmittedGleanerLeftInvocation;
-  terminal?: TerminalResult;
-}> {
-  return await runPostAdmissionSeatResume({
-    request,
-    env,
-    io,
-    load: (effective) =>
-      loadResumableGleanerLeftRun(
-      env.home,
-      effective.runId,
-      env.principalAuthority,
-    ),
-    buildTurnRequest: (admitted, effective) =>
-      buildGleanerLeftTurnRequest(
-      admitted,
-      resumeTurnRequestProjectionOptions(admitted, effective, env),
-    ),
-    adapters: gleanerLeftAdapters(),
-    ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
-  });
-}