@akagilnc/pi-workflow-roles 0.1.3718 → 0.1.3733

package/dist/acp-host/seat-profile-soul.js

@@ -0,0 +1,78 @@
+/**
+ * Seat-scoped host profile soul delivery (#644 / 拍 2).
+ *
+ * Hermes has no per-session systemPrompt channel; identity is the profile's
+ * SOUL.md. Each seat owns `profiles/<namePrefix><role>/`, and SOUL.md is a
+ * symlink to the packaged `souls/<role>.md` (package is the sole soul source).
+ */
+import { constants } from "node:fs";
+import { access, copyFile, lstat, mkdir, readlink, symlink, unlink } from "node:fs/promises";
+import { dirname, join, relative, resolve } from "node:path";
+/** Profile id for one seat role. */
+export function seatProfileName(spec, role) {
+    return `${spec.namePrefix}${role}`;
+}
+/** Packaged soul path for one role (`souls/<role>.md`). */
+export function packageRoleSoulPath(packageRoot, role) {
+    return join(packageRoot, "souls", `${role}.md`);
+}
+async function pathExists(path) {
+    try {
+        await access(path, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Ensure the seat profile directory exists and SOUL.md is a symlink to the
+ * packaged role soul. On first create, copy credential surfaces from the host
+ * root (parent of the profiles root) so the profile can authenticate without
+ * touching the default profile in place. Returns the profile id for argv.
+ */
+export async function ensureSeatProfileSoul(options) {
+    const { spec, operatorHome, packageRoot, role } = options;
+    const profileName = seatProfileName(spec, role);
+    const soulTarget = resolve(packageRoleSoulPath(packageRoot, role));
+    if (!(await pathExists(soulTarget))) {
+        throw new Error(`packaged role soul missing: ${soulTarget}`);
+    }
+    const profilesRoot = join(operatorHome, ...spec.profilesRootFromHome);
+    const profileDir = join(profilesRoot, profileName);
+    const hostRoot = dirname(profilesRoot);
+    const soulPath = join(profileDir, spec.soulFileName);
+    if (!(await pathExists(profileDir))) {
+        await mkdir(profileDir, { recursive: true });
+        // First-create credential bootstrap only. Never rewrite an existing profile's
+        // auth/config; never write into the host root / default profile.
+        for (const name of ["auth.json", ".env", "config.yaml"]) {
+            const source = join(hostRoot, name);
+            if (!(await pathExists(source)))
+                continue;
+            await copyFile(source, join(profileDir, name));
+        }
+    }
+    else {
+        await mkdir(profileDir, { recursive: true });
+    }
+    const desiredLink = relative(profileDir, soulTarget);
+    let current;
+    try {
+        const st = await lstat(soulPath);
+        if (st.isSymbolicLink()) {
+            current = await readlink(soulPath);
+        }
+    }
+    catch {
+        current = undefined;
+    }
+    if (current === desiredLink || current === soulTarget) {
+        return profileName;
+    }
+    if (await pathExists(soulPath) || current !== undefined) {
+        await unlink(soulPath);
+    }
+    await symlink(desiredLink, soulPath);
+    return profileName;
+}

package/dist/auditor-dossier-tool.js

@@ -1,5 +1,6 @@
 import { mkdirSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
+import { readableGateItem } from "./readable-gate-item.js";
 import { Type } from "typebox";
 const AUDITOR_DOSSIER_TOOL_NAME = "ak_get_run_dossier";
 const GATE_SUBMISSION_CANDIDATE_FILE = "gate-submission-candidate.json";
@@ -29,16 +30,20 @@ function readLatestToolCallLeaf(context) {
 function gateSubmissionCandidatePath(runDirectory) {
   return join(runDirectory, "artifacts", GATE_SUBMISSION_CANDIDATE_FILE);
 }
-function buildGateOfficerReviewInstruction(input) {
-  const lines = [
-    "\u672C\u8F6E\u7236\u5E2D\u4EA4\u5377\u5F85\u5BA1\u3002",
-    `\u6765\u6E90 run\uFF1A${input.sourceRunDirectory}`
-  ];
-  const candidate = input.submissionCandidatePath?.trim();
-  if (candidate !== void 0 && candidate.length > 0) {
-    lines.push(`\u4EA4\u5377\u5019\u9009\uFF08\u51BB\u7ED3\u5FEB\u7167\uFF09\uFF1A${candidate}`);
+function readLatestSubmissionArguments(context) {
+  const leaf = readLatestToolCallLeaf(context);
+  if (!isRecord(leaf) || !isRecord(leaf.message) || !Array.isArray(leaf.message.content)) {
+    return void 0;
+  }
+  for (const part of leaf.message.content) {
+    if (isRecord(part) && part.type === "toolCall" && "arguments" in part) {
+      return part.arguments;
+    }
   }
-  return lines.join("\n");
+  return void 0;
+}
+function buildGateOfficerReviewInstruction(input) {
+  return readableGateItem(input.submission);
 }
 function persistGateSubmissionCandidate(runDirectory, context) {
   const leaf = readLatestToolCallLeaf(context);
@@ -86,5 +91,6 @@ export {
   createAuditorDossierTool,
   gateSubmissionCandidatePath,
   persistGateSubmissionCandidate,
+  readLatestSubmissionArguments,
   readLatestToolCallLeaf
 };

package/dist/gatekeeper-role.js

@@ -1,4 +1,4 @@
-import { auditorRunDirectory, persistGateSubmissionCandidate, } from "./auditor-dossier-tool.js";
+import { auditorRunDirectory, persistGateSubmissionCandidate, readLatestSubmissionArguments, } from "./auditor-dossier-tool.js";
 import { GatekeeperDecisionError } from "./submission-errors.js";
 import { INSPECTOR_OUTPUT_TOOL_NAME } from "./inspector-contracts.js";
 import { GATEKEEPER_OUTPUT_TOOL_NAME, gatekeeperDecisionSchema, gatekeeperOutputSchema, } from "./package-contracts/gatekeeper-output.js";
@@ -173,14 +173,15 @@ export async function projectGatekeeperRun(options) {
             },
         };
     }
-    // Pointer-only summons need a resolvable leaf: Grok session.jsonl is header-only
-    // (#617 DK-4); write the in-memory tool-call candidate as a run artifact first (#632).
-    // Candidate path also rides same-parent officer resume as 人读材料 (#753 / #750).
-    const submissionCandidatePath = persistGateSubmissionCandidate(runDirectory, options.context);
+    // #632: Grok session.jsonl is header-only — freeze the in-memory tool-call leaf
+    // as a run artifact so dossier exploration still resolves. LLM→LLM resume does
+    // not ride this path: submission body goes verbatim on gateReviewInstruction (#786).
+    persistGateSubmissionCandidate(runDirectory, options.context);
+    const submission = readLatestSubmissionArguments(options.context);
     let summoned;
     try {
         const summon = options.summonOfficer
-            ?? (async (nextOfficer, sourceRunDirectory, officerSignal, reask) => {
+            ?? (async (nextOfficer, sourceRunDirectory, officerSignal, reask, nextSubmission) => {
                 const { summonGateOfficer } = await import("./public-role-summons.js");
                 return summonGateOfficer({
                     officer: nextOfficer,
@@ -188,12 +189,14 @@ export async function projectGatekeeperRun(options) {
                     cwd: options.context.cwd ?? process.cwd(),
                     ...(officerSignal === undefined ? {} : { signal: officerSignal }),
                     ...(reask === undefined ? {} : { reask }),
-                    ...(submissionCandidatePath === undefined
-                        ? {}
-                        : { submissionCandidatePath }),
+                    ...(nextSubmission === undefined ? {} : { submission: nextSubmission }),
+                    ...(options.home === undefined ? {} : { home: options.home }),
+                    ...(options.packageRoot === undefined ? {} : { packageRoot: options.packageRoot }),
+                    ...(options.roleTurnHost === undefined ? {} : { roleTurnHost: options.roleTurnHost }),
+                    ...(options.createRunId === undefined ? {} : { createRunId: options.createRunId }),
                 });
             });
-        summoned = await summon(officer, runDirectory, options.signal, options.reask);
+        summoned = await summon(officer, runDirectory, options.signal, options.reask, submission);
     }
     catch (error) {
         return {

package/dist/host-descriptions.js

@@ -10,6 +10,7 @@ export const HOST_DESCRIPTIONS = Object.freeze({
             suffix: Object.freeze(["stdio"]),
             modelFlag: "--model",
         }),
+        modelPassing: "argv",
         boundResume: "session/load",
         sessionBindingFile: "grok-acp-session.json",
         childEnv: Object.freeze({
@@ -18,6 +19,31 @@ export const HOST_DESCRIPTIONS = Object.freeze({
             GROK_SUBAGENTS: "0",
         }),
     }),
+    /**
+     * Operator home `~/.hermes`, native session/load resume, `acp` subcommand.
+     * Model arrives as an ACP `session/set_model` RPC with modelId `provider:model`
+     * (seat table provider + model concatenated). Reasoning is the global
+     * `--reasoning` flag before `acp`. Soul is the seat profile SOUL.md symlink
+     * (`hermes -p ak-<role> …`); package `souls/<role>.md` is the sole source.
+     */
+    "hermes": Object.freeze({
+        binaryFromHome: Object.freeze([".local", "bin", "hermes"]),
+        argv: Object.freeze({
+            prefix: Object.freeze(["acp"]),
+            suffix: Object.freeze([]),
+            thinkingFlag: "--reasoning",
+        }),
+        modelPassing: "set_model",
+        boundResume: "session/load",
+        sessionBindingFile: "hermes-acp-session.json",
+        childEnv: Object.freeze({}),
+        seatProfileSoul: Object.freeze({
+            flag: "-p",
+            namePrefix: "ak-",
+            profilesRootFromHome: Object.freeze([".hermes", "profiles"]),
+            soulFileName: "SOUL.md",
+        }),
+    }),
 });
 export function lookupHostDescription(host) {
     return Object.hasOwn(HOST_DESCRIPTIONS, host) ? HOST_DESCRIPTIONS[host] : undefined;

package/dist/public-cli/inspector-run.js

@@ -31,7 +31,7 @@ export async function runPublicInspector(argv, env, io, parseInspectorArgv) {
     // No bare catch→fresh: lookup/resume failures surface; only true absence mints new.
     const projectRoot = parsed.project ?? env.cwd;
     // #747: parentRunPath is the pure 卷宗指针 path only — never reask/materials text.
-    // #753: gate re-ask / new-submission pointers ride summons.instruction on resume.
+    // #753/#786: gate re-ask / verbatim submission body ride summons.instruction on resume.
     const parentRunPath = parentRunPathFromGatePointerInstruction(parsed.instruction);
     if (parentRunPath !== undefined) {
         const resumeInstruction = env.reviewReask ?? env.gateReviewInstruction;
@@ -57,7 +57,7 @@ export async function runPublicInspector(argv, env, io, parseInspectorArgv) {
             return resumed;
         // Reask without a prior same-parent run cannot deliver the plain-language ask
         // on a fresh mint without inventing a second prompt path — fail loud (#753).
-        // gateReviewInstruction alone is resume-only; fresh mint keeps argv 卷宗指针.
+        // gateReviewInstruction (verbatim body) alone is resume-only; fresh mint keeps argv 卷宗指针.
         if (env.reviewReask !== undefined) {
             presentStructuralRejection(new CliUsageError("inspector review reask requires a prior same-parent run to resume"), io);
             return { exitCode: 2 };

package/dist/public-cli/instruction-seat-run.js

@@ -150,7 +150,7 @@ export async function runPublicInstructionSeat(argv, env, io, role, parseArgv) {
             return { exitCode: 2 };
         }
     }
-    // #756: auditor reask / new-submission pointers ride summons.instruction on resume.
+    // #756/#786: auditor reask / verbatim submission body ride summons.instruction on resume.
     const resumeInstruction = env.reviewReask ?? env.gateReviewInstruction;
     const summons = {
         ...(resumeInstruction === undefined

package/dist/public-cli/main.js

@@ -15446,6 +15446,7 @@ var init_host_descriptions = __esm({
           suffix: Object.freeze(["stdio"]),
           modelFlag: "--model"
         }),
+        modelPassing: "argv",
         boundResume: "session/load",
         sessionBindingFile: "grok-acp-session.json",
         childEnv: Object.freeze({
@@ -15453,6 +15454,31 @@ var init_host_descriptions = __esm({
           GROK_MEMORY: "0",
           GROK_SUBAGENTS: "0"
         })
+      }),
+      /**
+       * Operator home `~/.hermes`, native session/load resume, `acp` subcommand.
+       * Model arrives as an ACP `session/set_model` RPC with modelId `provider:model`
+       * (seat table provider + model concatenated). Reasoning is the global
+       * `--reasoning` flag before `acp`. Soul is the seat profile SOUL.md symlink
+       * (`hermes -p ak-<role> …`); package `souls/<role>.md` is the sole source.
+       */
+      "hermes": Object.freeze({
+        binaryFromHome: Object.freeze([".local", "bin", "hermes"]),
+        argv: Object.freeze({
+          prefix: Object.freeze(["acp"]),
+          suffix: Object.freeze([]),
+          thinkingFlag: "--reasoning"
+        }),
+        modelPassing: "set_model",
+        boundResume: "session/load",
+        sessionBindingFile: "hermes-acp-session.json",
+        childEnv: Object.freeze({}),
+        seatProfileSoul: Object.freeze({
+          flag: "-p",
+          namePrefix: "ak-",
+          profilesRootFromHome: Object.freeze([".hermes", "profiles"]),
+          soulFileName: "SOUL.md"
+        })
       })
     });
   }
@@ -21973,6 +21999,7 @@ var init_method_skill = __esm({
 var init_auditor_dossier_tool = __esm({
   "src/auditor-dossier-tool.ts"() {
     "use strict";
+    init_readable_gate_item();
     init_build();
   }
 });

package/dist/public-cli/notary-run.js

@@ -52,7 +52,7 @@ export async function runPublicNotary(argv, env, io, parseNotaryArgv) {
         throw error;
     }
     // #747: officer resume key is this parent source-run path (not ticket number).
-    // #753: gate re-ask and new-submission pointers share summons.instruction
+    // #753/#786: gate re-ask and verbatim submission body share summons.instruction
     // (reask wins when both present; no parallel stack).
     {
         const resumeInstruction = env.reviewReask ?? env.gateReviewInstruction;
@@ -76,7 +76,7 @@ export async function runPublicNotary(argv, env, io, parseNotaryArgv) {
             return resumed;
         // Reask without a prior same-parent run cannot deliver the plain-language ask
         // on a fresh mint without inventing a second prompt path — fail loud (#753).
-        // gateReviewInstruction alone is resume-only materials; fresh mint ignores it.
+        // gateReviewInstruction (verbatim body) alone is resume-only; fresh mint ignores it.
         if (env.reviewReask !== undefined) {
             presentStructuralRejection(new CliUsageError("notary review reask requires a prior same-parent run to resume"), io);
             return { exitCode: 2 };

package/dist/public-role-summons.js

@@ -165,8 +165,11 @@ async function summonPublicRole(options) {
     ...options.signal === void 0 ? {} : { signal: options.signal },
     // #753: reask rides the existing notary same-ticket resume summons.instruction.
     ...options.reviewReask === void 0 ? {} : { reviewReask: options.reviewReask },
-    // #753/#750: new-submission pointers on same-parent resume (not conclusion re-ask).
-    ...options.gateReviewInstruction === void 0 ? {} : { gateReviewInstruction: options.gateReviewInstruction }
+    // #786: verbatim submission body on same-parent resume (not conclusion re-ask).
+    ...options.gateReviewInstruction === void 0 ? {} : { gateReviewInstruction: options.gateReviewInstruction },
+    // Offline test injects — same faces as public CLI env (production leaves unset).
+    ...options.roleTurnHost === void 0 ? {} : { roleTurnHost: options.roleTurnHost },
+    ...options.createRunId === void 0 ? {} : { createRunId: options.createRunId }
   };
   const captured = options.io === void 0 ? createCapturingIo() : void 0;
   const io = options.io ?? captured.io;
@@ -263,11 +266,10 @@ async function summonGateOfficer(options) {
     home = homeFromRunDirectory(options.sourceRunDirectory);
   }
   let gateReviewInstruction;
-  if (options.reask === void 0) {
+  if (options.reask === void 0 && options.submission !== void 0) {
     const { buildGateOfficerReviewInstruction } = await import("./auditor-dossier-tool.js");
     gateReviewInstruction = buildGateOfficerReviewInstruction({
-      sourceRunDirectory: options.sourceRunDirectory,
-      ...options.submissionCandidatePath === void 0 ? {} : { submissionCandidatePath: options.submissionCandidatePath }
+      submission: options.submission
     });
   }
   const common = {
@@ -277,7 +279,9 @@ async function summonGateOfficer(options) {
     ...options.io === void 0 ? {} : { io: options.io },
     ...options.signal === void 0 ? {} : { signal: options.signal },
     ...options.reask === void 0 ? {} : { reviewReask: options.reask },
-    ...gateReviewInstruction === void 0 ? {} : { gateReviewInstruction }
+    ...gateReviewInstruction === void 0 ? {} : { gateReviewInstruction },
+    ...options.roleTurnHost === void 0 ? {} : { roleTurnHost: options.roleTurnHost },
+    ...options.createRunId === void 0 ? {} : { createRunId: options.createRunId }
   };
   if (options.officer === "notary") {
     return summonPublicRole({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akagilnc/pi-workflow-roles",
-  "version": "0.1.3718",
+  "version": "0.1.3733",
   "description": "Soul-bound workflow roles for Pi",
   "type": "module",
   "license": "Apache-2.0",

package/src/acp-host/description.ts

@@ -1,10 +1,13 @@
 /**
  * One ACP host description. Every host-specific value the generic ACP adapter
- * needs — binary location, argv shape, resume verb, binding filename, child env
- * — is data here; the lifecycle in role-turn-host.ts stays one copy (#732).
+ * needs — binary location, argv shape, resume verb, binding filename, child env,
+ * optional seat-profile soul — is data here; the lifecycle in role-turn-host.ts
+ * stays one copy (#732).
  */
 import { join } from "node:path";
 
+import type { SeatProfileSoul } from "./seat-profile-soul.ts";
+
 export type AcpHostDescription = Readonly<{
   /** Binary path segments relative to the operator home. */
   binaryFromHome: readonly string[];
@@ -12,13 +15,28 @@ export type AcpHostDescription = Readonly<{
     prefix: readonly string[];
     suffix: readonly string[];
     modelFlag?: string;
+    /** CLI flag whose value is the seat thinking level; placed before `prefix`
+     * so it lands ahead of the subcommand (hermes global `--reasoning`). */
     thinkingFlag?: string;
   }>;
+  /**
+   * How the seat model reaches the agent:
+   * - "argv": passed as the CLI `--model` flag (grok);
+   * - "set_model": sent as an ACP `session/set_model` RPC with modelId
+   *   `provider:model` (hermes).
+   */
+  modelPassing: "argv" | "set_model";
   /** Which verb a bound resume uses; "session/new" hosts always mint + bind. */
   boundResume: "session/load" | "session/new";
   /** Durable ACP binding filename written beside the session principal. */
   sessionBindingFile: string;
   childEnv: Readonly<Record<string, string>>;
+  /**
+   * When set, the production factory ensures a seat profile whose SOUL.md is a
+   * symlink to the packaged role soul, and prefixes argv with `flag <name>`.
+   * Used by hosts that have no per-session systemPrompt channel (hermes).
+   */
+  seatProfileSoul?: SeatProfileSoul;
 }>;
 
 /** Absolute agent binary for one operator home. */
@@ -26,18 +44,35 @@ export function resolveAcpBinary(description: AcpHostDescription, operatorHome:
   return join(operatorHome, ...description.binaryFromHome);
 }
 
-/** Stdio argv: prefix, optional model/thinking flag pairs, suffix. */
+/** Stdio argv: optional profile flag, thinking flag (before the subcommand),
+ * prefix, optional model flag pair, suffix. */
 export function acpStdioArgs(
   description: AcpHostDescription,
   model?: { readonly model?: string; readonly thinking?: string },
+  seat?: { readonly profileName?: string },
 ): string[] {
   const { prefix, suffix, modelFlag, thinkingFlag } = description.argv;
   const pair = (flag: string | undefined, value: string | undefined): string[] =>
     flag === undefined || value === undefined ? [] : [flag, value];
   return [
+    ...pair(description.seatProfileSoul?.flag, seat?.profileName),
+    ...pair(thinkingFlag, model?.thinking),
     ...prefix,
     ...pair(modelFlag, model?.model),
-    ...pair(thinkingFlag, model?.thinking),
     ...suffix,
   ];
 }
+
+/**
+ * The modelId the host addresses the seat model by.
+ * "argv" hosts address by bare model name; "set_model" hosts address by the
+ * `provider:model` modelId the ACP catalog exposes (seat provider after host
+ * alias projection, concatenated — never a package provider map).
+ */
+export function acpModelId(
+  modelPassing: AcpHostDescription["modelPassing"],
+  model?: { readonly model?: string; readonly provider?: string },
+): string | undefined {
+  if (model?.model === undefined) return undefined;
+  return modelPassing === "set_model" ? `${model.provider}:${model.model}` : model.model;
+}

package/src/acp-host/production-host.ts

@@ -27,6 +27,7 @@ import { loadGatekeeperSessionMaterials, loadMainRoleSessionMaterials } from "..
 import { acpStdioArgs, resolveAcpBinary, type AcpHostDescription } from "./description.ts";
 import { createComposedAcpRoleTurnHost } from "./role-envelope.ts";
 import { connectAcpStdio } from "./role-turn-host.ts";
+import { ensureSeatProfileSoul } from "./seat-profile-soul.ts";
 import { createAcpSessionIdentityAuthority } from "./session-identity.ts";
 
 export type ProductionAcpHostOptions = Readonly<{
@@ -121,11 +122,25 @@ export function createProductionAcpRoleTurnHost(options: ProductionAcpHostOption
   return createComposedAcpRoleTurnHost({
     sessionIdentity: createAcpSessionIdentityAuthority(principalAuthority, description.sessionBindingFile),
     boundResume: description.boundResume,
+    modelPassing: description.modelPassing,
     roleRuntimeDependencies: createAcpRoleRuntimeDependencies(packageRoot),
     async connect(request) {
+      const seatProfile = description.seatProfileSoul;
+      const profileName = seatProfile === undefined
+        ? undefined
+        : await ensureSeatProfileSoul({
+          spec: seatProfile,
+          operatorHome: request.home,
+          packageRoot,
+          role: request.activation.role,
+        });
       return connectAcpStdio({
         binary: resolveAcpBinary(description, request.home),
-        args: acpStdioArgs(description, request.model),
+        args: acpStdioArgs(
+          description,
+          request.model,
+          profileName === undefined ? undefined : { profileName },
+        ),
         cwd: request.cwd,
         env,
       });

package/src/acp-host/role-envelope.ts

@@ -622,7 +622,8 @@ export async function prepareAcpRoleEnvelope(options: {
   };
 
   // Shared envelope activation. systemPrompt must be ready before session/new
-  // (ACP delivers it there), so activation runs during prepare.
+  // (delivered via _meta.systemPromptOverride where the host honors it), so
+  // activation runs during prepare.
   try {
     await emit("session_start", { reason: request.continuation.kind });
     const inputResults = await emit("input", { text: request.continuation.prompt, source: "interactive" });

package/src/acp-host/role-turn-host.ts

@@ -3,7 +3,7 @@ import { createInterface } from "node:readline";
 
 import type { RoleTurnHost, RoleTurnKnownFailure, RoleTurnRequest, RoleTurnResult } from "../host-contracts.ts";
 import { renderAgentStartMaterials } from "../agent-start-materials.ts";
-import type { AcpHostDescription } from "./description.ts";
+import { acpModelId, type AcpHostDescription } from "./description.ts";
 
 /** ACP v1 surface used by the generic ACP adapter. Protocol details stay in this module. */
 export interface AcpConnection {
@@ -64,6 +64,12 @@ export type AcpRoleTurnHostConfig = Readonly<{
   sessionIdentity: AcpSessionIdentityAuthority;
   /** Whether a bound resume reuses the native session or mints a fresh one. */
   boundResume: AcpHostDescription["boundResume"];
+  /**
+   * How the seat model reaches the agent: "set_model" sends an ACP
+   * `session/set_model` RPC with modelId `provider:model` once the session
+   * exists (new or loaded); "argv" leaves it to the connect argv (--model).
+   */
+  modelPassing: AcpHostDescription["modelPassing"];
   connect(request: RoleTurnRequest): Promise<AcpConnection>;
   prepare(request: RoleTurnRequest): Promise<AcpPreparedTurn>;
 }>;
@@ -201,6 +207,7 @@ export function createAcpRoleTurnHost(config: AcpRoleTurnHostConfig): RoleTurnHo
       const execution = serial.then(async (): Promise<RoleTurnResult> => {
         const continuation = request.continuation;
         const prepared = await config.prepare(request);
+        const systemPromptOverride = renderAcpSystemPromptOverride(prepared.systemPrompt);
         let connection: AcpConnection | undefined;
         let sessionId: string | undefined;
         let accepted = false;
@@ -220,7 +227,8 @@ export function createAcpRoleTurnHost(config: AcpRoleTurnHostConfig): RoleTurnHo
           const modelState = initializeMeta?.modelState;
           const availableModels = Array.isArray(modelState?.availableModels) ? modelState.availableModels : undefined;
           if (request.model !== undefined && availableModels !== undefined && !availableModels.some((entry) =>
-            typeof entry === "object" && entry !== null && (entry as { modelId?: unknown }).modelId === request.model?.model)) {
+            typeof entry === "object" && entry !== null
+            && (entry as { modelId?: unknown }).modelId === acpModelId(config.modelPassing, request.model))) {
             return failure("activation", "AcpHostModelMismatch", "host-model-mismatch", {
               provider: request.model.provider,
               model: request.model.model,
@@ -233,32 +241,33 @@ export function createAcpRoleTurnHost(config: AcpRoleTurnHostConfig): RoleTurnHo
             continuation.kind === "resume"
               ? request.hostTransition?.priorNativePaths
               : undefined;
+          const loadConnection = connection;
+          // Shared session/new + session/load body (cwd/mcpServers/_meta).
+          const sessionBindParams = {
+            cwd: request.cwd,
+            mcpServers: prepared.mcpServers,
+            _meta: { systemPromptOverride, yoloMode: false },
+          };
+          const loadSession = async (bindSessionId: string): Promise<string> => {
+            const loaded = await loadConnection.request("session/load", {
+              sessionId: bindSessionId,
+              ...sessionBindParams,
+            });
+            return typeof loaded.sessionId === "string" && loaded.sessionId !== ""
+              ? loaded.sessionId
+              : bindSessionId;
+          };
           if (continuation.kind === "resume" && config.boundResume === "session/load") {
             // Same-host resume reuses the native ACP session via session/load.
             const boundSessionId = await config.sessionIdentity.load(request.principal);
             if (boundSessionId !== undefined && boundSessionId !== "") {
-              const loaded = await connection.request("session/load", {
-                sessionId: boundSessionId,
-                cwd: request.cwd,
-                mcpServers: prepared.mcpServers,
-                _meta: { systemPromptOverride: renderAcpSystemPromptOverride(prepared.systemPrompt), yoloMode: false },
-              });
-              sessionId = typeof loaded.sessionId === "string" && loaded.sessionId !== ""
-                ? loaded.sessionId
-                : boundSessionId;
+              sessionId = await loadSession(boundSessionId);
             }
           }
           if (sessionId === undefined) {
             // Initial run, unbound resume (cross-host / lost binding), or a host
             // whose bound resume is session/new: mint the session and bind it.
-            const session = await connection.request(
-              "session/new",
-              {
-                cwd: request.cwd,
-                mcpServers: prepared.mcpServers,
-                _meta: { systemPromptOverride: renderAcpSystemPromptOverride(prepared.systemPrompt), yoloMode: false },
-              },
-            );
+            const session = await connection.request("session/new", sessionBindParams);
             sessionId = typeof session.sessionId === "string" ? session.sessionId : undefined;
             if (sessionId === undefined || sessionId === "") {
               return failure("session", "AcpSessionFailure", "session-id-missing");
@@ -266,6 +275,24 @@ export function createAcpRoleTurnHost(config: AcpRoleTurnHostConfig): RoleTurnHo
             await config.sessionIdentity.bind(request.principal, sessionId);
           }
 
+          // set_model hosts address the seat model by `provider:model` once the
+          // session exists; argv hosts never reach this RPC. Provider is the seat
+          // table value after owner host-alias projection (#778) — concatenated
+          // here, never dropped, never remapped in package code. set_model may
+          // rebuild the session agent and drop ACP-injected mcpServers, so re-bind
+          // via the same loadSession authority (return value is the live session id).
+          if (
+            config.modelPassing === "set_model"
+            && request.model !== undefined
+            && sessionId !== undefined
+          ) {
+            await connection.request("session/set_model", {
+              sessionId,
+              modelId: acpModelId(config.modelPassing, request.model),
+            });
+            sessionId = await loadSession(sessionId);
+          }
+
           let prompt =
             priorNativePaths !== undefined && priorNativePaths.length > 0
               ? `${prepared.prompt}\n${priorNativePaths.join("\n")}`
@@ -319,12 +346,9 @@ export function createAcpRoleTurnHost(config: AcpRoleTurnHostConfig): RoleTurnHo
           for (let attempt = 0; attempt < 8; attempt += 1) {
             let result: Readonly<Record<string, unknown>>;
             try {
-              const promptParts: Array<Record<string, unknown>> = [
-                { type: "text", text: prompt },
-              ];
               result = await promptOrAbort({
                 sessionId,
-                prompt: promptParts,
+                prompt: [{ type: "text", text: prompt }],
               });
             } catch (error) {
               // Envelope abort (typed infra declaration): closeRound owns the failure record.