@rallycry/conveyor-agent 11.0.5 → 11.0.7

package/dist/{chunk-J2NPWBVZ.js → chunk-NFNB2C35.js}

@@ -1,7 +1,8 @@
 import {
   mapChatHistory,
-  readAgentVersion
-} from "./chunk-XORJ6SII.js";
+  readAgentVersion,
+  refreshSkillsAfterCheckout
+} from "./chunk-SR66HQKB.js";
 import {
   MAX_BETWEEN_TURN_BUFFER,
   MAX_DIAGNOSTIC_OUTPUT,
@@ -28,7 +29,7 @@ import {
   spawnOptionsFingerprint,
   transcriptSize,
   turnOptionsFrom
-} from "./chunk-W6VILPQE.js";
+} from "./chunk-JG3VMWRQ.js";
 import {
   AgentConnection,
   CodespacePortVisibility,
@@ -44,6 +45,7 @@ import {
   forceFreshCooldownNotice,
   forceFreshMintBlocked,
   getCurrentBranch,
+  git,
   hasUncommittedChanges,
   hasUnpushedCommits,
   pushToOrigin,
@@ -57,7 +59,7 @@ import {
   statWorkspacePath,
   updateRemoteToken,
   verifyGitCredential
-} from "./chunk-SLUBOIYE.js";
+} from "./chunk-APP6Y2D7.js";
 import {
   registerBootMilestoneSocketFallback,
   reportBootMilestone
@@ -78,7 +80,7 @@ import {
 } from "./chunk-IA45XHOA.js";
 import {
   getWorkbenchClient
-} from "./chunk-EXQ6AHOY.js";
+} from "./chunk-TOTCEWJD.js";
 import {
   workbenchEnabled
 } from "./chunk-KMB3BU4S.js";
@@ -4640,6 +4642,12 @@ var PtySession = class {
   // synthetic id so the card flips to answered.
   pendingSyntheticQuestionIds = [];
   questionResultRemap = /* @__PURE__ */ new Map();
+  // An AskUserQuestion questionnaire is parked on screen (PreToolUse hook
+  // fired, no PostToolUse envelope yet). While set the parked process must
+  // not be reused: feeding follow-up prompt bytes into the live dialog would
+  // type chat text into the questionnaire. Fail-safe — a stale flag only
+  // costs a teardown + respawn (`--resume` recovers the conversation).
+  questionnairePending = false;
   // Per-turn state: the prompt to feed and the per-turn options subset. Both
   // start from the constructor args (turn 1) and are replaced by beginTurn.
   turnPrompt;
@@ -4732,7 +4740,9 @@ var PtySession = class {
    */
   canReuse(resume, fingerprint) {
     const resumeMatches = resume === void 0 ? this.reportedOpenCodeId !== null : resume === this.sessionUuid;
-    return !this._toreDown && !this.exited && this.activeQueue === null && resumeMatches && fingerprint === this.spawnFingerprint;
+    return !this._toreDown && !this.exited && this.activeQueue === null && // A parked questionnaire owns the terminal — a fed prompt would type
+    // into the dialog. Force teardown + respawn instead.
+    !this.questionnairePending && resumeMatches && fingerprint === this.spawnFingerprint;
   }
   get hookSocketPath() {
     return this.socket ? this.socket.socketPath : null;
@@ -4807,6 +4817,7 @@ var PtySession = class {
     this.deliveredTexts = [];
     this.disarmSubmitNudge();
     this.disarmPlanDialogAutoAccept();
+    this.questionnairePending = false;
     this.closeSyntheticQuestionCards();
   }
   /**
@@ -5116,6 +5127,7 @@ var PtySession = class {
   async teardown() {
     if (this._toreDown) return;
     this._toreDown = true;
+    this.questionnairePending = false;
     this.disarmPlanDialogAutoAccept();
     this.disarmSubmitNudge();
     this.closeSyntheticQuestionCards();
@@ -5391,6 +5403,7 @@ var PtySession = class {
     if (this.pendingPlanApproval && progress.tool_name === "ExitPlanMode") {
       this.disarmPlanDialogAutoAccept();
     }
+    if (progress.tool_name === "AskUserQuestion") this.questionnairePending = false;
     if (this.pendingSubmitNudge) this.disarmSubmitNudge();
     this.pushEvent({
       type: "tool_progress",
@@ -5411,6 +5424,7 @@ var PtySession = class {
     if (request.tool_name === "AskUserQuestion") {
       this.disarmSubmitNudge();
       this.disarmPlanDialogAutoAccept();
+      this.questionnairePending = true;
       const questions = parseUserQuestions(request.tool_input);
       this.pushEvent({ type: "user_question", questions });
       this.emitSyntheticQuestionCard(questions);
@@ -5519,6 +5533,7 @@ var PtySession = class {
   async finalizeOnExit(exitCode) {
     this.coalescer?.flush();
     this.exited = true;
+    this.questionnairePending = false;
     if (this._toreDown) return;
     if (this.tailer) {
       this.tailer.close();
@@ -12539,16 +12554,22 @@ function questionTextFromEvent(event) {
 }
 async function armQuestionPending(host, state, event) {
   state.questionPending = true;
+  const questionText = questionTextFromEvent(event);
+  host.callbacks.onUserQuestion?.({
+    kind: "armed",
+    ...questionText === void 0 ? {} : { questionText }
+  });
   await host.connection.emitStatus(
     "waiting_for_input",
     AGENT_STATUS_REASON_USER_QUESTION,
-    questionTextFromEvent(event)
+    questionText
   );
   await host.callbacks.onStatusChange("waiting_for_input");
 }
 async function clearQuestionPending(host, state, options) {
   if (!state.questionPending) return;
   state.questionPending = false;
+  host.callbacks.onUserQuestion?.({ kind: options.emitRunning ? "answered" : "turn_ended" });
   if (options.emitRunning) {
     await host.connection.emitStatus("running");
     await host.callbacks.onStatusChange("running");
@@ -14740,6 +14761,15 @@ function findLiveChild(sources) {
 var AUTO_RUN_MODES = /* @__PURE__ */ new Set(["building", "auto", "review", "discovery", "chat"]);
 var CHILD_DEFER_RECHECK_MS = 60 * 1e3;
 var ORPHAN_WAKE_GRACE_MS = 3 * 60 * 1e3;
+var QUESTION_GRACE_MS = 10 * 6e4;
+var QUESTION_HOLD_SLACK_MS = 6e4;
+function resolveQuestionGraceMs() {
+  const raw = Number(process.env.CONVEYOR_QUESTION_GRACE_MS ?? "");
+  return Number.isFinite(raw) && raw > 0 ? raw : QUESTION_GRACE_MS;
+}
+var QUESTION_TYPING_RECENT_MS = 6e4;
+var QUESTION_TYPING_DEFER_MS = 2 * 6e4;
+var QUESTION_TIMEOUT_PROMPT = 'No one answered your clarifying questions within 10 minutes. Do this now: (1) Save your findings-so-far as the card plan (`update_task`). (2) Post the unanswered questions to chat with `post_to_chat` using `milestone: "blocked"`, stating the assumption you would make for each. (3) If you can safely proceed on your best-judgment answers, state the assumptions and continue; otherwise end your turn \u2014 answers posted in chat will be delivered when you resume.';
 var SessionRunner = class _SessionRunner {
   connection;
   mode;
@@ -14793,6 +14823,18 @@ var SessionRunner = class _SessionRunner {
   /** Guards the one-shot `agent_live` boot-milestone report — fired on the
    *  first harness event (createQueryBridge's onEvent hook). */
   agentLiveReported = false;
+  /** 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). */
+  questionPendingSince = null;
+  /** 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. */
+  questionGraceTimer = null;
   constructor(config, callbacks, deps = {}) {
     this.config = config;
     this.callbacks = callbacks;
@@ -15148,6 +15190,7 @@ var SessionRunner = class _SessionRunner {
         process.stderr.write("[conveyor-agent] WARNING: task-branch checkout failed\n");
       }
       if (ok) void reportBootMilestone({ key: "branch_ready" });
+      await this.refreshSkillsForCheckout();
     }
     if (!this.stopped) {
       this.lifecycle.startGitFlush();
@@ -15207,6 +15250,40 @@ var SessionRunner = class _SessionRunner {
     await this.run();
   }
   // ── Core loop ──────────────────────────────────────────────────────
+  /**
+   * 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.
+   */
+  async refreshSkillsForCheckout() {
+    const write = (msg) => void process.stderr.write(`[conveyor-agent] ${msg}
+`);
+    try {
+      const result = workbenchEnabled() ? await getWorkbenchClient().refreshSkills() : await refreshSkillsAfterCheckout(
+        this.config.workspaceDir,
+        async (args, opts) => ({
+          stdout: await git(opts?.cwd ?? this.config.workspaceDir, args, opts?.timeoutMs)
+        }),
+        { info: write, warn: write, error: write }
+      );
+      const { filled, shadowed, stale } = result;
+      if (filled.length + shadowed.length + stale.length === 0) return;
+      write(
+        `post-checkout skill refresh: filled=[${filled.join(", ")}] shadowed=[${shadowed.join(", ")}] unusable=[${stale.join(", ")}]`
+      );
+    } catch (err) {
+      write(
+        `WARNING: post-checkout skill refresh failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
   // oxlint-disable-next-line complexity -- dormant idle paths add branches but are tightly coupled to the loop
   async coreLoop() {
     while (!this.stopped) {
@@ -15495,6 +15572,7 @@ var SessionRunner = class _SessionRunner {
   }
   /** Inject a message (from connection callback or external source) */
   injectMessage(msg) {
+    this.clearQuestionHold();
     if (this.inputResolver) {
       const resolve = this.inputResolver;
       this.inputResolver = null;
@@ -15702,6 +15780,7 @@ var SessionRunner = class _SessionRunner {
   }
   stop() {
     this.stopped = true;
+    this.clearQuestionHold();
     this.queryBridge?.stop();
     void this.queryBridge?.dispose().catch(() => {
     });
@@ -15796,7 +15875,8 @@ var SessionRunner = class _SessionRunner {
           void this.connection.sendHeartbeat();
         }
         return this.callbacks.onEvent(event);
-      }
+      },
+      onUserQuestion: (signal) => this.handleUserQuestionSignal(signal)
     });
     bridge.isParentTask = this.fullContext?.isParentTask ?? false;
     bridge.onBackgroundTaskDone = () => this.backgroundWork.noteCompletion();
@@ -15947,8 +16027,72 @@ ${outcome.failures.join("\n")}
    */
   resolveLoopStatus() {
     if (loopStatusForRunnerStatus(this._state) === "active") return "active";
+    if (this.questionPendingSince !== null && Date.now() - this.questionPendingSince < resolveQuestionGraceMs() + QUESTION_HOLD_SLACK_MS) {
+      return "waiting";
+    }
     return this.backgroundWork.hasPending() || isHeavyGateActive() ? "waiting" : "idle";
   }
+  // ── Question grace hold ────────────────────────────────────────────
+  /**
+   * 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.
+   */
+  handleUserQuestionSignal(signal) {
+    if (signal.kind === "armed") {
+      this.questionPendingSince = Date.now();
+      this.armQuestionGraceTimer(resolveQuestionGraceMs());
+      this.refreshLoopStatus();
+    } else if (signal.kind === "answered") {
+      this.clearQuestionHold();
+    }
+  }
+  armQuestionGraceTimer(delayMs) {
+    if (this.questionGraceTimer) clearTimeout(this.questionGraceTimer);
+    this.questionGraceTimer = setTimeout(() => this.handleQuestionGraceExpiry(), delayMs);
+    this.questionGraceTimer.unref();
+  }
+  clearQuestionHold() {
+    if (this.questionGraceTimer) {
+      clearTimeout(this.questionGraceTimer);
+      this.questionGraceTimer = null;
+    }
+    if (this.questionPendingSince === null) return;
+    this.questionPendingSince = null;
+    this.refreshLoopStatus();
+  }
+  /**
+   * 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.
+   */
+  handleQuestionGraceExpiry() {
+    this.questionGraceTimer = null;
+    if (this.questionPendingSince === null || this.stopped) return;
+    const lastInput = this.connection.lastPtyInputAt;
+    if (lastInput !== null && Date.now() - lastInput < QUESTION_TYPING_RECENT_MS) {
+      this.questionPendingSince = Date.now();
+      this.armQuestionGraceTimer(QUESTION_TYPING_DEFER_MS);
+      return;
+    }
+    process.stderr.write(
+      "[conveyor-agent] Question grace expired with no answer \u2014 un-parking the agent\n"
+    );
+    this.injectMessage({
+      content: QUESTION_TIMEOUT_PROMPT,
+      userId: "system",
+      source: "question_timeout"
+    });
+  }
   /** Mirror the resolved status into the loop-lag buffer so the starvation-proof
    *  heartbeat worker reports it too. Returns what it wrote. */
   refreshLoopStatus() {
@@ -15977,6 +16121,7 @@ ${outcome.failures.join("\n")}
     process.stderr.write(`[conveyor-agent] Shutdown: reason=${finalState}
 `);
     this.connection.sendEvent({ type: "shutdown", reason: finalState });
+    this.clearQuestionHold();
     this.portDiscovery.stop();
     this.backgroundWork.clear();
     this.loopLag.stop();