@rallycry/conveyor-agent 11.0.5 → 11.0.7

package/dist/chunk-SR66HQKB.js

@@ -0,0 +1,464 @@
+import {
+  redactToken
+} from "./chunk-GL2DIQEQ.js";
+
+// src/boot/graphify.ts
+var USER_HOME_MOUNT = "/mnt/conveyor-users";
+function computeGraphifyEnv(env, repoName, dirExists) {
+  if (env.CONVEYOR_GRAPHIFY_DISABLE === "1") {
+    return {};
+  }
+  const slug = env.CONVEYOR_GRAPHIFY_SLUG || repoName;
+  if (!slug) {
+    return {};
+  }
+  const primaryRoot = `${USER_HOME_MOUNT}/users/_shared/graphify`;
+  const legacyRoot = `${USER_HOME_MOUNT}/_shared/graphify`;
+  let sharedRoot = env.CONVEYOR_GRAPHIFY_SHARED_ROOT;
+  if (!sharedRoot) {
+    sharedRoot = dirExists(primaryRoot) || !dirExists(legacyRoot) ? primaryRoot : legacyRoot;
+  }
+  const dir = env.CONVEYOR_GRAPHIFY_DIR || `${sharedRoot}/${slug}/latest`;
+  const graph = env.CONVEYOR_GRAPHIFY_GRAPH || `${dir}/graph.json`;
+  return {
+    CONVEYOR_GRAPHIFY_SLUG: slug,
+    CONVEYOR_GRAPHIFY_SHARED_ROOT: sharedRoot,
+    CONVEYOR_GRAPHIFY_DIR: dir,
+    CONVEYOR_GRAPHIFY_GRAPH: graph
+  };
+}
+
+// src/runner/session-runner-helpers.ts
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+function mapChatHistory(messages) {
+  if (!messages) return [];
+  return messages.map((m) => ({
+    id: m.id,
+    role: m.role ?? "user",
+    content: m.content ?? "",
+    userId: m.userId,
+    userName: m.user?.name ?? void 0,
+    createdAt: m.createdAt,
+    ...m.source ? { source: m.source } : {},
+    ...m.files && m.files.length > 0 ? {
+      files: m.files.map((f) => ({
+        fileId: f.id,
+        fileName: f.fileName,
+        mimeType: f.mimeType,
+        fileSize: f.fileSize,
+        downloadUrl: f.downloadUrl ?? "",
+        content: f.content,
+        contentEncoding: f.contentEncoding
+      }))
+    } : {}
+  }));
+}
+function readAgentVersion() {
+  try {
+    const here = dirname(fileURLToPath(import.meta.url));
+    for (const rel of ["../package.json", "../../package.json"]) {
+      try {
+        const pkg = JSON.parse(readFileSync(join(here, rel), "utf-8"));
+        if (pkg.version) return pkg.version;
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+
+// src/boot/workspace-extras.ts
+import {
+  appendFileSync,
+  cpSync,
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync as readFileSync2,
+  readlinkSync,
+  renameSync,
+  rmSync,
+  statSync,
+  symlinkSync
+} from "fs";
+import { dirname as dirname2, join as join2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function errText(err) {
+  return redactToken(err instanceof Error ? err.message : String(err));
+}
+function isDir(path) {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isSymlink(path) {
+  try {
+    return lstatSync(path).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+function isDanglingSymlink(path) {
+  return !existsSync(path) && isSymlink(path);
+}
+var GRAPHIFY_BUNDLE_FILES = [
+  "graph.json",
+  "GRAPH_REPORT.md",
+  "manifest.json",
+  ".graphify_analysis.json",
+  ".graphify_labels.json",
+  "publish-manifest.json",
+  "cost.json"
+];
+function bindGraphifyBundle(workspace, graphifyEnv, log) {
+  const slug = graphifyEnv.CONVEYOR_GRAPHIFY_SLUG;
+  const sourceDir = graphifyEnv.CONVEYOR_GRAPHIFY_DIR;
+  const graphFile = graphifyEnv.CONVEYOR_GRAPHIFY_GRAPH;
+  if (!slug || !sourceDir || !graphFile) return;
+  if (!existsSync(graphFile)) {
+    log.info(`[boot] Graphify bundle not found for '${slug}' at ${sourceDir}`);
+    return;
+  }
+  const targetDir = join2(workspace, "graphify-out");
+  try {
+    mkdirSync(targetDir, { recursive: true });
+  } catch {
+    log.warn(`[boot] WARN: unable to create graphify-out at ${targetDir}`);
+    return;
+  }
+  for (const rel of GRAPHIFY_BUNDLE_FILES) {
+    const source = join2(sourceDir, rel);
+    const target = join2(targetDir, rel);
+    if (!existsSync(source)) continue;
+    if (existsSync(target) || isSymlink(target)) continue;
+    try {
+      symlinkSync(source, target);
+    } catch {
+    }
+  }
+  log.info(`[boot] Bound graphify bundle '${slug}' into ${targetDir}`);
+}
+async function ensureGrimoireSubmodule(workspace, githubToken, git, log) {
+  try {
+    if (!existsSync(join2(workspace, ".gitmodules"))) return;
+    let paths = "";
+    try {
+      ({ stdout: paths } = await git(
+        ["config", "--file", ".gitmodules", "--get-regexp", String.raw`submodule\..*\.path`],
+        { cwd: workspace, timeoutMs: 1e4 }
+      ));
+    } catch {
+      return;
+    }
+    if (!paths.split("\n").some((line) => line.trim().endsWith(".claude/grimoire"))) return;
+    if (isDir(join2(workspace, ".claude", "grimoire", "skills"))) return;
+    if (!githubToken) {
+      log.warn("[boot] WARN: grimoire submodule absent and no token to fetch it");
+      return;
+    }
+    try {
+      await git(
+        [
+          "-c",
+          `url.https://x-access-token:${githubToken}@github.com/.insteadOf=https://github.com/`,
+          "submodule",
+          "update",
+          "--init",
+          ".claude/grimoire"
+        ],
+        { cwd: workspace, timeoutMs: 3e5 }
+      );
+      log.info("[boot] Initialized grimoire submodule");
+    } catch (err) {
+      log.warn(
+        `[boot] WARN: grimoire submodule init failed (baked pods may lack rc-* skills): ${errText(err)}`
+      );
+    }
+  } catch (err) {
+    log.warn(`[boot] WARN: grimoire submodule check failed: ${errText(err)}`);
+  }
+}
+function excludeLinkedSkills(workspace, names, log) {
+  if (names.length === 0) return;
+  const infoDir = join2(workspace, ".git", "info");
+  if (!isDir(join2(workspace, ".git"))) return;
+  try {
+    mkdirSync(infoDir, { recursive: true });
+    const excludePath = join2(infoDir, "exclude");
+    const existing = existsSync(excludePath) ? readFileSync2(excludePath, "utf8") : "";
+    const missing = names.map((name) => `.claude/skills/${name}`).filter((line) => !existing.split("\n").includes(line));
+    if (missing.length === 0) return;
+    const prefix = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
+    appendFileSync(excludePath, `${prefix}${missing.join("\n")}
+`);
+  } catch (err) {
+    log.warn(`[boot] WARN: unable to exclude grimoire skill links: ${errText(err)}`);
+  }
+}
+function symlinkTargetsGrimoire(path) {
+  try {
+    return readlinkSync(path).includes(join2("grimoire", "skills"));
+  } catch {
+    return false;
+  }
+}
+function linkGrimoireSkills(workspace, log) {
+  const sourceDir = join2(workspace, ".claude", "grimoire", "skills");
+  const targetDir = join2(workspace, ".claude", "skills");
+  if (!isDir(sourceDir)) return;
+  try {
+    mkdirSync(targetDir, { recursive: true });
+  } catch {
+    log.warn(`[boot] WARN: unable to create ${targetDir}; skipping grimoire skill links`);
+    return;
+  }
+  const linkedNames = [];
+  let names = [];
+  try {
+    names = readdirSync(sourceDir);
+  } catch {
+    return;
+  }
+  for (const name of names) {
+    if (!isDir(join2(sourceDir, name))) continue;
+    const target = join2(targetDir, name);
+    if (existsSync(target) && !isSymlink(target)) {
+      log.warn(`[boot] WARN: ${target} exists and is not a symlink; skipping`);
+      continue;
+    }
+    if (isSymlink(target) && !symlinkTargetsGrimoire(target)) continue;
+    try {
+      rmSync(target, { force: true });
+      symlinkSync(join2("..", "grimoire", "skills", name), target);
+      linkedNames.push(name);
+    } catch {
+    }
+  }
+  excludeLinkedSkills(workspace, linkedNames, log);
+  log.info(`[boot] Linked ${linkedNames.length} grimoire skills into ${targetDir}`);
+}
+function bundledSkillsDir(moduleUrl = import.meta.url) {
+  try {
+    const dir = join2(dirname2(fileURLToPath2(moduleUrl)), "..", "skills");
+    return isDir(dir) ? dir : null;
+  } catch {
+    return null;
+  }
+}
+var EMPTY_MATERIALIZE = { filled: [], shadowed: [], stale: [] };
+async function hideShadowedPins(workspace, names, git, log) {
+  if (names.length === 0) return;
+  const paths = names.map((name) => `.claude/skills/${name}`);
+  if (!git) {
+    log.warn(
+      `[boot] WARN: replaced skill pin(s) ${names.join(", ")} stay visible to git (no git runner supplied)`
+    );
+    return;
+  }
+  try {
+    await git(["update-index", "--assume-unchanged", ...paths], {
+      cwd: workspace,
+      timeoutMs: 1e4
+    });
+  } catch (err) {
+    log.warn(`[boot] WARN: unable to hide replaced skill pins from git: ${errText(err)}`);
+  }
+}
+function readlinkOr(path) {
+  try {
+    return readlinkSync(path);
+  } catch {
+    return "unknown target";
+  }
+}
+function fillOneSkill(sourceDir, targetDir, name, log) {
+  if (!isDir(join2(sourceDir, name))) return null;
+  const target = join2(targetDir, name);
+  const dangling = isDanglingSymlink(target);
+  if (!dangling && (existsSync(target) || isSymlink(target))) return null;
+  if (!dangling) {
+    try {
+      cpSync(join2(sourceDir, name), target, { recursive: true, dereference: true });
+      return "filled";
+    } catch {
+      return null;
+    }
+  }
+  log.warn(
+    `[boot] WARN: repo skill '${name}' pointed at a missing target (${readlinkOr(target)}); shadowing it with this agent build's bundled copy`
+  );
+  const staging = join2(targetDir, `.${name}.conveyor-staging`);
+  try {
+    rmSync(staging, { recursive: true, force: true });
+    cpSync(join2(sourceDir, name), staging, { recursive: true, dereference: true });
+    rmSync(target, { force: true });
+    renameSync(staging, target);
+    return "shadowed";
+  } catch (err) {
+    try {
+      rmSync(staging, { recursive: true, force: true });
+    } catch {
+    }
+    log.warn(
+      `[boot] WARN: could not replace dangling skill pin '${name}' (${errText(err)}) \u2014 it stays unusable in this session's skill registry`
+    );
+    return "stale";
+  }
+}
+function reportStalePins(targetDir, bundled, log) {
+  let present = [];
+  try {
+    present = readdirSync(targetDir);
+  } catch {
+    return [];
+  }
+  const stale = present.filter(
+    (name) => !bundled.has(name) && isDanglingSymlink(join2(targetDir, name))
+  );
+  for (const name of stale) {
+    log.warn(
+      `[boot] WARN: repo skill '${name}' is a dangling pin and this agent build has no bundled copy \u2014 it will not appear in the session's skill registry`
+    );
+  }
+  return stale;
+}
+async function materializeBundledSkills(workspace, log, sourceDirOverride, git) {
+  const sourceDir = sourceDirOverride === void 0 ? bundledSkillsDir() : sourceDirOverride;
+  if (!sourceDir) {
+    log.warn(
+      "[boot] WARN: no bundled skills payload in this agent build. Cloud modes that invoke a skill will have no workflow to follow. This is a packaging fault (tsup copySkillsPayload did not run), not a workspace problem."
+    );
+    return EMPTY_MATERIALIZE;
+  }
+  const targetDir = join2(workspace, ".claude", "skills");
+  try {
+    mkdirSync(targetDir, { recursive: true });
+  } catch {
+    log.warn(`[boot] WARN: unable to create ${targetDir}; skipping bundled skills`);
+    return EMPTY_MATERIALIZE;
+  }
+  const filled = [];
+  const shadowed = [];
+  const unreplaced = [];
+  let names = [];
+  try {
+    names = readdirSync(sourceDir);
+  } catch {
+    return EMPTY_MATERIALIZE;
+  }
+  for (const name of names) {
+    const outcome = fillOneSkill(sourceDir, targetDir, name, log);
+    if (outcome === "filled") filled.push(name);
+    else if (outcome === "shadowed") shadowed.push(name);
+    else if (outcome === "stale") unreplaced.push(name);
+  }
+  const stale = [...unreplaced, ...reportStalePins(targetDir, new Set(names), log)];
+  excludeLinkedSkills(workspace, [...filled, ...shadowed], log);
+  await hideShadowedPins(workspace, shadowed, git, log);
+  log.info(
+    `[boot] Materialized ${filled.length} bundled skills into ${targetDir}` + (shadowed.length > 0 ? `; replaced ${shadowed.length} dangling pin(s)` : "") + (stale.length > 0 ? `; ${stale.length} dangling pin(s) left unusable` : "")
+  );
+  return { filled, shadowed, stale };
+}
+function refreshSkillsAfterCheckout(workspace, git, log, sourceDirOverride) {
+  linkGrimoireSkills(workspace, log);
+  return materializeBundledSkills(workspace, log, sourceDirOverride, git);
+}
+async function neutralizeGrimoirePointer(workspace, git, log) {
+  if (!existsSync(join2(workspace, ".claude", "grimoire"))) return;
+  try {
+    await git(["update-index", "--assume-unchanged", ".claude/grimoire"], {
+      cwd: workspace,
+      timeoutMs: 1e4
+    });
+    log.info("[boot] Marked .claude/grimoire assume-unchanged (submodule pointer drift is noise)");
+  } catch (err) {
+    log.warn(`[boot] WARN: grimoire assume-unchanged failed: ${errText(err)}`);
+  }
+}
+function parseReferenceRepos(refsJson) {
+  let parsed;
+  try {
+    parsed = JSON.parse(refsJson);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(parsed)) return [];
+  const refs = [];
+  for (const entry of parsed) {
+    if (typeof entry !== "object" || entry === null) continue;
+    const raw = entry;
+    const str = (key) => typeof raw[key] === "string" ? raw[key] : "";
+    const ref = {
+      slug: str("slug"),
+      owner: str("owner"),
+      name: str("name"),
+      branch: str("branch") || "main",
+      token: str("token")
+    };
+    if (ref.token && ref.slug && ref.owner && ref.name) refs.push(ref);
+  }
+  return refs;
+}
+async function runPreReadyBinds(workspace, bundle, git, log) {
+  const graphifyEnv = computeGraphifyEnv(process.env, bundle.gitPlan.repoName, isDir);
+  bindGraphifyBundle(workspace, graphifyEnv, log);
+  await ensureGrimoireSubmodule(workspace, bundle.githubToken ?? "", git, log);
+  linkGrimoireSkills(workspace, log);
+  await materializeBundledSkills(workspace, log, void 0, git);
+  await neutralizeGrimoirePointer(workspace, git, log);
+}
+async function cloneReferenceRepos(refsJson, git, log, referencesDir = "/workspaces/references") {
+  if (!refsJson) return;
+  const refs = parseReferenceRepos(refsJson);
+  if (refs.length === 0) return;
+  try {
+    mkdirSync(referencesDir, { recursive: true });
+  } catch {
+    return;
+  }
+  for (const ref of refs) {
+    const dest = join2(referencesDir, ref.slug);
+    if (existsSync(join2(dest, ".git"))) continue;
+    try {
+      await git(
+        [
+          "clone",
+          "--depth",
+          "1",
+          "--single-branch",
+          "--branch",
+          ref.branch,
+          `https://x-access-token:${ref.token}@github.com/${ref.owner}/${ref.name}.git`,
+          dest
+        ],
+        { timeoutMs: 6e5 }
+      );
+      try {
+        await git(
+          ["remote", "set-url", "origin", `https://github.com/${ref.owner}/${ref.name}.git`],
+          { cwd: dest, timeoutMs: 1e4 }
+        );
+      } catch {
+      }
+      log.info(`[boot] cloned reference ${ref.slug} (${ref.owner}/${ref.name}@${ref.branch})`);
+    } catch {
+      log.warn(`[boot] WARN: reference clone failed: ${ref.slug}`);
+    }
+  }
+}
+
+export {
+  computeGraphifyEnv,
+  refreshSkillsAfterCheckout,
+  runPreReadyBinds,
+  cloneReferenceRepos,
+  mapChatHistory,
+  readAgentVersion
+};

package/dist/{chunk-EXQ6AHOY.js → chunk-TOTCEWJD.js}

@@ -138,6 +138,24 @@ var WorkbenchClient = class {
       );
     });
   }
+  /** Ask the workbench — which owns the repo filesystem in split mode — to
+   *  re-run the skill floor after the agent's authoritative task-branch
+   *  checkout. A daemon without a provider answers an empty result. */
+  refreshSkills() {
+    return new Promise((resolve, reject) => {
+      let result = null;
+      this.open(
+        { op: "refreshSkills" },
+        (frame) => {
+          if (frame.t === "refreshSkills") result = frame;
+        },
+        (error) => {
+          if (result) resolve(result);
+          else reject(error ?? new WorkbenchError("connection closed before refreshSkills"));
+        }
+      );
+    });
+  }
   /** Mirrors setup/commands.ts runSetupCommand (shell form, streamed output,
    *  abort → graceful term-group kill, non-zero exit rejects). */
   runSetupCommand(cmd, cwd, onOutput, signal) {

package/dist/cli.js

@@ -7,7 +7,7 @@ import {
   WorkspaceCommandSupervisor,
   startWorkspaceCommandsAfterConnect,
   stopWorkspaceCommands
-} from "./chunk-URYBO32C.js";
+} from "./chunk-43XITDZP.js";
 import {
   DEFAULT_SONNET_MODEL,
   PtyHarness,
@@ -27,13 +27,13 @@ import {
   resolveTuiKindFromEnv,
   runUsageProbe,
   sampleKeyUsage
-} from "./chunk-J2NPWBVZ.js";
-import "./chunk-XORJ6SII.js";
+} from "./chunk-NFNB2C35.js";
+import "./chunk-SR66HQKB.js";
 import {
   inheritedEnv,
   resolvePtySpawn,
   sessionTempBase
-} from "./chunk-W6VILPQE.js";
+} from "./chunk-JG3VMWRQ.js";
 import {
   AgentConnection,
   CodespacePortVisibility,
@@ -44,12 +44,12 @@ import {
   createServiceLogger,
   fetchBootstrap,
   loadConveyorConfig
-} from "./chunk-SLUBOIYE.js";
+} from "./chunk-APP6Y2D7.js";
 import "./chunk-GL2DIQEQ.js";
 import "./chunk-W4LZ7R6Z.js";
 import "./chunk-7P6QZHXZ.js";
 import "./chunk-IA45XHOA.js";
-import "./chunk-EXQ6AHOY.js";
+import "./chunk-TOTCEWJD.js";
 import "./chunk-KMB3BU4S.js";
 import "./chunk-6Q6LQBWO.js";
 
@@ -1201,7 +1201,7 @@ function wireSpawnChildren(mode, connection, supervisors, logger7) {
 
 // src/cli.ts
 if (process.argv[2] === "boot") {
-  const { runBoot } = await import("./boot-7XH4FFLO.js");
+  const { runBoot } = await import("./boot-SQKXI5NY.js");
   process.exit(await runBoot(process.argv.slice(3)));
 }
 if (isLegacyEntrypointLaunch(process.env)) {
@@ -1303,7 +1303,7 @@ process.on("unhandledRejection", (reason) => {
   process.exit(1);
 });
 if (process.env.CONVEYOR_MODE === "workbench") {
-  const { startWorkbenchServer } = await import("./server-2Z5V3IPA.js");
+  const { startWorkbenchServer } = await import("./server-2IZBKD3Q.js");
   const { oomWatchdogOptionsFromEnv } = await import("./oom-watchdog-PAC5OJJG.js");
   const { DEFAULT_WORKBENCH_PORT } = await import("./protocol-QBCYO4GI.js");
   const port = Number(process.env.CONVEYOR_WORKBENCH_PORT) || DEFAULT_WORKBENCH_PORT;
@@ -1454,7 +1454,7 @@ if (!RUNNER_MODES.includes(CONVEYOR_MODE)) {
   process.exit(1);
 }
 if (CONVEYOR_MODE === "serving") {
-  const { runServingSession } = await import("./serve-boot-B4BIZMNB.js");
+  const { runServingSession } = await import("./serve-boot-ESZKFN5M.js");
   exitContext.runnerMode = "serving";
   exitContext.sessionId = process.env.CONVEYOR_SESSION_ID ?? exitContext.sessionId;
   const outcome = await runServingSession({

package/dist/{client-IG6C5F2G.js → client-6AUPKKMV.js}

@@ -4,7 +4,7 @@ import {
   WorkbenchError,
   getWorkbenchClient,
   resetWorkbenchClient
-} from "./chunk-EXQ6AHOY.js";
+} from "./chunk-TOTCEWJD.js";
 import "./chunk-KMB3BU4S.js";
 import "./chunk-6Q6LQBWO.js";
 export {

package/dist/index.d.ts

@@ -131,6 +131,10 @@ declare class AgentConnection {
     private earlyProbeUsage;
     private ptyInputCallback;
     private ptyResizeCallback;
+    /** Epoch ms of the last relayed keystroke, or null before any input. The
+     *  question-grace expiry reads it to defer un-parking while a human is
+     *  actively typing into the Connected-TUI (they may be mid-answer). */
+    private _lastPtyInputAt;
     constructor(config: AgentConnectionConfig);
     get sessionId(): string;
     get connected(): boolean;
@@ -282,6 +286,8 @@ declare class AgentConnection {
      * just stays on the relay transport.
      */
     reportPtyStream(port: number | null): void;
+    /** Epoch ms of the last relayed TUI keystroke, or null before any. */
+    get lastPtyInputAt(): number | null;
     /** Subscribe to relayed keystrokes. Returns an unsubscribe fn. */
     onPtyInput(handler: (data: string) => void): () => void;
     /** Subscribe to relayed (reconciled) terminal resizes. Returns an unsubscribe fn. */
@@ -729,6 +735,18 @@ declare class SessionRunner {
     /** Guards the one-shot `agent_live` boot-milestone report — fired on the
      *  first harness event (createQueryBridge's onEvent hook). */
     private agentLiveReported;
+    /** Epoch ms since a TUI questionnaire has been parked on a human with no
+     *  answer; null when none is pending. While set (and within the grace +
+     *  slack bound) `resolveLoopStatus` reports `waiting`, which reaches the API
+     *  as `active` and keeps the workspace activity clock fresh — the pod must
+     *  not be slept out from under an unanswered question. Deliberately KEPT
+     *  when the turn ends with the questionnaire still parked (the Shape-B
+     *  silent death this hold exists for). */
+    private questionPendingSince;
+    /** Single-shot unref'd timer driving `handleQuestionGraceExpiry`. The
+     *  liveness hold above is bounded by timestamp arithmetic, so a lost timer
+     *  still expires the hold — it just skips the un-park injection. */
+    private questionGraceTimer;
     constructor(config: SessionRunnerConfig, callbacks: SessionRunnerCallbacks, deps?: SessionRunnerDependencies);
     get state(): AgentRunnerStatus;
     /**
@@ -833,6 +851,19 @@ declare class SessionRunner {
     run(): Promise<void>;
     /** Convenience wrapper: connect() then run(). */
     start(): Promise<void>;
+    /**
+     * Re-run the skill floor against the tree `ensureOnTaskBranch` just produced.
+     *
+     * Split-mode pods keep the repo in the WORKBENCH container, so this routes
+     * over the launcher: running it in-process here would materialize skills into
+     * the AGENT container's own copy of /workspaces/repo — still on the base
+     * branch, already complete — and look like it worked while Claude spawned on
+     * the untouched real tree. Codespaces/local (no workbench) run it directly.
+     *
+     * Best-effort by design: a failure warns and boot continues, exactly like the
+     * pre-ready binds it repeats.
+     */
+    private refreshSkillsForCheckout;
     private coreLoop;
     /**
      * Handle dormant-after-completed idle. Returns true if a critical message
@@ -1016,6 +1047,29 @@ declare class SessionRunner {
      * for why an unknown status still fails open to `active`.
      */
     private resolveLoopStatus;
+    /**
+     * Question-pending transitions from the event loop. `armed` starts the
+     * bounded liveness hold + the grace timer; `answered` clears both.
+     * `turn_ended` — the turn's result arrived with the questionnaire still
+     * parked — deliberately KEEPS them: that is the Shape-B silent death
+     * (idle heartbeats stop bumping the activity clock and the reconciler
+     * sleeps the pod minutes later) this hold exists to prevent.
+     */
+    private handleUserQuestionSignal;
+    private armQuestionGraceTimer;
+    private clearQuestionHold;
+    /**
+     * The grace expired with the questionnaire still unanswered. Un-park the
+     * agent by injecting the timeout prompt as a superseding system message —
+     * the proven supersede path (mid-turn: queue + queryBridge.stop(), teardown
+     * kills the parked dialog and the respawn `--resume`s cleanly; idle: the
+     * inputResolver picks it up). Never synthetic keypresses: Enter would
+     * fabricate an answer and Esc handling is CLI-version-dependent.
+     *
+     * A human actively typing in the Connected-TUI defers the expiry — they may
+     * be mid-answer, and superseding would yank the dialog out from under them.
+     */
+    private handleQuestionGraceExpiry;
     /** Mirror the resolved status into the loop-lag buffer so the starvation-proof
      *  heartbeat worker reports it too. Returns what it wrote. */
     private refreshLoopStatus;
@@ -1055,9 +1109,31 @@ interface AgentRunnerConfig {
      */
     packExecution?: _project_shared.PackExecution;
 }
+/**
+ * Question-pending transitions surfaced to the runner by the event loop
+ * (`applyQuestionTransitions` in execution/event-processor.ts):
+ *  - `armed` — the PTY hook observed an AskUserQuestion; a questionnaire is
+ *    parked on a human.
+ *  - `answered` — the questionnaire resolved (PostToolUse envelope, or a new
+ *    assistant record without the question block).
+ *  - `turn_ended` — the turn's `result` arrived while the questionnaire was
+ *    still parked. The dialog is still on screen with nobody answering — the
+ *    silent-death shape the question grace hold exists for — so the runner
+ *    must KEEP its pending hold rather than clear it.
+ */
+type UserQuestionSignal = {
+    kind: "armed";
+    questionText?: string;
+} | {
+    kind: "answered";
+} | {
+    kind: "turn_ended";
+};
 interface AgentRunnerCallbacks {
     onEvent: (event: Record<string, unknown>) => void | Promise<void>;
     onStatusChange: (status: string) => void | Promise<void>;
+    /** Optional — fired on question-pending transitions (see UserQuestionSignal). */
+    onUserQuestion?: (signal: UserQuestionSignal) => void;
 }
 
 interface GithubTokenFileSync {