@zq-silk/yui 0.13.9 → 0.14.0

package/dist/run/agentRun.js

@@ -1,356 +0,0 @@
-import { validateEffectiveLaunchSnapshot } from "../executor/effectiveLaunch.js";
-import { formatAgentRunReceiptId, validateTaskRecordReference } from "../task/taskRecordReference.js";
-import { validateYieldReceipt } from "./yieldReceipt.js";
-import { validateAgentRunControlRequest } from "./runControlRequest.js";
-import { validateManagedWorkspace } from "../worktree/managedWorkspace.js";
-import { createRunAssignment, createRunBootstrapEnvelope, validateRunAssignment, validateRunBootstrapEnvelope } from "../context/runContextContract.js";
-export function createAgentRun(id, taskId, roleName, mode, assignment, now, context) {
-    if (mode !== "new" && mode !== "resume") {
-        throw new Error(`Agent run dispatch mode is invalid: ${mode}.`);
-    }
-    const timestamp = now.toISOString();
-    const normalizedAssignment = typeof assignment === "string"
-        ? createRunAssignment({
-            runId: id,
-            roleName,
-            purpose: context.purpose ?? "execution",
-            action: context.purpose === "review"
-                ? "review-round"
-                : context.workItemId === undefined ? "leader-wake" : "execute-work-item",
-            subject: {
-                taskId,
-                ...(context.workItemId === undefined ? {} : { workItemId: context.workItemId }),
-                ...(context.purpose === "review"
-                    ? { reviewRoundId: context.reviewRoundId ?? `legacy-${id}` }
-                    : context.reviewRoundId === undefined ? {} : { reviewRoundId: context.reviewRoundId })
-            },
-            directive: assignment,
-            deltaRefIds: []
-        })
-        : validateRunAssignment(assignment);
-    return {
-        schemaVersion: 10,
-        id: requireSafeIdentity(id, "Agent run id"),
-        taskId: requireSafeIdentity(taskId, "Task id"),
-        roleName: requireSafeIdentity(roleName, "Role name"),
-        mode,
-        assignment: normalizedAssignment,
-        bootstrapEnvelope: createRunBootstrapEnvelope(normalizedAssignment),
-        purpose: context.purpose ?? "execution",
-        ...(context.workItemId === undefined
-            ? {}
-            : { workItemId: requireSafeIdentity(context.workItemId, "Work item id") }),
-        ...(context.reviewRoundId === undefined
-            ? {}
-            : { reviewRoundId: requireSafeIdentity(context.reviewRoundId, "ReviewRound id") }),
-        ...(context.executionGroupId === undefined
-            ? {}
-            : { executionGroupId: requireSafeIdentity(context.executionGroupId, "ExecutionGroup id") }),
-        ...(context.executionLaneId === undefined
-            ? {}
-            : { executionLaneId: requireSafeIdentity(context.executionLaneId, "ExecutionLane id") }),
-        ...(context.workspace === undefined
-            ? {}
-            : { workspace: validateManagedWorkspace(context.workspace) }),
-        effective: validateEffectiveLaunchSnapshot(context.effective),
-        status: "active",
-        createdAt: timestamp,
-        updatedAt: timestamp
-    };
-}
-export function isActiveAgentRun(run) {
-    return run.status === "active";
-}
-/** Binds a freshly created, not-yet-persisted Run to its frozen Context. */
-export function withAgentRunContextSnapshot(run, snapshot, deltaRefIds = []) {
-    if (run.status !== "active" || run.pushedAt !== undefined || run.deliveredAt !== undefined) {
-        throw new Error(`Cannot bind Context Snapshot after Run delivery: ${run.id}.`);
-    }
-    const assignment = createRunAssignment({
-        ...run.assignment,
-        contextSnapshotRef: snapshot,
-        deltaRefIds
-    });
-    return validateAgentRun(Object.freeze({
-        ...run,
-        assignment,
-        bootstrapEnvelope: createRunBootstrapEnvelope(assignment)
-    }));
-}
-export function markAgentRunPushed(run, now) {
-    if (run.status !== "active") {
-        throw new Error(`Cannot push a terminal Agent run: ${run.id}.`);
-    }
-    if (run.pushedAt !== undefined)
-        return run;
-    const timestamp = now.toISOString();
-    return { ...run, pushedAt: timestamp, updatedAt: timestamp };
-}
-export function markAgentRunDelivered(run, now) {
-    if (run.status !== "active") {
-        throw new Error(`Cannot deliver a terminal Agent run: ${run.id}.`);
-    }
-    if (run.deliveredAt !== undefined)
-        return run;
-    const timestamp = now.toISOString();
-    // Acceptance implies the prompt was pushed first; record both so a consumer
-    // never sees delivered-without-pushed.
-    return {
-        ...run,
-        ...(run.pushedAt === undefined ? { pushedAt: timestamp } : {}),
-        deliveredAt: timestamp,
-        updatedAt: timestamp
-    };
-}
-export function validateAgentRun(run) {
-    if (run.schemaVersion !== 10)
-        throw new Error("Agent run must use schemaVersion 10.");
-    validateTaskRecordReference({ taskId: run.taskId, localId: run.id }, "agentRun");
-    requireSafeIdentity(run.roleName, "Role name");
-    if (run.mode !== "new" && run.mode !== "resume") {
-        throw new Error(`Agent run dispatch mode is invalid: ${String(run.mode)}.`);
-    }
-    validateRunAssignment(run.assignment);
-    validateRunBootstrapEnvelope(run.bootstrapEnvelope);
-    if (run.assignment.runId !== run.id || run.assignment.roleName !== run.roleName
-        || run.assignment.subject.taskId !== run.taskId) {
-        throw new Error("Agent run Assignment identity does not match the Run.");
-    }
-    if (JSON.stringify(createRunBootstrapEnvelope(run.assignment))
-        !== JSON.stringify(run.bootstrapEnvelope)) {
-        throw new Error("Agent run Bootstrap Envelope does not match its Assignment.");
-    }
-    if (!["execution", "review"].includes(run.purpose)) {
-        throw new Error(`Agent run purpose is invalid: ${String(run.purpose)}.`);
-    }
-    if (run.workItemId !== undefined) {
-        validateTaskRecordReference({ taskId: run.taskId, localId: run.workItemId }, "workItem");
-    }
-    if (run.reviewRoundId !== undefined) {
-        validateTaskRecordReference({ taskId: run.taskId, localId: run.reviewRoundId }, "reviewRound");
-    }
-    if ((run.executionGroupId === undefined) !== (run.executionLaneId === undefined)) {
-        throw new Error("Agent run execution lineage is incomplete.");
-    }
-    if (run.executionGroupId !== undefined) {
-        requireSafeIdentity(run.executionGroupId, "ExecutionGroup id");
-        requireSafeIdentity(run.executionLaneId, "ExecutionLane id");
-    }
-    if (run.workspace !== undefined) {
-        validateManagedWorkspace(run.workspace);
-        if (run.workspace.owner.taskId !== run.taskId) {
-            throw new Error("Agent run workspace belongs to another Task.");
-        }
-        if (run.workspace.owner.type === "work-item"
-            && run.workspace.owner.workItemId !== run.workItemId) {
-            throw new Error("Agent run workspace belongs to another Work Item.");
-        }
-        if (run.workspace.owner.type === "work-item" && run.workItemId === undefined) {
-            throw new Error("A WorkItem workspace requires a WorkItem Agent run reference.");
-        }
-        if (run.workspace.owner.type === "review-round" && run.purpose !== "review") {
-            throw new Error("A ReviewRound workspace requires a review Agent run.");
-        }
-        if (run.workspace.owner.type === "integration-attempt") {
-            throw new Error("An IntegrationAttempt workspace cannot be used by an Agent run.");
-        }
-        if (run.workspace.owner.type === "execution-lane") {
-            if (run.workspace.owner.executionGroupId !== run.executionGroupId
-                || run.workspace.owner.executionLaneId !== run.executionLaneId) {
-                throw new Error("Agent run Execution Lane workspace lineage does not match the Run.");
-            }
-            if (run.workspace.owner.purpose === "execution"
-                && run.workspace.owner.workItemId !== run.workItemId) {
-                throw new Error("Agent run Execution Lane workspace WorkItem does not match the Run.");
-            }
-            if (run.workspace.owner.purpose === "review"
-                && run.workspace.owner.reviewRoundId !== run.reviewRoundId) {
-                throw new Error("Agent run review Lane workspace ReviewRound does not match the Run.");
-            }
-        }
-        if (run.workspace.owner.type === "review-round"
-            && run.workspace.owner.reviewRoundId !== run.reviewRoundId) {
-            throw new Error(`Agent run ReviewRound workspace owner does not match ${run.reviewRoundId ?? "none"}.`);
-        }
-    }
-    if (run.purpose === "review") {
-        if (run.reviewRoundId === undefined) {
-            throw new Error("A review Agent run requires a ReviewRound reference.");
-        }
-        if (run.workspace === undefined
-            || !((run.workspace.owner.type === "review-round"
-                && run.workspace.owner.reviewRoundId === run.reviewRoundId)
-                || (run.workspace.owner.type === "execution-lane"
-                    && run.workspace.owner.purpose === "review"
-                    && run.workspace.owner.reviewRoundId === run.reviewRoundId))) {
-            throw new Error(`A review Agent run requires its exact ReviewRound workspace owner: ${run.reviewRoundId}.`);
-        }
-        if (run.workspace.entries.length === 0
-            || run.workspace.entries.some(({ access }) => access !== "write")) {
-            throw new Error("A review Agent run requires only isolated writable workspace entries.");
-        }
-    }
-    else {
-        if (run.reviewRoundId !== undefined) {
-            throw new Error("An execution Agent run cannot reference a ReviewRound.");
-        }
-        if (run.workspace?.owner.type === "review-round") {
-            throw new Error("An execution Agent run cannot use a ReviewRound-owned workspace.");
-        }
-        if (run.workspace?.owner.type === "execution-lane" && run.workspace.owner.purpose !== "execution") {
-            throw new Error("An execution Agent run cannot use a review Lane workspace.");
-        }
-    }
-    validateEffectiveLaunchSnapshot(run.effective);
-    if (run.workspace !== undefined
-        && (run.effective.workspace.root !== run.workspace.root
-            || JSON.stringify(run.effective.workspace.entries) !== JSON.stringify(run.workspace.entries))) {
-        throw new Error("Agent run effective workspace does not match its managed workspace.");
-    }
-    if (run.purpose === "review") {
-        if (run.effective.reviewRoundId !== run.reviewRoundId) {
-            throw new Error("Review Agent run effective provenance does not match its ReviewRound.");
-        }
-        if (!run.workspace.entries.some(({ baseCommit }) => baseCommit === run.effective.reviewBaseCommit)) {
-            throw new Error("Review Agent run effective base does not match its workspace.");
-        }
-    }
-    else if (run.effective.reviewRoundId !== undefined) {
-        throw new Error("Execution Agent run cannot carry Review effective provenance.");
-    }
-    if (!["active", "yielded", "failed"].includes(run.status)) {
-        throw new Error(`Agent run status is invalid: ${String(run.status)}.`);
-    }
-    requireTimestamp(run.createdAt, "Agent run createdAt");
-    requireTimestamp(run.updatedAt, "Agent run updatedAt");
-    if (run.pushedAt !== undefined)
-        requireTimestamp(run.pushedAt, "Agent run pushedAt");
-    if (run.deliveredAt !== undefined) {
-        requireTimestamp(run.deliveredAt, "Agent run deliveredAt");
-        // Acceptance can never precede its transport push.
-        if (run.pushedAt === undefined) {
-            throw new Error("Agent run deliveredAt requires a prior pushedAt.");
-        }
-    }
-    if (run.deliveryReceiptId !== undefined) {
-        requireText(run.deliveryReceiptId, "Agent run deliveryReceiptId");
-        if (run.deliveryReceiptId.length > 256) {
-            throw new Error("Agent run deliveryReceiptId exceeds 256 characters.");
-        }
-    }
-    if (run.status === "active") {
-        if (run.summary !== undefined || run.endedAt !== undefined) {
-            throw new Error("An active Agent run cannot have terminal metadata.");
-        }
-        if (run.disposition !== undefined
-            || run.observedActionabilityDigest !== undefined
-            || run.waitReason !== undefined) {
-            throw new Error("An active Agent run cannot carry Leader receipt metadata.");
-        }
-    }
-    else {
-        requireText(run.summary ?? "", "Agent run summary");
-        requireTimestamp(run.endedAt ?? "", "Agent run endedAt");
-        if (run.disposition !== undefined
-            && !["progress", "waiting", "blocked", "completed"].includes(run.disposition)) {
-            throw new Error(`Agent run disposition is invalid: ${String(run.disposition)}.`);
-        }
-        if (run.observedActionabilityDigest !== undefined) {
-            requireText(run.observedActionabilityDigest, "Agent run observedActionabilityDigest");
-        }
-        if (run.waitReason !== undefined) {
-            requireText(run.waitReason.kind, "Agent run waitReason kind");
-            if (run.waitReason.ref !== undefined) {
-                requireText(run.waitReason.ref, "Agent run waitReason ref");
-            }
-        }
-    }
-    if (run.controlRequest !== undefined) {
-        validateAgentRunControlRequest(run.controlRequest);
-        if (run.status !== "active") {
-            throw new Error("A terminal Agent run cannot carry a controlRequest projection.");
-        }
-    }
-    if (run.yieldReceipt !== undefined) {
-        validateYieldReceipt(run.yieldReceipt);
-        if (run.status !== "yielded") {
-            throw new Error("An Agent run yield receipt requires a yielded Run.");
-        }
-    }
-    return run;
-}
-export function yieldAgentRun(run, summary, now) {
-    return finishAgentRun(run, "yielded", requireResultText(summary, "Agent run summary"), now);
-}
-export function failAgentRun(run, summary, now) {
-    return finishAgentRun(run, "failed", requireResultText(summary, "Agent run summary"), now);
-}
-function finishAgentRun(run, status, summary, now) {
-    if (run.status !== "active") {
-        throw new Error(`Agent run is already terminal: ${run.id}.`);
-    }
-    const timestamp = now.toISOString();
-    const terminal = {
-        ...run,
-        status,
-        summary,
-        updatedAt: timestamp,
-        endedAt: timestamp
-    };
-    if (terminal.controlRequest !== undefined)
-        delete terminal.controlRequest;
-    return terminal;
-}
-export function agentRunDeliveryReceiptId(run) {
-    return run.deliveryReceiptId
-        ?? run.controlRequest?.receiptId
-        ?? formatAgentRunReceiptId(run.taskId, run.id);
-}
-export function withAgentRunControlRequest(run, request, now) {
-    if (run.status !== "active") {
-        throw new Error(`Agent run cannot accept a control request: ${run.id}.`);
-    }
-    return validateAgentRun({
-        ...run,
-        mode: "resume",
-        deliveryReceiptId: request.receiptId,
-        controlRequest: validateAgentRunControlRequest(request),
-        updatedAt: now.toISOString()
-    });
-}
-/** Attaches the Issue 04 yield receipt to a yielded Run. */
-export function withYieldReceipt(run, receipt) {
-    if (run.status !== "yielded") {
-        throw new Error(`Cannot attach a yield receipt to a non-yielded Agent run: ${run.id}.`);
-    }
-    return validateAgentRun({ ...run, yieldReceipt: receipt });
-}
-function requireSafeIdentity(value, label) {
-    const normalized = requireText(value, label);
-    if (["__proto__", "prototype", "constructor", ".", ".."].includes(normalized)
-        || /[\/\\\0]/.test(normalized)) {
-        throw new Error(`${label} is invalid.`);
-    }
-    return normalized;
-}
-function requireText(value, label) {
-    if (typeof value !== "string" || value.includes("\0"))
-        throw new Error(`${label} is invalid.`);
-    const normalized = value.trim();
-    if (normalized.length === 0)
-        throw new Error(`${label} is required.`);
-    return normalized;
-}
-/** Result transport preserves the provider's complete text, including outer whitespace. */
-function requireResultText(value, label) {
-    if (typeof value !== "string" || value.includes("\0"))
-        throw new Error(`${label} is invalid.`);
-    if (value.trim().length === 0)
-        throw new Error(`${label} is required.`);
-    return value;
-}
-function requireTimestamp(value, label) {
-    if (typeof value !== "string" || !Number.isFinite(Date.parse(value))) {
-        throw new Error(`${label} must be an ISO timestamp.`);
-    }
-}

package/dist/run/rejectedYieldAttempt.js

@@ -1,221 +0,0 @@
-import { contextContentDigest, validateContextSnapshotRef } from "../context/contextSnapshot.js";
-import { computeYieldOutcomeDigest } from "./yieldReceipt.js";
-export const RUN_YIELD_REJECTED_EVENT = "run.yield-rejected";
-const MAX_SUMMARY_CHARACTERS = 2_000;
-const MAX_REPORT_CHARACTERS = 8_000;
-const MAX_CHECKS = 16;
-const MAX_FINDINGS = 16;
-const MAX_EVIDENCE = 16;
-const MAX_LABEL_CHARACTERS = 128;
-const MAX_DETAILS_CHARACTERS = 512;
-const MAX_EVIDENCE_CHARACTERS = 512;
-/**
- * Creates the bounded diagnostic projection persisted when a Reviewer report
- * cannot cross the exact terminalization fence. The full validated submission
- * participates in the immutable digest, while only known, size-bounded fields
- * are retained as non-authoritative evidence.
- */
-export function createRejectedYieldAttempt(input) {
-    const reviewResult = input.reviewResult;
-    const fullReport = reviewResult?.report ?? input.summary;
-    const contentDigest = computeYieldOutcomeDigest({
-        status: "yielded",
-        summary: input.summary,
-        ...(reviewResult === undefined ? {} : { reviewResult })
-    });
-    const summary = boundedText(input.summary, MAX_SUMMARY_CHARACTERS);
-    const report = boundedText(fullReport, MAX_REPORT_CHARACTERS);
-    const checks = (reviewResult?.checks ?? []).slice(0, MAX_CHECKS).map((check) => ({
-        name: boundedText(check.name, MAX_LABEL_CHARACTERS),
-        outcome: check.outcome,
-        ...(check.details === undefined
-            ? {}
-            : { details: boundedText(check.details, MAX_DETAILS_CHARACTERS) })
-    }));
-    const findings = (reviewResult?.findings ?? []).slice(0, MAX_FINDINGS).map((finding) => ({
-        id: boundedText(finding.id, MAX_LABEL_CHARACTERS),
-        severity: finding.severity,
-        status: finding.status,
-        summary: boundedText(finding.summary, MAX_DETAILS_CHARACTERS)
-    }));
-    const evidence = (reviewResult?.evidence ?? []).slice(0, MAX_EVIDENCE)
-        .map((entry) => boundedText(entry, MAX_EVIDENCE_CHARACTERS));
-    const deltaReasoning = reviewResult?.deltaReasoning === undefined
-        ? undefined
-        : boundedText(reviewResult.deltaReasoning, MAX_DETAILS_CHARACTERS);
-    const projectionTruncated = summary !== input.summary
-        || report !== fullReport
-        || checks.length !== (reviewResult?.checks?.length ?? 0)
-        || checks.some((check, index) => (check.name !== reviewResult?.checks?.[index]?.name
-            || check.details !== reviewResult?.checks?.[index]?.details))
-        || findings.length !== (reviewResult?.findings?.length ?? 0)
-        || findings.some((finding, index) => (finding.id !== reviewResult?.findings?.[index]?.id
-            || finding.summary !== reviewResult?.findings?.[index]?.summary))
-        || evidence.length !== (reviewResult?.evidence?.length ?? 0)
-        || evidence.some((entry, index) => entry !== reviewResult?.evidence?.[index])
-        || deltaReasoning !== reviewResult?.deltaReasoning
-        || reviewResult?.gitSnapshot !== undefined;
-    const observed = Object.freeze({
-        nativeSessionId: input.nativeSessionId ?? null,
-        launchId: input.launchId ?? null,
-        durableNativeSessionId: input.durableNativeSessionId ?? null,
-        durableLaunchId: input.durableLaunchId ?? null,
-        inFlightRunId: input.inFlightRunId ?? null,
-        inFlightReceiptId: input.inFlightReceiptId ?? null,
-        activeRunId: input.activeRun?.id ?? null,
-        activeReceiptId: input.activeRun?.receiptId ?? null,
-        contextSnapshot: input.contextSnapshot ?? null,
-        activeContextSnapshot: input.activeRun?.contextSnapshot ?? null
-    });
-    const attemptDigest = contextContentDigest({
-        taskId: input.taskId,
-        runId: input.runId,
-        reviewRoundId: input.reviewRoundId,
-        receiptId: input.receiptId,
-        rejectionReason: input.rejectionReason,
-        contentDigest,
-        observed
-    });
-    return Object.freeze({
-        schemaVersion: 1,
-        authority: "unaccepted",
-        semanticStatus: "diagnostic-only",
-        taskId: input.taskId,
-        runId: input.runId,
-        roleName: input.roleName,
-        purpose: "review",
-        reviewRoundId: input.reviewRoundId,
-        receiptId: input.receiptId,
-        rejectionReason: input.rejectionReason,
-        summary,
-        report,
-        checks: Object.freeze(checks),
-        findings: Object.freeze(findings),
-        evidence: Object.freeze(evidence),
-        ...(reviewResult?.evidenceCommit === undefined
-            ? {}
-            : { evidenceCommit: reviewResult.evidenceCommit }),
-        ...(reviewResult?.deltaDisposition === undefined
-            ? {}
-            : { deltaDisposition: reviewResult.deltaDisposition }),
-        ...(deltaReasoning === undefined ? {} : { deltaReasoning }),
-        projectionTruncated,
-        observed,
-        attemptedAt: input.attemptedAt.toISOString(),
-        contentDigest,
-        attemptDigest
-    });
-}
-export function rejectedYieldAttemptEventPayload(attempt) {
-    return {
-        runId: attempt.runId,
-        roleName: attempt.roleName,
-        reviewRoundId: attempt.reviewRoundId,
-        receiptId: attempt.receiptId,
-        rejectionReason: attempt.rejectionReason,
-        authority: attempt.authority,
-        semanticStatus: attempt.semanticStatus,
-        contentDigest: attempt.contentDigest,
-        attemptDigest: attempt.attemptDigest,
-        attempt: JSON.stringify(attempt)
-    };
-}
-/** Reads only canonical records emitted by rejectedYieldAttemptEventPayload. */
-export function rejectedYieldAttemptFromTaskEvent(event) {
-    if (event.type !== RUN_YIELD_REJECTED_EVENT)
-        return null;
-    try {
-        const parsed = JSON.parse(event.payload.attempt ?? "");
-        if (!isRejectedYieldAttempt(parsed))
-            return null;
-        const expectedAttemptDigest = contextContentDigest({
-            taskId: parsed.taskId,
-            runId: parsed.runId,
-            reviewRoundId: parsed.reviewRoundId,
-            receiptId: parsed.receiptId,
-            rejectionReason: parsed.rejectionReason,
-            contentDigest: parsed.contentDigest,
-            observed: parsed.observed
-        });
-        if (parsed.schemaVersion !== 1
-            || parsed.authority !== "unaccepted"
-            || parsed.semanticStatus !== "diagnostic-only"
-            || parsed.purpose !== "review"
-            || parsed.taskId !== event.taskId
-            || parsed.runId !== event.payload.runId
-            || parsed.roleName !== event.payload.roleName
-            || parsed.reviewRoundId !== event.payload.reviewRoundId
-            || parsed.receiptId !== event.payload.receiptId
-            || parsed.rejectionReason !== event.payload.rejectionReason
-            || parsed.contentDigest !== event.payload.contentDigest
-            || parsed.attemptDigest !== event.payload.attemptDigest
-            || parsed.attemptDigest !== expectedAttemptDigest
-            || parsed.attemptedAt !== event.createdAt
-            || !/^[a-f0-9]{64}$/u.test(parsed.contentDigest)) {
-            return null;
-        }
-        return parsed;
-    }
-    catch {
-        return null;
-    }
-}
-function isRejectedYieldAttempt(value) {
-    if (typeof value !== "object" || value === null || Array.isArray(value))
-        return false;
-    const attempt = value;
-    const observed = attempt.observed;
-    if (typeof observed !== "object" || observed === null || Array.isArray(observed))
-        return false;
-    const nullableObserved = [
-        observed.nativeSessionId,
-        observed.launchId,
-        observed.durableNativeSessionId,
-        observed.durableLaunchId,
-        observed.inFlightRunId,
-        observed.inFlightReceiptId,
-        observed.activeRunId,
-        observed.activeReceiptId
-    ];
-    if (nullableObserved.some((entry) => entry !== null && typeof entry !== "string")) {
-        return false;
-    }
-    if (observed.contextSnapshot !== null)
-        validateContextSnapshotRef(observed.contextSnapshot);
-    if (observed.activeContextSnapshot !== null) {
-        validateContextSnapshotRef(observed.activeContextSnapshot);
-    }
-    return typeof attempt.taskId === "string"
-        && typeof attempt.runId === "string"
-        && typeof attempt.roleName === "string"
-        && typeof attempt.reviewRoundId === "string"
-        && typeof attempt.receiptId === "string"
-        && typeof attempt.rejectionReason === "string"
-        && typeof attempt.summary === "string"
-        && typeof attempt.report === "string"
-        && typeof attempt.projectionTruncated === "boolean"
-        && typeof attempt.attemptedAt === "string"
-        && typeof attempt.contentDigest === "string"
-        && typeof attempt.attemptDigest === "string"
-        && Array.isArray(attempt.checks)
-        && attempt.checks.every((check) => (typeof check === "object" && check !== null
-            && typeof check.name === "string"
-            && ["passed", "failed", "skipped"].includes(check.outcome)
-            && (check.details === undefined || typeof check.details === "string")))
-        && Array.isArray(attempt.findings)
-        && attempt.findings.every((finding) => (typeof finding === "object" && finding !== null
-            && typeof finding.id === "string"
-            && typeof finding.summary === "string"))
-        && Array.isArray(attempt.evidence)
-        && attempt.evidence.every((entry) => typeof entry === "string");
-}
-function boundedText(value, maximum) {
-    const safe = value
-        .replaceAll(/\u001B\][^\u0007]*(?:\u0007|\u001B\\|\u009C)/gu, " ")
-        .replaceAll(/\u001B\[[0-?]*[ -/]*[@-~]/gu, " ")
-        .replaceAll(/[\u0000-\u0008\u000B-\u001F\u007F-\u009F]/gu, " ");
-    const characters = Array.from(safe);
-    if (characters.length <= maximum)
-        return safe;
-    return `${characters.slice(0, maximum - 1).join("")}…`;
-}

package/dist/run/runControlRequest.js

@@ -1,50 +0,0 @@
-import { createHash } from "node:crypto";
-import { requireIdentity, requireTimestamp } from "../domain/validation.js";
-export const WORKFLOW_OUTCOME_REQUEST_TIMEOUT_MS = 30_000;
-export function createWorkflowOutcomeRequest(input) {
-    const requestedAt = input.now.toISOString();
-    return validateAgentRunControlRequest({
-        schemaVersion: 1,
-        kind: "workflow-outcome",
-        requestId: createHash("sha256")
-            .update(`${input.runId}\0${input.nativeTurnId}\0${requestedAt}`)
-            .digest("hex"),
-        state: "dispatching",
-        nativeTurnId: input.nativeTurnId,
-        receiptId: `workflow-outcome-${input.runId}-${input.nativeTurnId}`,
-        requestedAt,
-        deadlineAt: new Date(input.now.getTime() + WORKFLOW_OUTCOME_REQUEST_TIMEOUT_MS).toISOString()
-    });
-}
-export function validateAgentRunControlRequest(value) {
-    if (value.schemaVersion !== 1 || value.kind !== "workflow-outcome") {
-        throw new Error("Agent Run control request is unsupported.");
-    }
-    if (value.state !== "dispatching" && value.state !== "awaiting-outcome") {
-        throw new Error("Agent Run control request state is invalid.");
-    }
-    requireIdentity(value.requestId, "Agent Run control request id");
-    requireIdentity(value.nativeTurnId, "Agent Run control native Turn id");
-    requireIdentity(value.receiptId, "Agent Run control receipt id");
-    requireTimestamp(value.requestedAt, "Agent Run control requestedAt");
-    requireTimestamp(value.deadlineAt, "Agent Run control deadlineAt");
-    if (Date.parse(value.deadlineAt) <= Date.parse(value.requestedAt)) {
-        throw new Error("Agent Run control deadline must follow requestedAt.");
-    }
-    return value;
-}
-export function markWorkflowOutcomeRequestDispatched(value) {
-    validateAgentRunControlRequest(value);
-    return value.state === "dispatching"
-        ? validateAgentRunControlRequest({ ...value, state: "awaiting-outcome" })
-        : value;
-}
-export function serializeWorkflowOutcomeRequestEnvelope(input) {
-    validateAgentRunControlRequest(input.request);
-    return [
-        "Yui managed workflow-outcome request for the existing Run.",
-        `task=${requireIdentity(input.taskId, "Task id")} run=${requireIdentity(input.runId, "Run id")} role=${requireIdentity(input.roleName, "Role name")}`,
-        `request=${input.request.requestId} completedTurn=${input.request.nativeTurnId}`,
-        "Record the required Yui workflow outcome now. Do not replay the Assignment or repeat completed work."
-    ].join("\n");
-}