@akagilnc/pi-workflow-roles 0.1.4802 → 0.1.4870

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

@@ -1,255 +0,0 @@
-/**
- * Public Coder Role run: admit → post-admission coordinator → settle Terminal result (#109 / #517).
- * #109: package-owned TDD method, default apply / explicit plan, shared #106 success interface.
- * #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 PackagedMethodSkillProvenance,
-} from "../package-resources/method-skill.ts";
-import { CliUsageError } from "./cli-errors.ts";
-import {
-  admitCoderInvocation,
-  buildCoderTransportPrompt,
-  type AdmittedCoderInvocation,
-} from "./invocation.ts";
-import {
-  buildAutoResumeContinuationPrompt,
-  loadResumableCoderRun,
-  markRunAdmitted,
-  type PublicResumeRequest,
-} from "./run-lifecycle.ts";
-import {
-  presentStructuralRejection,
-  trySettleCoderTerminalResult,
-} 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 CoderRunEnv = PostAdmissionEnv & {
-  createRunId?: () => string;
-};
-
-function coderMethods(
-  phase: string,
-  packageRoot: string,
-): readonly MethodBinding[] {
-  return phase === "apply"
-    ? [{ kind: "skill", path: resolvePackagedMethodSkillPath(packageRoot, "tdd") }]
-    : [];
-}
-
-/** Project admitted Coder invocation onto the host-neutral turn request. */
-export function buildCoderTurnRequest(
-  admitted: AdmittedCoderInvocation,
-  options: RoleTurnRequestProjectionOptions,
-): RoleTurnRequest {
-  return projectRoleTurnRequest(
-    admitted,
-    {
-      activation: {
-        role: "coder",
-        phase: admitted.phase,
-        taskPath: admitted.taskPath,
-      },
-      methods: coderMethods(admitted.phase, options.packageRoot),
-    },
-    options,
-  );
-}
-
-function coderAdapters(
-  methodProvenance?: PackagedMethodSkillProvenance,
-): PostAdmissionAdapters<AdmittedCoderInvocation> {
-  return {
-    trySettle: (admitted, authority, scope) =>
-      trySettleCoderTerminalResult(
-        admitted,
-        authority,
-        {
-          ...(methodProvenance === undefined ? {} : { methodProvenance }),
-        },
-        scope,
-      ),
-  };
-}
-
-export async function runPublicCoder(
-  argv: readonly string[],
-  env: CoderRunEnv,
-  io: CliIo,
-  parseCoderArgv: (args: readonly string[]) => {
-    phase: "plan" | "apply";
-    instruction: string;
-    attachmentPaths: string[];
-    project?: string;
-  },
-): Promise<{
-  exitCode: number;
-  admitted?: AdmittedCoderInvocation;
-  terminal?: TerminalResult;
-}> {
-  let admitted: AdmittedCoderInvocation;
-  try {
-    const parsed = parseCoderArgv(argv);
-    admitted = await admitCoderInvocation({
-      home: env.home,
-      principalAuthority: env.principalAuthority,
-      cwd: env.cwd,
-      phase: parsed.phase,
-      instruction: parsed.instruction,
-      attachmentPaths: parsed.attachmentPaths,
-      ...(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 methodProvenance: PackagedMethodSkillProvenance | undefined;
-  if (admitted.phase === "apply") {
-    try {
-      const material = await loadPackagedMethodSkillMaterial(
-        env.packageRoot,
-        "tdd",
-      );
-      methodProvenance = material.provenance;
-    } catch (error) {
-      return (await presentControlledFailure(
-        admitted,
-        {
-          timedOut: false,
-          code: null,
-          stderr: "",
-          thrown: error,
-          knownCause: "activation",
-        },
-        coderAdapters(),
-        env.principalAuthority,
-        io,
-      )) as { exitCode: number; admitted: AdmittedCoderInvocation; terminal: TerminalResult };
-    }
-  }
-
-  return await runPostAdmissionResumable({
-    admitted,
-    env,
-    io,
-    buildInitialRequest: () =>
-      buildCoderTurnRequest(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: buildCoderTransportPrompt(
-            admitted,
-            engineSessionMaterialFromOptions({
-              ...pickEngineAxis(env),
-              packageRoot: env.packageRoot,
-            }),
-          ),
-        },
-      }),
-    buildResumeRequest: () =>
-      buildCoderTurnRequest(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: coderAdapters(methodProvenance),
-    ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
-  });
-}
-
-/**
- * Resume a previously admitted Coder Role run after a typed HTTP 429.
- * Restores role/phase/task/session identity; model override is temporary.
- */
-export async function runPublicCoderResume(
-  request: PublicResumeRequest,
-  env: CoderRunEnv,
-  io: CliIo,
-): Promise<{
-  exitCode: number;
-  admitted?: AdmittedCoderInvocation;
-  terminal?: TerminalResult;
-}> {
-  return await runPostAdmissionSeatResume({
-    request,
-    env,
-    io,
-    load: (effective) =>
-      loadResumableCoderRun(env.home, effective.runId, env.principalAuthority),
-    buildTurnRequest: (admitted, effective) =>
-      buildCoderTurnRequest(
-        admitted,
-        resumeTurnRequestProjectionOptions(admitted, effective, env),
-      ),
-    adapters: coderAdapters(),
-    // Apply-only method; plan resume keeps empty provenance (same as initial).
-    afterAdmittedLoad: (admitted) =>
-      resolveResumeMethodMaterialAdapters({
-        admitted,
-        authority: env.principalAuthority,
-        io,
-        shouldLoad: admitted.phase === "apply",
-        loadMaterial: () =>
-          loadPackagedMethodSkillMaterial(env.packageRoot, "tdd"),
-        adaptersWith: (material) => coderAdapters(material.provenance),
-        emptyAdapters: coderAdapters(),
-        knownCause: "activation",
-      }),
-    ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
-  });
-}
-
-// Re-export for tests that assert typed credential failure channel shape.
-export type { RoleTurnKnownFailure, PackagedMethodSkillProvenance };

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

@@ -1,189 +0,0 @@
-/**
- * Public Collector Role run: admit a structured PR target → explicit Internal activate
- * → settle Terminal result (#112 / #517). #633: manual resume continues the exact
- * session. Lifecycle is the shared post-admission coordinator.
- */
-import type { DurablePrincipalAuthority, RoleTurnRequest } from "../host-contracts.ts";
-import { engineSessionMaterialFromOptions, pickEngineAxis } from "../package-resources/engine-material.ts";
-import { CliUsageError } from "./cli-errors.ts";
-import {
-  admitCollectorInvocation,
-  buildCollectorTransportPrompt,
-  type AdmittedCollectorInvocation,
-  type ParseCollectorArgvResult,
-} from "./invocation.ts";
-import {
-  runPostAdmissionOneShot,
-  type PostAdmissionAdapters,
-  type PostAdmissionEnv,
-  runPostAdmissionSeatResume,
-  resumeTurnRequestProjectionOptions,
-} from "./post-admission.ts";
-import {
-  loadResumableCollectorRun,
-  markRunAdmitted,
-  type PublicResumeRequest,
-} from "./run-lifecycle.ts";
-import {
-  presentStructuralRejection,
-  readCollectorInfrastructureFailure,
-  trySettleCollectorTerminalResult,
-} 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 CollectorRunEnv = PostAdmissionEnv & {
-  createRunId?: () => string;
-};
-
-/** Project admitted invocation onto the host-neutral turn request. */
-export function buildCollectorTurnRequest(
-  admitted: AdmittedCollectorInvocation,
-  options: RoleTurnRequestProjectionOptions,
-): RoleTurnRequest {
-  return projectRoleTurnRequest(
-    admitted,
-    {
-      activation: {
-        role: "collector" as const,
-        repo: admitted.repository.display,
-        // #676 A: omit pr when unbound — role binds via ak_collector_bind_target.
-        ...(admitted.prNumber === undefined ? {} : { pr: String(admitted.prNumber) }),
-        ...(admitted.requestManifestPath === undefined ? {} : { requestManifestPath: admitted.requestManifestPath }),
-        ...(admitted.waitWindowMs === undefined ? {} : { waitMs: String(admitted.waitWindowMs) }),
-      },
-    },
-    options,
-  );
-}
-
-export async function runPublicCollector(
-  argv: readonly string[],
-  env: CollectorRunEnv,
-  io: CliIo,
-  parseCollectorArgv: (args: readonly string[]) => ParseCollectorArgvResult,
-): Promise<{
-  exitCode: number;
-  admitted?: AdmittedCollectorInvocation;
-  terminal?: TerminalResult;
-}> {
-  let admitted: AdmittedCollectorInvocation;
-  try {
-    const parsed = parseCollectorArgv(argv);
-    admitted = await admitCollectorInvocation({
-      home: env.home,
-      principalAuthority: env.principalAuthority,
-      cwd: env.cwd,
-      ...(parsed.prNumber === undefined ? {} : { prNumber: parsed.prNumber }),
-      instruction: parsed.instruction,
-      attachmentPaths: parsed.attachmentPaths,
-      ...(parsed.project === undefined ? {} : { project: parsed.project }),
-      ...(parsed.repo === undefined ? {} : { repo: parsed.repo }),
-      ...(parsed.requestManifestPath === undefined ? {} : { requestManifestPath: parsed.requestManifestPath }),
-      ...(parsed.waitWindowMs === undefined ? {} : { waitWindowMs: parsed.waitWindowMs }),
-      ...(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 = buildCollectorTurnRequest(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: buildCollectorTransportPrompt(
-        admitted,
-        engineSessionMaterialFromOptions({
-          ...pickEngineAxis(env),
-          packageRoot: env.packageRoot,
-        }),
-      ),
-    },
-  });
-
-  return await runPostAdmissionOneShot({
-    admitted,
-    env,
-    io,
-    request: turnRequest,
-    adapters: collectorAdapters(),
-    ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
-  });
-}
-
-function collectorAdapters(): PostAdmissionAdapters<AdmittedCollectorInvocation> {
-  return {
-    trySettle: (admitted, authority, scope) =>
-      trySettleCollectorTerminalResult(admitted, authority, scope),
-    shouldPresentSettled: () => true,
-    resolveRunnerKnownFailure: async ({ result, sessionFile }) => {
-      const infrastructureFailure = await readCollectorInfrastructureFailure(sessionFile);
-      return (
-        result.knownFailure ??
-        (infrastructureFailure === undefined
-          ? undefined
-          : {
-              ...(infrastructureFailure.cause === undefined
-                ? {}
-                : { cause: infrastructureFailure.cause }),
-              diagnostic: infrastructureFailure.diagnostic,
-              ...(infrastructureFailure.identity === undefined
-                ? {}
-                : { identity: infrastructureFailure.identity }),
-            })
-      );
-    },
-  };
-}
-
-/**
- * Resume a previously admitted Collector run (#633). Repository/PR identity
- * restores from the durable admitted request; the session principal reopens.
- */
-export async function runPublicCollectorResume(
-  request: PublicResumeRequest,
-  env: CollectorRunEnv,
-  io: CliIo,
-): Promise<{
-  exitCode: number;
-  admitted?: AdmittedCollectorInvocation;
-  terminal?: TerminalResult;
-}> {
-  return await runPostAdmissionSeatResume({
-    request,
-    env,
-    io,
-    load: (effective) =>
-      loadResumableCollectorRun(
-      env.home,
-      effective.runId,
-      env.principalAuthority,
-    ),
-    buildTurnRequest: (admitted, effective) =>
-      buildCollectorTurnRequest(
-      admitted,
-      resumeTurnRequestProjectionOptions(admitted, effective, env),
-    ),
-    adapters: collectorAdapters(),
-    ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
-  });
-}

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

@@ -1,233 +0,0 @@
-/**
- * Public Diarist (起居郎) Role run — #708 / ADR 0075（起居郎是 LLM 角色）/ #779.
- * Same admit → post-admission → settle shape as the other instruction seats.
- * Semantic collection is the role's own turn: LLM finds materials itself
- * (no frozen candidate catalog, no path/attachment burden on the caller).
- * Who calls it and in what order is the caller's business (ADR 0010; ADR 0075 不规定调用顺序).
- */
-import type { DurablePrincipalAuthority, RoleTurnRequest } from "../host-contracts.ts";
-import { engineSessionMaterialFromOptions, pickEngineAxis } from "../package-resources/engine-material.ts";
-import { CliUsageError } from "./cli-errors.ts";
-import {
-  admitDiaristInvocation,
-  bindAdmittedTicketNumber,
-  buildInstructionTransportPrompt,
-  relocateAdmittedRunToTicket,
-  recordAdmittedCorrelation,
-  type AdmittedDiaristInvocation,
-  type ParseDiaristArgvResult,
-} from "./invocation.ts";
-import {
-  prepareSummonsResumeMaterials,
-  runPostAdmissionOneShot,
-  runPostAdmissionSeatResume,
-  resumeTurnRequestProjectionOptions,
-  type PostAdmissionAdapters,
-  type PostAdmissionEnv,
-} from "./post-admission.ts";
-import {
-  loadResumableDiaristRun,
-  markRunAdmitted,
-  type PublicResumeRequest,
-  type RunWriterLease,
-} from "./run-lifecycle.ts";
-import {
-  presentStructuralRejection,
-  trySettleDiaristTerminalResult,
-} 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 { readBoardTicketNumber } from "../run-ticket-number.ts";
-
-export type DiaristRunEnv = PostAdmissionEnv & {
-  principalAuthority: DurablePrincipalAuthority;
-  createRunId?: () => string;
-  /**
-   * Typed handoff from a caller that already holds a verified ticket key
-   * (countersign refresh / post-assert). Never derived from summons prose.
-   * When set: same-ticket resume under that key, else bind before the turn
-   * so identity is already on the run pages (ADR 0075 / 0081).
-   */
-  boundTicketNumber?: number;
-};
-
-/** Project admitted invocation onto the host-neutral turn request. */
-export function buildDiaristTurnRequest(
-  admitted: AdmittedDiaristInvocation,
-  options: RoleTurnRequestProjectionOptions,
-): RoleTurnRequest {
-  return projectRoleTurnRequest(
-    admitted,
-    { activation: { role: "diarist" as const } },
-    options,
-  );
-}
-
-/**
- * Board-bound ticket on pages → memory bind + unbound→ticket relocate under lease.
- * Shared by resume (interrupted board-bound unbound) and post-turn first assert.
- */
-async function bindAndRelocateDiaristIfBoardBound(
-  admitted: AdmittedDiaristInvocation,
-  authority: DiaristRunEnv["principalAuthority"],
-  lease?: RunWriterLease,
-): Promise<void> {
-  const boardTicket = await readBoardTicketNumber(admitted.runDirectory);
-  if (boardTicket === undefined) return;
-  if (admitted.ticketNumber === undefined) {
-    await bindAdmittedTicketNumber(admitted, boardTicket);
-  }
-  await relocateAdmittedRunToTicket(admitted, authority, lease);
-}
-
-function diaristAdapters(
-  env: DiaristRunEnv,
-): PostAdmissionAdapters<AdmittedDiaristInvocation> {
-  return {
-    trySettle: (admitted, authority, scope) =>
-      trySettleDiaristTerminalResult(admitted, authority, scope),
-    shouldPresentSettled: () => true,
-    // Resume interrupted state: board ticket already on pages, run still under unbound/.
-    beforeDispatch: async (admitted, lease) => {
-      if (env.correlationId !== undefined && env.correlationId.trim() !== "") {
-        await recordAdmittedCorrelation(admitted, env.correlationId);
-      }
-      await bindAndRelocateDiaristIfBoardBound(admitted, env.principalAuthority, lease);
-    },
-    // First post-turn assert: accept hook wrote board pages; relocate before lease release.
-    afterDispatch: async (admitted, lease) => {
-      await bindAndRelocateDiaristIfBoardBound(admitted, env.principalAuthority, lease);
-    },
-  };
-}
-
-export async function runPublicDiarist(
-  argv: readonly string[],
-  env: DiaristRunEnv,
-  io: CliIo,
-  parseDiaristArgv: (args: readonly string[]) => ParseDiaristArgvResult,
-): Promise<{
-  exitCode: number;
-  admitted?: AdmittedDiaristInvocation;
-  terminal?: TerminalResult;
-}> {
-  let parsed: ParseDiaristArgvResult;
-  try {
-    parsed = parseDiaristArgv(argv);
-  } catch (error) {
-    if (error instanceof CliUsageError) {
-      presentStructuralRejection(error, io);
-      return { exitCode: 2 };
-    }
-    throw error;
-  }
-
-  // #637 / #771 / ADR 0075 / #779 / #987: ticket identity is the LLM's typed
-  // assertion on this turn, OR a typed handoff key already held by the caller
-  // (countersign refresh bind). Code never pre-judges the summons text and never
-  // freezes a candidate catalog. Public same-ticket resume-by-ticketNumber was
-  // deleted (#987 Result 7); callers continue an existing diarist run only via
-  // explicit `ak-role resume <runId>`. Handoff ticket remains a bind key only.
-
-  const handoffTicket = env.boundTicketNumber;
-
-  let admitted: AdmittedDiaristInvocation;
-  try {
-    admitted = await admitDiaristInvocation({
-      home: env.home,
-      principalAuthority: env.principalAuthority,
-      cwd: env.cwd,
-      instruction: parsed.instruction,
-      attachmentPaths: parsed.attachmentPaths,
-      ...(parsed.project === undefined ? {} : { project: parsed.project }),
-      ...(env.createRunId === undefined ? {} : { createRunId: env.createRunId }),
-      ...(env.model === undefined ? {} : { model: env.model }),
-      ...(env.correlationId === undefined ? {} : { correlationId: env.correlationId }),
-      ...(handoffTicket === undefined ? {} : { assertedTicketNumber: handoffTicket }),
-    });
-  } catch (error) {
-    if (error instanceof CliUsageError) {
-      presentStructuralRejection(error, io);
-      return { exitCode: 2 };
-    }
-    throw error;
-  }
-
-  await markRunAdmitted(admitted, env.principalAuthority);
-
-
-  const turnProjection: RoleTurnRequestProjectionOptions = {
-    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: buildInstructionTransportPrompt(
-        admitted,
-        engineSessionMaterialFromOptions({
-          ...pickEngineAxis(env),
-          packageRoot: env.packageRoot,
-        }),
-      ),
-    },
-  };
-  const turnRequest = buildDiaristTurnRequest(admitted, turnProjection);
-
-  return await runPostAdmissionOneShot({
-    admitted,
-    env,
-    io,
-    request: turnRequest,
-    adapters: diaristAdapters(env),
-    ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
-  });
-}
-
-/**
- * Resume a previously admitted Diarist run (#708 / ADR 0079 同票传召 = resume).
- * LLM re-finds materials; entry identity keeps the volume idempotent.
- */
-export async function runPublicDiaristResume(
-  request: PublicResumeRequest,
-  env: DiaristRunEnv,
-  io: CliIo,
-): Promise<{
-  exitCode: number;
-  admitted?: AdmittedDiaristInvocation;
-  terminal?: TerminalResult;
-}> {
-  return await runPostAdmissionSeatResume({
-    request,
-    env,
-    io,
-    load: (effective) =>
-      loadResumableDiaristRun(env.home, effective.runId, env.principalAuthority),
-    buildTurnRequest: async (admitted, effective) => {
-      const summonsPrepared = await prepareSummonsResumeMaterials(
-        admitted.runDirectory,
-        effective.summons,
-      );
-      return buildDiaristTurnRequest(
-        admitted,
-        resumeTurnRequestProjectionOptions(
-          admitted,
-          effective,
-          env,
-          summonsPrepared,
-        ),
-      );
-    },
-    adapters: diaristAdapters(env),
-    ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
-  });
-}