@edgehero/pi-dispatch 4.2.0 → 4.3.1

package/src/provider-steering.mjs

@@ -162,6 +162,7 @@ const UNREACHABLE_BY_SCAN = ["AWS_ENDPOINT_URL_BEDROCK_RUNTIME", "ALL_PROXY", "h
  */
 const PI_OWN_READS = [
 	"PI_CLEAR_ON_SHRINK",
+	"PI_CLIPBOARD_OSC52",
 	"PI_CODING_AGENT_DIR",
 	"PI_CODING_AGENT_SESSION_DIR",
 	"PI_EXPERIMENTAL",

package/src/queue.mjs

@@ -247,6 +247,38 @@ async function addLocalJob(queue, { folder, flow, task, command, provider, model
 // window only needs to absorb burst re-labels, not the full redelivery window.
 const SEMANTIC_WINDOW_MS = 10 * 60 * 1000;
 
+/**
+ * Close the semantic window of a run that PARKED (REQ-AWAIT-INPUT, DES-AWAIT-INPUT-ENDS-THE-JOB). Never throws.
+ *
+ * The window exists to coalesce rapid duplicate deliveries into one ACTIVE job. A ttl-mode key outlives the job it
+ * was set for (bullmq 5.80.4, `removeDeduplicationKeyIfNeededOnFinalization.lua`: a finished job deletes its key only
+ * when it has no ttl), so without this a person's answer that lands within ten minutes of the delivery that STARTED
+ * the parked run is swallowed against that finished run: the receiver answers `deduplicated`, nothing runs, and the
+ * marker stays. Once a run has parked, the next delivery on its key is a deliberate answer, never a duplicate.
+ *
+ * It asks the BullMQ job itself, rather than rebuilding the key from the job data: `job.deduplicationId` is the id
+ * the add stored with the job (`deid` in its hash), so there is no second spelling of the key format to drift from
+ * `enqueueForgeJob`'s, and it covers every suffix (the `closed:`/`cmd:` slot, a replica's `:r<n>`) by construction.
+ * And `job.removeDeduplicationKey()` is a compare-and-delete (`removeDeduplicationKey-1.lua`: DEL only when the key
+ * still holds THIS job's id), where `queue.removeDeduplicationKey(id)` is a bare DEL that could free a key a later
+ * job now holds.
+ *
+ * Fails open with a named line: a failure only leaves today's behaviour (the answer waits out the window).
+ * `released` is false, logged as a release and not as a failure, when the key is already gone (the window lapsed
+ * during a long run) or now names another job.
+ */
+export async function releaseSemanticWindow(job, log = () => {}) {
+	if (!job?.deduplicationId || typeof job.removeDeduplicationKey !== "function") return false;
+	try {
+		const released = (await job.removeDeduplicationKey()) === true;
+		log("parked_window_released", { jobId: job.id ?? null, released });
+		return released;
+	} catch (error) {
+		log("parked_window_release_failed", { jobId: job.id ?? null, code: typeof error?.code === "string" ? error.code : "error" });
+		return false;
+	}
+}
+
 /**
  * Enqueue a GitHub-triggered job. Returns `{ jobId, deduplicated, survivingJobId? }` -- the computed
  * per-delivery id, plus whether the SEMANTIC window swallowed this delivery (issue #289; the GUID
@@ -311,7 +343,7 @@ export async function enqueueGitLabJob(queue, fields) {
  * window, replicas never coalesce against each other, and an unflagged job's dedup id is the same string it
  * has always been.
  */
-export async function enqueueForgeJob(queue, kind, { repo, projectId, azure, target, flow, command, trigger, provider, model, maxTurns, models, maxCostUsd, packages, image, backend, excludeTools, mcp, skillsDir, instructions, resume, secrets, secretsProfile, waitFor, replica, replicas }) {
+export async function enqueueForgeJob(queue, kind, { repo, projectId, azure, target, flow, command, trigger, provider, model, maxTurns, models, maxCostUsd, packages, image, backend, excludeTools, mcp, skillsDir, instructions, resume, awaitInput, parkedReply, secrets, secretsProfile, waitFor, replica, replicas }) {
 	const jobId = forgeDeliveryJobId(kind, trigger?.deliveryId, replica);
 	// `packages` (whether to load the operator-staged pi packages) and `image` (which container image to run)
 	// come off the MATCHED trigger (INT-TRIGGERS-FILE-CONTRACT / REQ-GLOBAL-PI-OVERLAY) and land on `data`
@@ -366,6 +398,12 @@ export async function enqueueForgeJob(queue, kind, { repo, projectId, azure, tar
 		// delivery, and `trigger` is what /job/event.json is built from.
 		...(instructions !== undefined && { instructions }),
 		...(resume !== undefined && { resume }),
+		// REQ-AWAIT-INPUT (issue #625): only when armed, so an unflagged job's data is byte-identical, and at JOB level
+		// for resume's reason: `trigger` is copied verbatim into /job/event.json.
+		...(awaitInput === true && { awaitInput: true }),
+		// A phrase-free reply to a parked issue (issue #625), gated by the worker on the key's `parked` mark. Never part
+		// of an id: it says how the delivery was routed, not what it is.
+		...(parkedReply === true && { parkedReply: true }),
 		// REQ-TRIGGER-SECRETS. The env variables this trigger binds and the profile whose resolver reads
 		// them. REFERENCES only: no value is ever enqueued, because a queued job is durable and a resolved
 		// credential in Redis would outlive the container it was scoped to. The worker resolves them at job

package/src/reserved-env.mjs

@@ -43,6 +43,7 @@ export const CONTAINER_ENV_NAMES = new Set([
 	"PI_FLOW",
 	"PI_COMMAND",
 	"PI_EXCLUDE_TOOLS",
+	"PI_AWAIT_INPUT",
 	"PI_MCP_SERVERS",
 	// Issues #501, #502: the per-job dollar cap (written by the worker since #501, from the trigger's and the
 	// deployment's caps) and the allowed-model list (reserved until #502 writes it). Neither can be bound through

package/src/run-container.mjs

@@ -148,6 +148,10 @@ export function makeRunContainer({
 			excludeTools: Array.isArray(job.excludeTools) && job.excludeTools.length > 0 ? job.excludeTools : undefined,
 			// REQ-MCP-OPERATOR-SERVERS: the trigger's MCP server names, off `job` like excludeTools.
 			mcpServers: Array.isArray(job.mcp) && job.mcp.length > 0 ? job.mcp : undefined,
+			// Issue #625: whether the runner offers the tool a parked run ends on. Only beside a staged transcript: the
+			// runner refuses the flag without one (await-input-without-session), so a job whose resume degraded to no
+			// mount is not armed into that refusal.
+			awaitInput: job.awaitInput === true && prepared.session ? true : undefined,
 			// Issue #502: the effective allowed-model list, off `job` like excludeTools. index.mjs `effectiveJobOf` folds
 			// the deployment's PI_ALLOWED_MODELS in under the trigger's own, so `job.models` is already the one list.
 			allowedModels: Array.isArray(job.models) && job.models.length > 0 ? job.models : null,

package/src/run-history.mjs

@@ -172,11 +172,30 @@ export function parseExitTurns(text) {
  * Live from the first image that declares `mcp`: an image built before the worker named them prints the same line.
  */
 export const MCP_RUNNER_REASONS = Object.freeze(["mcp-unavailable", "mcp-config-invalid", "mcp-config-mismatch", "mcp-secret-missing", "mcp-command-missing", "mcp-shadowed"]);
-export const RUNNER_POLICY_REASONS = new Set(["provider-auth-refused", "cost-cap", "model-not-allowed", "cost-cap-unenforceable", "model-policy-unenforceable", ...MCP_RUNNER_REASONS]);
+/**
+ * The runner's exit-2 refusals of a job armed with `run.awaitInput` (issue #625), each before the prompt: another
+ * extension registers the tool a parked run ends on (`await-input-shadowed`), or the job has no session file to park
+ * a transcript in (`await-input-without-session`, a worker regression, since the worker arms the flag only beside
+ * `run.resume` and refuses that with no store). Named for MCP_RUNNER_REASONS' reason: the operator's fix is not a budget.
+ */
+export const AWAIT_INPUT_RUNNER_REASONS = Object.freeze(["await-input-shadowed", "await-input-without-session"]);
+export const RUNNER_POLICY_REASONS = new Set(["provider-auth-refused", "cost-cap", "model-not-allowed", "cost-cap-unenforceable", "model-policy-unenforceable", ...MCP_RUNNER_REASONS, ...AWAIT_INPUT_RUNNER_REASONS]);
+
+/**
+ * The runner's reasons that ride a COMPLETED exit (`code: 0`) and that the worker acts on, closed (issue #625). One so
+ * far: `awaiting-input`, a run that asked a person a question and ended so the next run resumes with the answer. Every
+ * other exit-0 reason (`stop`, `length`, `command-completed`, `tool-terminated`) is still dropped, as before.
+ *
+ * Read for the same bounded reason RUNNER_POLICY_REASONS is: it cannot change the retry class. The processor consults it
+ * only inside its exit-0 branch, so the worst a forged line can do on a real exit 0 is mark a completed run parked: the
+ * worker then posts one fixed sentence and writes a marker beside a transcript the job already promoted.
+ */
+export const RUNNER_COMPLETED_REASONS = new Set(["awaiting-input"]);
 
 /**
  * The reason off the decisive exit line (`decisiveExitLine`), or `null`: a member of `RUNNER_POLICY_REASONS`
- * and only when that same line says `code: 2`. Read off the same line as `parseExitTurns`, and NEVER throws.
+ * and only when that same line says `code: 2`, or a member of `RUNNER_COMPLETED_REASONS` and only when it says
+ * `code: 0` (issue #625). Read off the same line as `parseExitTurns`, and NEVER throws.
  *
  * Why this may reach the outcome when its five siblings may not: it cannot change the retry class. The
  * processor consults it only inside its container-exit-2 branch, so a container that exits 1 while
@@ -189,6 +208,7 @@ export const RUNNER_POLICY_REASONS = new Set(["provider-auth-refused", "cost-cap
 export function parseExitReason(text) {
 	const parsed = decisiveExitLine(text);
 	if (parsed === null) return null;
+	if (parsed?.code === 0 && RUNNER_COMPLETED_REASONS.has(parsed?.reason)) return parsed.reason;
 	return parsed?.code === 2 && RUNNER_POLICY_REASONS.has(parsed?.reason) ? parsed.reason : null;
 }
 

package/src/session-store.mjs

@@ -90,6 +90,15 @@ const CONTEXT_FILE = "context";
  * stamp existed ran on `local`, and the default is a setting that can move under it.
  */
 const VENUE_FILE = "venue";
+/**
+ * The run that wrote the transcript beside it ended `awaiting-input` (REQ-AWAIT-INPUT, issue #625): it asked a person
+ * a question and ended so that the next run on this key resumes with the answer. One line, the promotion's
+ * `now()` in milliseconds. Keyed state written where the key already is, like `resume-chain`, so it is not the
+ * index `DES-SESSION-KEY-IS-DERIVED-NOT-INDEXED` refuses: it answers one question about this key and nothing
+ * looks it up by anything else. Written and REMOVED by promotion alone, under the promotion lock: a parked run
+ * writes it, any other completed run on the key removes it, so it never outlives the transcript it describes.
+ */
+export const PARKED_FILE = "parked";
 /**
  * What the venue stamp reads while a promotion is swapping the transcript under it. It matches no venue:
  * parentheses are outside the charset every backend name is validated against (a test pins every name this
@@ -540,7 +549,7 @@ export function makeSessionStore({
 		return st.isDirectory() ? `${st.dev}:${st.ino}` : null;
 	}
 
-	function promoteSession(session, { piVersion = null, context = null } = {}) {
+	function promoteSession(session, { piVersion = null, context = null, parked = false } = {}) {
 		// The second DI-seam backstop, and unreachable for the same reason as the `!sessionsDir` return
 		// above: sessionKeyFor is total and binary (null, or 32 hex chars), so resolveSession returns null
 		// rather than a keyless session, and processor.mjs only calls this when prepare handed it one. Kept
@@ -711,6 +720,7 @@ export function makeSessionStore({
 				// it is reporting.
 				writeSidecar(dir, RESUME_CHAIN_FILE, session.key, chainValue(session));
 				writeContextSidecar(dir, session, context);
+				writeParkedSidecar(dir, session, parked);
 			} finally {
 				fs.closeSync(fd);
 				try {
@@ -840,6 +850,20 @@ export function makeSessionStore({
 		writeSidecar(dir, CONTEXT_FILE, session.key, `${context.tokens} ${context.window}${stamp}`);
 	}
 
+	// Issue #625: `parked` is set by a run that ended awaiting-input, and cleared by every other promotion, so the
+	// marker always describes the transcript beside it. Caught like its siblings: the promotion already happened.
+	function writeParkedSidecar(dir, session, parked) {
+		if (parked === true) {
+			writeSidecar(dir, PARKED_FILE, session.key, String(now()));
+			return;
+		}
+		try {
+			fs.unlinkSync(join(dir, PARKED_FILE));
+		} catch {
+			// Absent is the desired state, so failing to remove what is not there is success.
+		}
+	}
+
 	function keyDir(key) {
 		return join(sessionsDir, key);
 	}
@@ -1289,5 +1313,24 @@ export function makeSessionStore({
 		}
 	}
 
-	return { resolveSession, promoteSession, reapSessions };
+	/**
+	 * Whether the key a job resolves to holds a `parked` mark (issue #625): the TRUTH the worker gates a phrase-free reply
+	 * on, where the forge label was only the receiver's hint. Free, read-only and never throws, so it can answer before
+	 * the mint. An issue's key is a pure function of the job (`pi/issue-<n>`); a pull request's needs its head branch,
+	 * which costs a token to read, which is why a phrase-free reply is routed on issues only and this resolves no PR.
+	 * The key's own name must `lstat` as a real directory, resolveSession's first gate, so a planted link answers no.
+	 */
+	function isParked(job) {
+		if (!sessionsDir || job?.target?.type === "pull_request") return false;
+		const key = sessionKeyFor(job);
+		if (!key) return false;
+		try {
+			if (!fs.lstatSync(keyDir(key)).isDirectory()) return false;
+		} catch {
+			return false;
+		}
+		return readSidecar(key, PARKED_FILE) !== null;
+	}
+
+	return { resolveSession, promoteSession, reapSessions, isParked };
 }

package/src/start.mjs

@@ -2002,6 +2002,23 @@ export async function startWorker(
 		log("comment", { jobId: job?.id, text });
 	};
 
+	// Issue #625: the forge's parked marker, set on a park and cleared when it no longer applies. comment()'s shape and its
+	// rule: it NEVER throws, because the marker decides nothing (the session store's sidecar does) and a forge that refuses
+	// the label must not flip an outcome. A local job has no forge and no marker. Issues only: a pull request's reply is
+	// routed on the phrase (parked.mjs).
+	const parkedLabel = async (job, on) => {
+		const forge = forgeFor(job);
+		if (!forge?.host?.setParkedLabel || job?.target?.type !== "issue") return;
+		try {
+			const auth = forge.auth ?? (await ensureAuth(job.kind));
+			if (!auth) return;
+			const token = await auth.mintToken(job);
+			await forge.host.setParkedLabel(job, job.target, on, token);
+		} catch (err) {
+			log("parked_label_failed", { jobId: job?.id, on, reason: err?.message });
+		}
+	};
+
 	// The operator's failure hook (issue #288, INT-ON-FAILURE-HOOK-CONTRACT). Constructed ONLY when the
 	// knob is set: an unset PI_ON_FAILURE builds nothing, spawns nothing, and logs nothing -- the
 	// byte-identical guarantee. Fired from the two terminal listeners below, never from the processor:
@@ -2241,6 +2258,8 @@ export async function startWorker(
 			// Completed-only, so a policy or infra exit leaves the canonical transcript byte-identical and a
 			// retry starts from what the first attempt did (CONST-RETRY-INFRA-ONLY).
 			promoteSession: sessionStore.promoteSession,
+			isParked: sessionStore.isParked,
+			parkedLabel,
 			// The same value the store above was built from, passed explicitly so the processor's fail-closed
 			// `run.resume` gate answers from THIS config rather than from its own env default. Identical on the
 			// real path; the difference shows under an injected env, where the store would be built from the

package/src/triggers-file.mjs

@@ -478,6 +478,10 @@ export const AUTHORED_NARROWING_FIELDS = Object.freeze([
 	// REQ-MCP-OPERATOR-SERVERS: the MCP servers a trigger's jobs connect. Not a widening when dropped but the same
 	// silent outcome: the job runs its flow without the servers it was written against, on a clean record.
 	Object.freeze({ key: "mcp", authored: (v) => Array.isArray(v) && v.length > 0 }),
+	// REQ-AWAIT-INPUT: the tool a run ends on to wait for a person. Dropped by a receiver from before #625 (which tolerates
+	// the key as unknown), the job runs without it: the agent cannot ask, and the record reads like a clean run. Only
+	// `true` arms it, and the job data carries it only then, so `false` is nothing authored.
+	Object.freeze({ key: "awaitInput", authored: (v) => v === true }),
 ]);
 
 export function makeCheckWaitSkew({ triggersPath, fs = nodeFs }) {

package/src/triggers.mjs

@@ -30,7 +30,7 @@ import { imageRefProblem } from "./image-ref.mjs";
 // materialize.mjs and the admin already import it, and a keep-in-sync copy would drift where a
 // traversal guard cannot). flow-gate's module body is import-inert, so this keeps parseTriggers pure.
 import { SKILL_NAME_RE } from "./flow-gate.mjs";
-import { FORGE_HOST_VARS, FORGE_KINDS, MINTED_TOKEN_VARS, RUN_KINDS, forgeSpec, isForgeKind } from "./forges.mjs";
+import { FORGE_HOST_VARS, FORGE_KINDS, MINTED_TOKEN_VARS, RECEIVER_ONLY_VARS, RUN_KINDS, forgeSpec, isForgeKind } from "./forges.mjs";
 import { findDuplicateKey } from "./json-duplicates.mjs";
 // The server-name rule, from the one module that parses the overlay's list (its body is import-inert).
 import { FORGE_MCP_KINDS, FORGE_MCP_SERVER_NAME, MCP_SERVER_NAME_RE } from "./mcp-config.mjs";
@@ -261,7 +261,7 @@ const ENV_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
  * Every set is IMPORTED, never retyped, which is the rule `sandbox.test.mjs` keeps for the same reason: a
  * forge added to the table later must not need a second edit here to stay covered.
  */
-export const RESERVED_ENV_NAMES = new Set([...MINTED_TOKEN_VARS, ...FORGE_HOST_VARS, ...WORKER_ONLY_SECRET_VARS, ...EGRESS_ENV_VARS, ...CONTAINER_ENV_NAMES, ...RUNNER_ENV_NAMES, ...PROVIDER_STEERING_VARS]);
+export const RESERVED_ENV_NAMES = new Set([...MINTED_TOKEN_VARS, ...FORGE_HOST_VARS, ...RECEIVER_ONLY_VARS, ...WORKER_ONLY_SECRET_VARS, ...EGRESS_ENV_VARS, ...CONTAINER_ENV_NAMES, ...RUNNER_ENV_NAMES, ...PROVIDER_STEERING_VARS]);
 
 function isNonEmptyString(value) {
 	return typeof value === "string" && value.trim() !== "";
@@ -425,6 +425,9 @@ function normalizeCron(on, run, index, path, state) {
 	// `false` or absent. Both must keep reaching the job payload unchanged -- an operator who wrote down
 	// today's default must not get a `data` that disagrees with the file they reviewed.
 	const resume = validateResumeFlag(run, `cron trigger "${id}"`, path);
+	// Called for its refusal only (issue #625): `true` needs run.resume, which cron refuses, so the returned `run`
+	// grows no `awaitInput` key, exactly as it grows no `replicas` one.
+	validateAwaitInputFlag(run, `cron trigger "${id}"`, path);
 	// Called and DISCARDED: on a cron trigger this can only refuse, and the refusal is the point. The
 	// returned `run` below deliberately grows no `replicas` key -- a cron entry can never carry one.
 	validateReplicas(run, `cron trigger "${id}"`, path);
@@ -557,6 +560,28 @@ function validateResumeFlag(run, at, path) {
 	return run.resume;
 }
 
+/**
+ * Validate the per-trigger `run.awaitInput` flag (REQ-AWAIT-INPUT, issue #625): whether the job is offered the tool
+ * that ends a run to wait for a person's answer. Strictly boolean, validateResumeFlag's rule and for its reason: a
+ * truthy `"false"` would arm what the operator meant to leave off.
+ *
+ * `true` needs `run.resume: true` beside it, and that one rule carries every other refusal: a parked run is only
+ * worth anything if the next run resumes its transcript, and `run.resume` is already refused on cron and beside
+ * `run.command`, `run.replicas` and `run.secrets`, each for a reason that holds here too. So this adds no list of
+ * its own, which is one place fewer for the two to disagree.
+ *
+ * Returns the flag, undefined when absent, so an unflagged trigger normalizes byte-identically to today's.
+ */
+function validateAwaitInputFlag(run, at, path) {
+	if (run.awaitInput !== undefined && typeof run.awaitInput !== "boolean") {
+		throw configError(`${at}: run.awaitInput must be true or false when present: ${path}`);
+	}
+	if (run.awaitInput === true && run.resume !== true) {
+		throw configError(`${at}: run.awaitInput needs run.resume: true beside it -- a run that stops to wait for an answer is continued by the next run on the same issue or pull request, and only run.resume keeps the transcript it would continue from: ${path}`);
+	}
+	return run.awaitInput;
+}
+
 /**
  * Validate the per-trigger `run.image` reference, shared by all four normalizers. It selects the Docker image
  * this trigger's job containers run in, overriding the deployment-wide `PI_JOB_IMAGE` for this trigger only;
@@ -1649,6 +1674,7 @@ function normalizeLabel(on, run, index, path) {
 	const skillsDir = validateSkillsDir(run, at, path);
 	const instructions = validateInstructions(run, at, path);
 	const resume = validateResumeFlag(run, at, path);
+	const awaitInput = validateAwaitInputFlag(run, at, path);
 	const repository = validateRepository(run, "label", at, path);
 	const replicas = validateReplicas(run, at, path);
 	const secrets = validateSecrets(run, at, path);
@@ -1660,7 +1686,7 @@ function normalizeLabel(on, run, index, path) {
 	const ref = validateRunModel(on, run, at, path);
 	return {
 		on: { type: "label", any: predicate.any, all: predicate.all, none: predicate.none },
-		run: { kind: run.kind, flow: run.flow, packages, image, resume, replicas, ...(command !== undefined && { command }), ...(skillsDir !== undefined && { skillsDir }), ...(instructions !== undefined && { instructions }), ...(repository !== undefined && { repository }), ...(secrets !== undefined && { secrets }), ...(secretsProfile !== undefined && { secretsProfile }), ...(waitFor !== undefined && { waitFor }), ...(backend !== undefined && { backend }), ...(excludeTools !== undefined && { excludeTools }), ...(mcp !== undefined && { mcp }), ...ref },
+		run: { kind: run.kind, flow: run.flow, packages, image, resume, replicas, ...(awaitInput !== undefined && { awaitInput }), ...(command !== undefined && { command }), ...(skillsDir !== undefined && { skillsDir }), ...(instructions !== undefined && { instructions }), ...(repository !== undefined && { repository }), ...(secrets !== undefined && { secrets }), ...(secretsProfile !== undefined && { secretsProfile }), ...(waitFor !== undefined && { waitFor }), ...(backend !== undefined && { backend }), ...(excludeTools !== undefined && { excludeTools }), ...(mcp !== undefined && { mcp }), ...ref },
 	};
 }
 
@@ -1692,6 +1718,7 @@ function normalizeComment(on, run, index, path, state) {
 	const skillsDir = validateSkillsDir(run, at, path);
 	const instructions = validateInstructions(run, at, path);
 	const resume = validateResumeFlag(run, at, path);
+	const awaitInput = validateAwaitInputFlag(run, at, path);
 	const repository = validateRepository(run, "comment", at, path);
 	const replicas = validateReplicas(run, at, path);
 	const secrets = validateSecrets(run, at, path);
@@ -1703,7 +1730,7 @@ function normalizeComment(on, run, index, path, state) {
 	const ref = validateRunModel(on, run, at, path);
 	return {
 		on: { type: "comment", phrase: on.phrase },
-		run: { kind: run.kind, flow: run.flow, packages, image, resume, replicas, ...(command !== undefined && { command }), ...(skillsDir !== undefined && { skillsDir }), ...(instructions !== undefined && { instructions }), ...(repository !== undefined && { repository }), ...(secrets !== undefined && { secrets }), ...(secretsProfile !== undefined && { secretsProfile }), ...(waitFor !== undefined && { waitFor }), ...(backend !== undefined && { backend }), ...(excludeTools !== undefined && { excludeTools }), ...(mcp !== undefined && { mcp }), ...ref },
+		run: { kind: run.kind, flow: run.flow, packages, image, resume, replicas, ...(awaitInput !== undefined && { awaitInput }), ...(command !== undefined && { command }), ...(skillsDir !== undefined && { skillsDir }), ...(instructions !== undefined && { instructions }), ...(repository !== undefined && { repository }), ...(secrets !== undefined && { secrets }), ...(secretsProfile !== undefined && { secretsProfile }), ...(waitFor !== undefined && { waitFor }), ...(backend !== undefined && { backend }), ...(excludeTools !== undefined && { excludeTools }), ...(mcp !== undefined && { mcp }), ...ref },
 	};
 }
 
@@ -1762,6 +1789,7 @@ function normalizeIssue(on, run, index, path) {
 	const skillsDir = validateSkillsDir(run, at, path);
 	const instructions = validateInstructions(run, at, path);
 	const resume = validateResumeFlag(run, at, path);
+	const awaitInput = validateAwaitInputFlag(run, at, path);
 	validateRepository(run, "issue", at, path);
 	const replicas = validateReplicas(run, at, path);
 	const secrets = validateSecrets(run, at, path);
@@ -1780,7 +1808,7 @@ function normalizeIssue(on, run, index, path) {
 			...(number !== undefined && { number }),
 			...(once !== undefined && { once }),
 		},
-		run: { kind: run.kind, flow: run.flow, packages, image, resume, replicas, ...(command !== undefined && { command }), ...(skillsDir !== undefined && { skillsDir }), ...(instructions !== undefined && { instructions }), ...(secrets !== undefined && { secrets }), ...(secretsProfile !== undefined && { secretsProfile }), ...(waitFor !== undefined && { waitFor }), ...(backend !== undefined && { backend }), ...(excludeTools !== undefined && { excludeTools }), ...(mcp !== undefined && { mcp }), ...ref },
+		run: { kind: run.kind, flow: run.flow, packages, image, resume, replicas, ...(awaitInput !== undefined && { awaitInput }), ...(command !== undefined && { command }), ...(skillsDir !== undefined && { skillsDir }), ...(instructions !== undefined && { instructions }), ...(secrets !== undefined && { secrets }), ...(secretsProfile !== undefined && { secretsProfile }), ...(waitFor !== undefined && { waitFor }), ...(backend !== undefined && { backend }), ...(excludeTools !== undefined && { excludeTools }), ...(mcp !== undefined && { mcp }), ...ref },
 	};
 }
 
@@ -1850,6 +1878,7 @@ function normalizePullRequest(on, run, index, path) {
 	const skillsDir = validateSkillsDir(run, at, path);
 	const instructions = validateInstructions(run, at, path);
 	const resume = validateResumeFlag(run, at, path);
+	const awaitInput = validateAwaitInputFlag(run, at, path);
 	validateRepository(run, "pull_request", at, path);
 	const replicas = validateReplicas(run, at, path);
 	const secrets = validateSecrets(run, at, path);
@@ -1873,7 +1902,7 @@ function normalizePullRequest(on, run, index, path) {
 			...(number !== undefined && { number }),
 			...(once !== undefined && { once }),
 		},
-		run: { kind: run.kind, flow: run.flow, packages, image, resume, replicas, ...(command !== undefined && { command }), ...(skillsDir !== undefined && { skillsDir }), ...(instructions !== undefined && { instructions }), ...(secrets !== undefined && { secrets }), ...(secretsProfile !== undefined && { secretsProfile }), ...(waitFor !== undefined && { waitFor }), ...(backend !== undefined && { backend }), ...(excludeTools !== undefined && { excludeTools }), ...(mcp !== undefined && { mcp }), ...ref },
+		run: { kind: run.kind, flow: run.flow, packages, image, resume, replicas, ...(awaitInput !== undefined && { awaitInput }), ...(command !== undefined && { command }), ...(skillsDir !== undefined && { skillsDir }), ...(instructions !== undefined && { instructions }), ...(secrets !== undefined && { secrets }), ...(secretsProfile !== undefined && { secretsProfile }), ...(waitFor !== undefined && { waitFor }), ...(backend !== undefined && { backend }), ...(excludeTools !== undefined && { excludeTools }), ...(mcp !== undefined && { mcp }), ...ref },
 	};
 }