@zq-silk/yui 0.6.0 → 0.6.2

package/dist/job/jobRunner.js

@@ -0,0 +1,350 @@
+/**
+ * Standalone durable-job runner.
+ *
+ * Receives exactly one argument: the absolute path to a `spec.json` written
+ * atomically by the Controller. The runner MUST NOT open state.json or any
+ * other control-plane file; its entire contract is the spec + the artifact
+ * directory. The Controller supervises the runner through the artifact files
+ * (heartbeat, checkpoint.json, exit.json) and the process identity.
+ */
+import { spawn } from "node:child_process";
+import { chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, utimesSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { writeTextFileAtomically } from "../storage/durableFile.js";
+import { readLinuxProcessStartIdentity } from "../controller/domainIdentity.js";
+const DEFAULT_STEP_TIMEOUT_MS = 30 * 60_000;
+const HEARTBEAT_INTERVAL_MS = 5_000;
+const SIGKILL_GRACE_MS = 2_000;
+const CANCEL_FENCE = "cancel";
+/**
+ * The bounded grace between SIGTERM and SIGKILL for a step that ignores the
+ * termination request. Scales with the step timeout (capped) so even the
+ * shortest timeout converges in tests while real checks get the full grace.
+ */
+function sigkillGraceMs(stepTimeoutMs) {
+    return Math.min(SIGKILL_GRACE_MS, Math.max(100, Math.floor(stepTimeoutMs / 2)));
+}
+export async function runDurableJobRunner(specPath) {
+    const spec = readSpec(specPath);
+    const artifactDir = resolve(spec.artifactDir);
+    const logsDir = join(artifactDir, "logs");
+    mkdirSync(logsDir, { recursive: true, mode: 0o700 });
+    chmodSync(artifactDir, 0o700);
+    const heartbeatPath = join(artifactDir, "heartbeat");
+    const checkpointPath = join(artifactDir, "checkpoint.json");
+    const exitPath = join(artifactDir, "exit.json");
+    const cancelPath = join(artifactDir, CANCEL_FENCE);
+    touchHeartbeat(heartbeatPath);
+    const heartbeatTimer = setInterval(() => touchHeartbeat(heartbeatPath), HEARTBEAT_INTERVAL_MS);
+    heartbeatTimer.unref();
+    // f3: Durable startup handshake. Write ready.json with O_EXCL before any
+    // step side effect. If the file already exists, another runner instance
+    // already started — exit to prevent duplicate execution. The supervisor
+    // reads this file to adopt a queued job after a Controller crash.
+    //
+    // rr4/finding-4: The runner writes its own OS startIdentity so the
+    // supervisor can adopt without re-reading /proc (which could return a
+    // reused PID's identity after the original runner exited).
+    const readyPath = join(artifactDir, "ready.json");
+    try {
+        const readyFd = openSync(readyPath, "wx", 0o600);
+        writeFileSync(readyFd, JSON.stringify({
+            pid: process.pid,
+            startIdentity: readLinuxProcessStartIdentity(process.pid) ?? String(process.pid),
+            startedAt: new Date().toISOString()
+        }, null, 2) + "\n");
+        closeSync(readyFd);
+    }
+    catch (error) {
+        if (error.code === "EEXIST") {
+            // Another runner already started for this job. Exit cleanly.
+            return;
+        }
+        throw error;
+    }
+    let cancelled = false;
+    let currentChild = null;
+    // f4: Kill the entire process group so background descendants cannot
+    // survive the runner's terminal exit. Each step runs in its own group
+    // (detached: true), and negative-pid kill targets the whole group.
+    const killProcessGroup = (child, signal) => {
+        if (child.pid === undefined)
+            return;
+        try {
+            process.kill(-child.pid, signal);
+        }
+        catch (error) {
+            if (error.code !== "ESRCH")
+                throw error;
+        }
+    };
+    // f2/rr5: The SIGTERM handler must stay installed and idempotent for the
+    // runner's whole lifetime. A repeated SIGTERM (supervisor re-send, stale-
+    // heartbeat escalation, or a second operator cancel) must NOT bypass the
+    // graceful exit.json write: the first signal sets `cancelled` and kills the
+    // step; subsequent signals during the drain are ignored so the runner can
+    // finish writing exit.json before exiting. Using `process.on` (not `once`)
+    // keeps the handler installed; the early return makes re-entry a no-op.
+    const onSignal = () => {
+        if (cancelled)
+            return;
+        cancelled = true;
+        if (currentChild !== null) {
+            killProcessGroup(currentChild, "SIGTERM");
+            // A child that ignores SIGTERM must not pin the runner: escalate so the
+            // job still reaches its bounded terminal result.
+            setTimeout(() => {
+                if (currentChild !== null)
+                    killProcessGroup(currentChild, "SIGKILL");
+            }, SIGKILL_GRACE_MS).unref();
+        }
+    };
+    process.on("SIGTERM", onSignal);
+    process.on("SIGINT", onSignal);
+    const completedSteps = [];
+    let outcome = "succeeded";
+    let exitCode = 0;
+    let signal = null;
+    let failedStep;
+    try {
+        for (let index = 0; index < spec.steps.length; index += 1) {
+            if (cancelled || existsSync(cancelPath)) {
+                cancelled = true;
+                outcome = "cancelled";
+                exitCode = null;
+                break;
+            }
+            touchHeartbeat(heartbeatPath);
+            const step = spec.steps[index];
+            const stepNumber = String(index + 1).padStart(3, "0");
+            const logName = `${stepNumber}-${sanitizeLogName(step.name)}.log`;
+            const logPath = join(logsDir, logName);
+            const logFd = openSync(logPath, "w", 0o600);
+            const stepTimeoutMs = step.timeoutMs ?? spec.defaultStepTimeoutMs ?? DEFAULT_STEP_TIMEOUT_MS;
+            const startedAt = Date.now();
+            let timedOut = false;
+            let child;
+            try {
+                // Issue 08: a structured argv step executes without a shell so its
+                // tokens can never be reinterpreted; a legacy command step keeps the
+                // shell form. A per-step cwd/env override applies to either form.
+                const stepCwd = step.cwd ?? spec.workspace;
+                const stepEnv = step.env === undefined
+                    ? spec.env
+                    : { ...spec.env, ...step.env };
+                // f4: a new process group (detached) lets the runner kill the whole
+                // step tree on timeout or cancel, for both argv and shell forms.
+                if (step.argv !== undefined) {
+                    const [file, ...args] = step.argv;
+                    child = spawn(file, args, {
+                        cwd: stepCwd,
+                        env: stepEnv,
+                        stdio: ["ignore", logFd, logFd],
+                        detached: true
+                    });
+                }
+                else {
+                    child = spawn("/bin/sh", ["-lc", step.command], {
+                        cwd: stepCwd,
+                        env: stepEnv,
+                        stdio: ["ignore", logFd, logFd],
+                        detached: true
+                    });
+                }
+            }
+            catch (error) {
+                closeSync(logFd);
+                completedSteps.push({
+                    name: step.name,
+                    exitCode: null,
+                    signal: null,
+                    timedOut: false,
+                    durationMs: Date.now() - startedAt,
+                    logPath: logName,
+                    head: spec.head
+                });
+                outcome = "failed";
+                exitCode = null;
+                failedStep = step.name;
+                writeCheckpoint(checkpointPath, completedSteps);
+                break;
+            }
+            currentChild = child;
+            let sigkillTimer;
+            const timeout = setTimeout(() => {
+                timedOut = true;
+                killProcessGroup(child, "SIGTERM");
+                // A step that ignores SIGTERM must still converge: escalate to
+                // SIGKILL after the bounded grace so exit.json is always written.
+                sigkillTimer = setTimeout(() => {
+                    killProcessGroup(child, "SIGKILL");
+                }, sigkillGraceMs(stepTimeoutMs));
+                sigkillTimer.unref();
+            }, stepTimeoutMs);
+            timeout.unref();
+            const result = await new Promise((resolvePromise) => {
+                child.once("error", () => {
+                    resolvePromise({ code: null, signal: null });
+                });
+                child.once("close", (code, sig) => {
+                    resolvePromise({ code, signal: sig ?? null });
+                });
+            });
+            clearTimeout(timeout);
+            if (sigkillTimer !== undefined)
+                clearTimeout(sigkillTimer);
+            closeSync(logFd);
+            currentChild = null;
+            const stepResult = {
+                name: step.name,
+                exitCode: result.code,
+                signal: result.signal,
+                timedOut,
+                durationMs: Date.now() - startedAt,
+                logPath: logName,
+                head: spec.head
+            };
+            completedSteps.push(stepResult);
+            writeCheckpoint(checkpointPath, completedSteps);
+            if (cancelled) {
+                outcome = "cancelled";
+                exitCode = null;
+                break;
+            }
+            if (timedOut) {
+                outcome = "timed-out";
+                exitCode = result.code;
+                signal = result.signal;
+                failedStep = step.name;
+                break;
+            }
+            if (result.code !== 0) {
+                outcome = "failed";
+                exitCode = result.code;
+                signal = result.signal;
+                failedStep = step.name;
+                break;
+            }
+        }
+    }
+    finally {
+        clearInterval(heartbeatTimer);
+        // f2/rr5: Do NOT remove the signal handlers here. A repeated SIGTERM
+        // between the step loop and the exit.json write must still hit the
+        // idempotent handler (which ignores it) rather than the default handler
+        // (which would kill the process before exit.json is written). The
+        // handlers are removed after the exit.json write below.
+    }
+    const exit = {
+        outcome,
+        exitCode,
+        signal,
+        ...(failedStep === undefined ? {} : { failedStep }),
+        steps: completedSteps,
+        finishedAt: new Date().toISOString()
+    };
+    writeTextFileAtomically(exitPath, `${JSON.stringify(exit, null, 2)}\n`);
+    // f2/rr5: exit.json is durable — the signal handlers are no longer needed.
+    process.removeListener("SIGTERM", onSignal);
+    process.removeListener("SIGINT", onSignal);
+}
+function readSpec(specPath) {
+    const resolved = resolve(specPath);
+    const raw = readJsonFile(resolved);
+    const spec = raw;
+    if (typeof spec.jobId !== "string" || spec.jobId.length === 0) {
+        throw new Error("DurableJob spec is missing jobId.");
+    }
+    if (typeof spec.taskId !== "string" || spec.taskId.length === 0) {
+        throw new Error("DurableJob spec is missing taskId.");
+    }
+    if (typeof spec.workspace !== "string" || !spec.workspace.startsWith("/")) {
+        throw new Error("DurableJob spec workspace must be an absolute path.");
+    }
+    if (typeof spec.artifactDir !== "string" || !spec.artifactDir.startsWith("/")) {
+        throw new Error("DurableJob spec artifactDir must be an absolute path.");
+    }
+    if (typeof spec.head !== "string" || spec.head.length === 0) {
+        throw new Error("DurableJob spec is missing head.");
+    }
+    if (typeof spec.env !== "object" || spec.env === null || Array.isArray(spec.env)) {
+        throw new Error("DurableJob spec env must be a map.");
+    }
+    if (!Array.isArray(spec.steps) || spec.steps.length === 0) {
+        throw new Error("DurableJob spec must have at least one step.");
+    }
+    for (const step of spec.steps) {
+        if (typeof step.name !== "string" || step.name.length === 0) {
+            throw new Error("DurableJob spec step is missing name.");
+        }
+        if (typeof step.command !== "string" || step.command.length === 0) {
+            throw new Error(`DurableJob spec step ${step.name} is missing command.`);
+        }
+        if (step.argv !== undefined) {
+            if (!Array.isArray(step.argv) || step.argv.length === 0
+                || step.argv.some((value) => typeof value !== "string" || value.length === 0)) {
+                throw new Error(`DurableJob spec step ${step.name} argv is invalid.`);
+            }
+        }
+        if (step.cwd !== undefined
+            && (typeof step.cwd !== "string" || !step.cwd.startsWith("/"))) {
+            throw new Error(`DurableJob spec step ${step.name} cwd must be absolute.`);
+        }
+        if (step.env !== undefined
+            && (typeof step.env !== "object" || step.env === null || Array.isArray(step.env))) {
+            throw new Error(`DurableJob spec step ${step.name} env must be a map.`);
+        }
+        if (step.timeoutMs !== undefined
+            && (!Number.isSafeInteger(step.timeoutMs) || step.timeoutMs < 1)) {
+            throw new Error(`DurableJob spec step ${step.name} timeoutMs is invalid.`);
+        }
+    }
+    return spec;
+}
+function readJsonFile(path) {
+    const raw = readFileSync(path, "utf8");
+    return JSON.parse(raw);
+}
+function touchHeartbeat(path) {
+    try {
+        utimesSync(path, new Date(), new Date());
+    }
+    catch {
+        try {
+            const fd = openSync(path, "w", 0o600);
+            closeSync(fd);
+        }
+        catch {
+            // Best-effort liveness proof; the supervisor detects staleness.
+        }
+    }
+}
+function writeCheckpoint(path, completedSteps) {
+    const checkpoint = {
+        completedSteps,
+        updatedAt: new Date().toISOString()
+    };
+    writeTextFileAtomically(path, `${JSON.stringify(checkpoint, null, 2)}\n`);
+}
+function sanitizeLogName(name) {
+    return name.replace(/[^a-zA-Z0-9._-]/gu, "_").slice(0, 80) || "step";
+}
+function isEntrypoint() {
+    return process.argv[1] !== undefined
+        && resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+}
+if (isEntrypoint()) {
+    const specPath = process.argv[2];
+    if (typeof specPath !== "string" || specPath.length === 0) {
+        process.stderr.write("Usage: jobRunner.js <spec.json>\n");
+        process.exitCode = 1;
+    }
+    else {
+        void runDurableJobRunner(specPath).catch((error) => {
+            const message = error instanceof Error ? error.message : String(error);
+            process.stderr.write(`DurableJob runner failed: ${message}\n`);
+            process.exitCode = 1;
+        });
+    }
+}

package/dist/lifecycle/exactRunTerminalization.js

@@ -6,7 +6,9 @@ import { terminalizeTaskRoleRunSession } from "../executor/agentExecutor.js";
 import { updateRoleStatus } from "../role/role.js";
 import { createTaskEvent } from "../event/taskEvent.js";
 import { finishReviewRound, updateReviewExecutionGroup } from "../review/reviewRound.js";
-import { failAgentRun, yieldAgentRun } from "../run/agentRun.js";
+import { reconcileReviewFindingsAfterReview } from "../review/reviewFindingLedger.js";
+import { failAgentRun, withYieldReceipt, yieldAgentRun } from "../run/agentRun.js";
+import { createYieldReceipt } from "../run/yieldReceipt.js";
 import { recordExecutionLaneResult } from "../execution/executionGroup.js";
 import { formatAgentRunReceiptId } from "../task/taskRecordReference.js";
 import { isRuntimeLaunchReservation, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
@@ -178,6 +180,11 @@ export function terminalizeExactRunReviewRound(store, input, now) {
     }
     const terminal = finishReviewRound(groupedRound, input.outcome.status === "yielded" ? "completed" : "failed", input.outcome.summary, now, input.reviewResult);
     store.saveReviewRound(input.taskId, terminal);
+    // Issue 06: a completed (semantic) Round feeds the finding ledger; a failed
+    // execution attempt is skipped by the classifier and never creates findings.
+    if (terminal.status === "completed") {
+        reconcileReviewFindingsAfterReview(store, input.taskId, terminal.id, now);
+    }
     return { disposition: "applied", round: terminal };
 }
 /**
@@ -264,7 +271,22 @@ export function terminalizeExactTaskRun(store, input, now) {
         return obsolete(run, reviewRoundTerminalization.reason ?? "review-round-mismatch");
     }
     const terminal = input.outcome.status === "yielded"
-        ? yieldAgentRun(run, input.outcome.summary, now)
+        ? withYieldReceipt(yieldAgentRun(run, input.outcome.summary, now), createYieldReceipt(input.taskId, input.runId, {
+            status: "yielded",
+            summary: input.outcome.summary,
+            ...(input.reviewResult === undefined
+                ? {}
+                : {
+                    reviewResult: {
+                        ...(input.reviewResult.report === undefined ? {} : { report: input.reviewResult.report }),
+                        ...(input.reviewResult.checks === undefined ? {} : { checks: input.reviewResult.checks }),
+                        ...(input.reviewResult.findings === undefined ? {} : { findings: input.reviewResult.findings }),
+                        ...(input.reviewResult.evidence === undefined ? {} : { evidence: input.reviewResult.evidence }),
+                        ...(input.reviewResult.evidenceCommit === undefined ? {} : { evidenceCommit: input.reviewResult.evidenceCommit }),
+                        ...(input.reviewResult.gitSnapshot === undefined ? {} : { gitSnapshot: input.reviewResult.gitSnapshot })
+                    }
+                })
+        }, now))
         : failAgentRun(run, input.outcome.summary, now);
     if (run.executionGroupId !== undefined
         && run.executionLaneId !== undefined

package/dist/lifecycle/providerErrorClass.js

@@ -0,0 +1,126 @@
+/**
+ * Issue 04 — Provider error classification.
+ *
+ * Provider failures arrive as opaque free text (Claude StopFailure
+ * `error`/`errorDetails`, Codex turn-completion summaries). The retry-in-place
+ * coordinator needs a stable, provider-neutral error class before it can decide
+ * whether the original Session may be retried. This module is the single
+ * classifier: it is pure, table-driven, and deliberately conservative.
+ *
+ * Classes (Issue 04 §2):
+ * - `transient-provider`   — 500/502/504, connection reset, backend capacity;
+ *                            the original Session is retried in place.
+ * - `transport-uncertain`  — the request may have been accepted but the
+ *                            response was lost; native facts are consulted
+ *                            before any resend.
+ * - `policy-denied`        — cyber_policy / permission boundary; never retried
+ *                            automatically, never worked around by switching
+ *                            Session or widening permission.
+ * - `session-dead`         — the process/tmux/native identity is gone; in-place
+ *                            retry stops and a replacement blocker is raised.
+ * - `invalid-request`      — deterministic parameter/protocol error; fail fast,
+ *                            never call the Provider again.
+ * - `unclassified`         — no conservative match; behaves like
+ *                            `invalid-request` for retry purposes (old
+ *                            terminalize-immediately behavior) while remaining
+ *                            observable in shadow metrics.
+ */
+/** Classes for which the original Session may be retried in place. */
+export const RETRYABLE_PROVIDER_ERROR_CLASSES = [
+    "transient-provider",
+    "transport-uncertain"
+];
+export function isRetryableProviderErrorClass(errorClass) {
+    return RETRYABLE_PROVIDER_ERROR_CLASSES.includes(errorClass);
+}
+/**
+ * Ordered pattern tables. The first class whose pattern matches wins, so the
+ * table order is the precedence order. Patterns are matched case-insensitively
+ * against the concatenation of every available text field.
+ */
+const SESSION_DEAD_PATTERNS = [
+    { pattern: /session not found/iu, label: "session-not-found" },
+    { pattern: /no such (session|thread)/iu, label: "no-such-session" },
+    { pattern: /thread not found/iu, label: "thread-not-found" },
+    { pattern: /session (has )?expired/iu, label: "session-expired" },
+    { pattern: /session (has )?ended/iu, label: "session-ended" },
+    { pattern: /session (is )?dead/iu, label: "session-dead" },
+    { pattern: /session terminated/iu, label: "session-terminated" },
+    { pattern: /process exited/iu, label: "process-exited" },
+    { pattern: /pane (is )?dead/iu, label: "pane-dead" },
+    { pattern: /target session/iu, label: "target-session" }
+];
+const POLICY_DENIED_PATTERNS = [
+    { pattern: /cyber[_-]?policy/iu, label: "cyber-policy" },
+    { pattern: /policy[_-]?violation/iu, label: "policy-violation" },
+    { pattern: /usage[_-]?policy/iu, label: "usage-policy" },
+    { pattern: /content[_-]?policy/iu, label: "content-policy" },
+    { pattern: /safety[_-]?policy/iu, label: "safety-policy" },
+    { pattern: /policy denial/iu, label: "policy-denial" }
+];
+const INVALID_REQUEST_PATTERNS = [
+    { pattern: /invalid[_-]?request/iu, label: "invalid-request" },
+    { pattern: /validation error/iu, label: "validation-error" },
+    { pattern: /bad request/iu, label: "bad-request" },
+    { pattern: /\b400\b/u, label: "http-400" },
+    { pattern: /unknown (flag|tool|argument)/iu, label: "unknown-argument" },
+    { pattern: /unexpected argument/iu, label: "unexpected-argument" },
+    { pattern: /invalid schema/iu, label: "invalid-schema" }
+];
+const TRANSIENT_PROVIDER_PATTERNS = [
+    { pattern: /\b50[024]\b/u, label: "http-5xx" },
+    { pattern: /server[_-]?error/iu, label: "server-error" },
+    { pattern: /internal server error/iu, label: "internal-server-error" },
+    { pattern: /connection lost/iu, label: "connection-lost" },
+    { pattern: /connection reset/iu, label: "connection-reset" },
+    { pattern: /econnreset/iu, label: "econnreset" },
+    { pattern: /socket hang up/iu, label: "socket-hang-up" },
+    { pattern: /kv[_-]?cache[_-]?allocate[_-]?failed/iu, label: "kv-cache-allocate-failed" },
+    { pattern: /overloaded/iu, label: "overloaded" },
+    { pattern: /\b429\b/u, label: "http-429" },
+    { pattern: /rate[_-]?limit/iu, label: "rate-limit" },
+    { pattern: /upstream/iu, label: "upstream" },
+    { pattern: /bad gateway/iu, label: "bad-gateway" },
+    { pattern: /gateway timeout/iu, label: "gateway-timeout" },
+    { pattern: /service unavailable/iu, label: "service-unavailable" },
+    { pattern: /temporarily unavailable/iu, label: "temporarily-unavailable" },
+    { pattern: /try again/iu, label: "try-again" }
+];
+const TRANSPORT_UNCERTAIN_PATTERNS = [
+    { pattern: /timed?[ -]?out/iu, label: "timeout" },
+    { pattern: /etimedout/iu, label: "etimedout" },
+    { pattern: /response lost/iu, label: "response-lost" },
+    { pattern: /lost response/iu, label: "lost-response" },
+    { pattern: /stream interrupted/iu, label: "stream-interrupted" },
+    { pattern: /interrupted function/iu, label: "interrupted-function" },
+    { pattern: /controller timeout/iu, label: "controller-timeout" },
+    { pattern: /delivery (unconfirmed|uncertain|not confirmed)/iu, label: "delivery-unconfirmed" },
+    { pattern: /unconfirmed delivery/iu, label: "unconfirmed-delivery" },
+    { pattern: /no response/iu, label: "no-response" }
+];
+const CLASS_TABLE = [
+    { errorClass: "session-dead", patterns: SESSION_DEAD_PATTERNS },
+    { errorClass: "policy-denied", patterns: POLICY_DENIED_PATTERNS },
+    { errorClass: "invalid-request", patterns: INVALID_REQUEST_PATTERNS },
+    { errorClass: "transient-provider", patterns: TRANSIENT_PROVIDER_PATTERNS },
+    { errorClass: "transport-uncertain", patterns: TRANSPORT_UNCERTAIN_PATTERNS }
+];
+/**
+ * Classifies one provider failure. Every available text field is concatenated
+ * so a class can be recognized regardless of which field carried it. Unknown
+ * text is `unclassified`, which keeps the old fail-immediately behavior.
+ */
+export function classifyProviderError(input) {
+    const text = [input.error, input.errorDetails, input.summary]
+        .filter((value) => typeof value === "string" && value.length > 0)
+        .join("\n");
+    if (text.length === 0)
+        return { errorClass: "unclassified", matched: "none" };
+    for (const { errorClass, patterns } of CLASS_TABLE) {
+        for (const { pattern, label } of patterns) {
+            if (pattern.test(text))
+                return { errorClass, matched: label };
+        }
+    }
+    return { errorClass: "unclassified", matched: "none" };
+}

package/dist/message/message.js

@@ -3,12 +3,15 @@ export const TASK_MESSAGE_KINDS = ["user", "operator", "role-result", "system"];
 export function createTaskMessage(id, taskId, body, kind, author, now, context = {}) {
     validateKindAndAuthor(kind, author);
     const message = {
-        schemaVersion: 2,
+        schemaVersion: 3,
         id: requireSafeIdentity(id, "Message id"),
         taskId: requireSafeIdentity(taskId, "Message Task id"),
         kind,
         author: normalizeAuthor(author),
         body: requireBody(body),
+        ...(context.wakePolicy === undefined
+            ? {}
+            : { wakePolicy: context.wakePolicy }),
         ...(context.runId === undefined
             ? {}
             : { runId: requireSafeIdentity(context.runId, "Message Run id") }),
@@ -24,12 +27,22 @@ export function taskMessageAuthorLabel(author) {
     return author.type === "role" ? author.roleName : author.type;
 }
 export function validateTaskMessage(message) {
-    if (message.schemaVersion !== 2)
-        throw new Error("Task Message must use schemaVersion 2.");
+    if (message.schemaVersion !== 3)
+        throw new Error("Task Message must use schemaVersion 3.");
     validateTaskRecordReference({ taskId: message.taskId, localId: message.id }, "message");
     requireText(message.body, "Message body");
     validateKindAndAuthor(message.kind, message.author);
     normalizeAuthor(message.author);
+    if (message.wakePolicy !== undefined
+        && message.wakePolicy !== "leader"
+        && message.wakePolicy !== "none") {
+        throw new Error(`Message wakePolicy is invalid: ${String(message.wakePolicy)}.`);
+    }
+    if (message.wakePolicy !== undefined
+        && message.kind !== "user"
+        && message.kind !== "operator") {
+        throw new Error("Message wakePolicy is only valid for user/operator messages.");
+    }
     if (message.runId !== undefined)
         requireSafeIdentity(message.runId, "Message Run id");
     if (message.workItemId !== undefined) {