@zq-silk/yui 0.13.9 → 0.14.0

package/dist/run/yieldReceipt.js

@@ -1,65 +0,0 @@
-import { createHash } from "node:crypto";
-import { requireIdentity, requireText, requireTimestamp } from "../domain/validation.js";
-const DIGEST_PREFIX_LENGTH = 16;
-function canonicalDigestValue(value) {
-    if (value === null || typeof value !== "object")
-        return JSON.stringify(value) ?? "null";
-    if (Array.isArray(value)) {
-        return `[${value.map(canonicalDigestValue).join(",")}]`;
-    }
-    const entries = Object.entries(value)
-        .filter(([, entry]) => entry !== undefined)
-        .sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0));
-    return `{${entries
-        .map(([key, entry]) => `${JSON.stringify(key)}:${canonicalDigestValue(entry)}`)
-        .join(",")}}`;
-}
-/**
- * Computes the terminal outcome digest. The canonical form sorts object keys
- * and drops `undefined` fields so the same outcome always hashes identically
- * regardless of object construction order.
- */
-export function computeYieldOutcomeDigest(input) {
-    return createHash("sha256")
-        .update(canonicalDigestValue(input))
-        .digest("hex");
-}
-export function formatYieldReceiptRequestId(taskId, runId, outcomeDigest) {
-    return `yield:${taskId}:${runId}:${outcomeDigest.slice(0, DIGEST_PREFIX_LENGTH)}`;
-}
-export function formatYieldReceiptId(taskId, runId, outcomeDigest) {
-    return `yield-receipt:${taskId}:${runId}:${outcomeDigest.slice(0, DIGEST_PREFIX_LENGTH)}`;
-}
-export function createYieldReceipt(taskId, runId, outcome, now) {
-    const outcomeDigest = computeYieldOutcomeDigest(outcome);
-    return validateYieldReceipt({
-        schemaVersion: 1,
-        requestId: formatYieldReceiptRequestId(taskId, runId, outcomeDigest),
-        receiptId: formatYieldReceiptId(taskId, runId, outcomeDigest),
-        outcomeDigest,
-        committedAt: now.toISOString()
-    });
-}
-export function validateYieldReceipt(value) {
-    if (value.schemaVersion !== 1) {
-        throw new Error("Yield receipt must use schemaVersion 1.");
-    }
-    requireIdentity(value.requestId, "Yield receipt requestId");
-    requireIdentity(value.receiptId, "Yield receipt receiptId");
-    requireText(value.outcomeDigest, "Yield receipt outcomeDigest");
-    requireTimestamp(value.committedAt, "Yield receipt committedAt");
-    return value;
-}
-/**
- * Matches a presented outcome against a terminal Run's committed receipt.
- * The same digest replays the receipt; a different digest fails closed.
- */
-export function matchYieldReceipt(receipt, outcome) {
-    if (receipt === undefined)
-        return null;
-    const presented = computeYieldOutcomeDigest(outcome);
-    if (presented === receipt.outcomeDigest) {
-        return { kind: "replayed", receipt };
-    }
-    return { kind: "digest-mismatch", existing: receipt };
-}

package/dist/runtime/turnCompletion.js

@@ -1,3 +0,0 @@
-// Compatibility facade. The authoritative Turn-completion model belongs to
-// the Execution domain; runtime adapters only translate external Hook facts.
-export * from "../executor/turnCompletion.js";

package/dist/scheduler/actionability.js

@@ -1,323 +0,0 @@
-import { createHash } from "node:crypto";
-import { currentWorkItemExecutionGroup } from "../workItem/workItem.js";
-import { isDurableJobTerminal } from "../job/durableJob.js";
-import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
-import { executionStageSpendClosed, observedExecutionResourceUsage, projectExecutionStageResources } from "../execution/resourceBroker.js";
-/**
- * Canonical SHA-256 digest over the normalized actionable facts. Pure and
- * deterministic: the same facts always produce the same digest regardless of
- * collection order.
- */
-export function computeActionabilityDigest(input) {
-    const facts = [...input.facts]
-        .map((fact) => ({ key: fact.key, value: fact.value }))
-        .sort((left, right) => (left.key < right.key ? -1 : left.key > right.key ? 1 : 0));
-    const canonical = JSON.stringify({
-        taskId: input.taskId,
-        taskStatus: input.taskStatus,
-        facts
-    });
-    return createHash("sha256").update(canonical).digest("hex");
-}
-const TERMINAL_WORK_ITEM_STATUSES = new Set(["completed", "retired"]);
-const CONSUMED_INTEGRATION_STATUSES = new Set(["committed", "superseded"]);
-/** Exact durable Broker queue shared by admission and wake actionability. */
-export function projectQueuedResourceLaneIdentities(store, now) {
-    return store.listActiveTaskIds().flatMap((taskId) => {
-        const taskRuns = store.listAgentRuns(taskId);
-        const taskEvents = store.listEvents(taskId);
-        const workItemLanes = store.listWorkItems(taskId).flatMap((item) => {
-            if (item.status !== "running")
-                return [];
-            const group = currentWorkItemExecutionGroup(item);
-            if (group === undefined || group.resolution !== undefined)
-                return [];
-            if (group.stage !== undefined) {
-                const resources = projectExecutionStageResources({
-                    group,
-                    stageGroups: item.executionGroups,
-                    usage: observedExecutionResourceUsage({
-                        group,
-                        stageGroups: item.executionGroups,
-                        runs: taskRuns,
-                        events: taskEvents
-                    }),
-                    now
-                });
-                if (executionStageSpendClosed(resources))
-                    return [];
-            }
-            return group.lanes.flatMap((lane) => {
-                if (lane.status !== "pending"
-                    || lane.effective === undefined
-                    || lane.runId !== undefined)
-                    return [];
-                return [{
-                        taskId,
-                        workItemId: item.id,
-                        executionGroupId: group.id,
-                        executionLaneId: lane.id,
-                        providerId: lane.effective.adapterId,
-                        agentId: lane.effective.agentId,
-                        ...(lane.effective.model === undefined ? {} : { model: lane.effective.model }),
-                        requestedAt: lane.updatedAt
-                    }];
-            });
-        });
-        const reviewLanes = store.listReviewRounds(taskId).flatMap((round) => {
-            if (round.status !== "pending" && round.status !== "running")
-                return [];
-            const group = round.executionGroup;
-            if (group === undefined || group.resolution !== undefined)
-                return [];
-            return group.lanes.flatMap((lane) => {
-                if (lane.status !== "pending"
-                    || lane.effective === undefined
-                    || lane.runId !== undefined)
-                    return [];
-                return [{
-                        taskId,
-                        ...(round.workItemId === undefined ? {} : { workItemId: round.workItemId }),
-                        executionGroupId: group.id,
-                        executionLaneId: lane.id,
-                        providerId: lane.effective.adapterId,
-                        agentId: lane.effective.agentId,
-                        ...(lane.effective.model === undefined ? {} : { model: lane.effective.model }),
-                        requestedAt: lane.updatedAt
-                    }];
-            });
-        });
-        return [...workItemLanes, ...reviewLanes];
-    });
-}
-/**
- * True only when the Task still owns a Resource-Broker-queued Lane that a
- * later Leader dispatch may start. Terminal owners retain their immutable
- * Group history, but can never reserve live queue capacity.
- */
-export function hasDispatchableQueuedResourceLane(store, taskId) {
-    const workItemGroups = (store.listWorkItems?.(taskId) ?? [])
-        .filter(({ status }) => status === "running")
-        .flatMap(({ executionGroups }) => executionGroups);
-    const reviewGroups = (store.listReviewRounds?.(taskId) ?? [])
-        .filter(({ status }) => status === "pending" || status === "running")
-        .flatMap(({ executionGroup }) => executionGroup === undefined ? [] : [executionGroup]);
-    return [...workItemGroups, ...reviewGroups].some((group) => (group.resolution === undefined
-        && group.lanes.some((lane) => (lane.status === "pending"
-            && lane.effective !== undefined
-            && lane.runId === undefined))));
-}
-/**
- * Fold a Task's durable records into the normalized actionable facts. This
- * function only reads; it never starts a Controller, queues a wake, writes a
- * Message, or mutates any record.
- *
- * Included facts (each changes only when the durable record changes):
- * - Active Runs: the ownership/liveness picture. A Run starting or ending
- *   changes the digest so a lost executor is detected.
- * - Non-terminal/failed WorkItems: pending, running, awaiting-acceptance, and
- *   failed items still need Leader or Worker action.
- * - Non-completed ReviewRounds: pending/running/failed rounds still need
- *   Leader disposition or a Reviewer.
- * - Unresolved IntegrationAttempts: running/validating/blocked/failed attempts
- *   the Leader may need to resolve.
- * - Terminal DurableJobs: new terminal results the Leader should observe.
- * - InputRequests: open and answered/cancelled requests.
- * - User directives explicitly marked `wakePolicy=leader`.
- *
- * Excluded: pure revision growth, progress/heartbeat events, repeated scans of
- * an unchanged blocker, read-only status requests, and waits already owned by
- * an active Worker/Reviewer/Job (the active-Run facts above capture ownership).
- */
-export function collectTaskActionability(store, taskId, now = new Date()) {
-    const task = store.getTask(taskId);
-    if (task === null) {
-        throw new Error(`Task not found for actionability projection: ${taskId}.`);
-    }
-    const facts = [];
-    const events = store.listEvents?.(taskId) ?? [];
-    for (const run of operationalTaskRecords(store.listAgentRuns(taskId), events, "agent-run").filter((candidate) => candidate.status === "active")) {
-        facts.push({
-            key: `active-run:${run.id}`,
-            value: [
-                run.roleName,
-                run.workItemId ?? "",
-                run.reviewRoundId ?? "",
-                run.updatedAt
-            ].join("|")
-        });
-    }
-    const workItems = store.listWorkItems?.(taskId) ?? [];
-    const reviewRounds = store.listReviewRounds?.(taskId) ?? [];
-    for (const item of workItems) {
-        if (TERMINAL_WORK_ITEM_STATUSES.has(item.status))
-            continue;
-        facts.push({
-            key: `work-item:${item.id}`,
-            value: `${item.status}|${item.updatedAt}`
-        });
-        for (const group of item.executionGroups) {
-            if (group.resolution !== undefined || group.stage?.resources === undefined)
-                continue;
-            facts.push({
-                key: `resource-deadline:${group.id}`,
-                value: now.getTime() >= Date.parse(group.stage.resources.deadlineAt)
-                    ? "reached"
-                    : "open"
-            });
-        }
-    }
-    // A Resource-Broker-queued Lane is durable but deliberately has no active
-    // Run. Include the global capacity and fair-queue projection only for Tasks
-    // that are actually queued, so either capacity or an older reservation being
-    // released changes their digest without polling or a second scheduler.
-    const queueProjectionAvailable = store.listActiveTaskIds !== undefined
-        && store.listWorkItems !== undefined
-        && store.listReviewRounds !== undefined
-        && store.listEvents !== undefined;
-    const queuedResourceLanes = queueProjectionAvailable
-        ? projectQueuedResourceLaneIdentities({
-            listActiveTaskIds: () => store.listActiveTaskIds(),
-            listAgentRuns: (candidateTaskId) => store.listAgentRuns(candidateTaskId),
-            listWorkItems: (candidateTaskId) => store.listWorkItems(candidateTaskId),
-            listReviewRounds: (candidateTaskId) => store.listReviewRounds(candidateTaskId),
-            listEvents: (candidateTaskId) => store.listEvents(candidateTaskId)
-        }, now)
-        : [];
-    const hasQueuedResourceLane = queueProjectionAvailable
-        ? queuedResourceLanes.some((lane) => lane.taskId === taskId)
-        : hasDispatchableQueuedResourceLane(store, taskId);
-    if (hasQueuedResourceLane && store.listActiveTaskIds !== undefined) {
-        const activeResourceScopes = store.listActiveTaskIds().flatMap((activeTaskId) => (operationalTaskRecords(store.listAgentRuns(activeTaskId), store.listEvents?.(activeTaskId) ?? [], "agent-run").flatMap((run) => (run.status !== "active"
-            || run.executionGroupId === undefined
-            || run.executionLaneId === undefined
-            ? []
-            : [
-                "home",
-                `task:${activeTaskId}`,
-                ...(run.workItemId === undefined
-                    ? []
-                    : [`work-item:${activeTaskId}/${run.workItemId}`]),
-                `group:${activeTaskId}/${run.executionGroupId}`,
-                `provider:${run.effective.adapterId}`,
-                `agent:${run.effective.agentId}`,
-                `model:${run.effective.adapterId}/${run.effective.model ?? "default"}`
-            ]))));
-        const activeResourceCounts = new Map();
-        for (const scope of activeResourceScopes) {
-            activeResourceCounts.set(scope, (activeResourceCounts.get(scope) ?? 0) + 1);
-        }
-        facts.push({
-            key: "resource-broker:active-capacity",
-            value: [...activeResourceCounts]
-                .sort(([left], [right]) => left.localeCompare(right))
-                .map(([scope, count]) => `${scope}=${count}`)
-                .join("|")
-        });
-        if (queueProjectionAvailable) {
-            facts.push({
-                key: "resource-broker:fair-queue",
-                value: queuedResourceLanes
-                    .map((lane) => [
-                    lane.requestedAt,
-                    lane.taskId,
-                    lane.workItemId ?? "",
-                    lane.executionGroupId,
-                    lane.executionLaneId,
-                    lane.providerId,
-                    lane.agentId,
-                    lane.model ?? "default"
-                ].join("|"))
-                    .sort()
-                    .join("\n")
-            });
-        }
-    }
-    for (const round of reviewRounds) {
-        if (round.status === "completed")
-            continue;
-        facts.push({
-            key: `review:${round.id}`,
-            value: `${round.status}|${round.endedAt ?? round.createdAt}`
-        });
-    }
-    for (const attempt of store.listIntegrationAttempts?.(taskId) ?? []) {
-        if (CONSUMED_INTEGRATION_STATUSES.has(attempt.status))
-            continue;
-        facts.push({
-            key: `integration:${attempt.id}`,
-            value: `${attempt.status}|${attempt.updatedAt}`
-        });
-    }
-    for (const job of store.listDurableJobs?.(taskId) ?? []) {
-        if (!isDurableJobTerminal(job.status))
-            continue;
-        facts.push({
-            key: `durable-job:${job.id}`,
-            value: `${job.status}|${job.terminalAt ?? job.updatedAt}`
-        });
-    }
-    for (const request of store.listInputRequests?.(taskId) ?? []) {
-        facts.push({
-            key: `input:${request.id}`,
-            value: `${request.status}|${request.updatedAt}`
-        });
-    }
-    for (const message of operationalTaskRecords(store.listMessages?.(taskId) ?? [], events, "message")) {
-        if (message.wakePolicy !== "leader")
-            continue;
-        facts.push({
-            key: `directive:${message.id}`,
-            value: message.createdAt
-        });
-    }
-    return { taskId, taskStatus: task.status, facts };
-}
-/**
- * Derive the Leader Run disposition from the Task execution projection status.
- * This is machine-derived at yield time so the Scheduler does not depend on
- * free-text Leader summaries.
- */
-export function deriveLeaderRunDisposition(projectionStatus, taskStatus) {
-    if (taskStatus !== "active")
-        return "completed";
-    switch (projectionStatus) {
-        case "blocked":
-            return "blocked";
-        case "waiting-on-agents":
-        case "waiting-user":
-            return "waiting";
-        case "completed":
-        case "retired":
-        case "archived":
-            return "completed";
-        default:
-            return "progress";
-    }
-}
-/**
- * Decide whether a `task-orphaned` scan should create a new Leader Run.
- *
- * Suppression applies only when the last Leader Run ended `waiting` or
- * `blocked` and its `observedActionabilityDigest` equals the current digest.
- * A `progress`/`completed` disposition, a missing digest, or a changed digest
- * always wakes. Computation errors fail open.
- */
-export function decideOrphanWake(input) {
-    const { currentDigest, lastLeaderRun } = input;
-    if (lastLeaderRun === null)
-        return { kind: "wake", digest: currentDigest };
-    if (lastLeaderRun.status === "active")
-        return { kind: "wake", digest: currentDigest };
-    const disposition = lastLeaderRun.disposition;
-    if (disposition !== "waiting" && disposition !== "blocked") {
-        return { kind: "wake", digest: currentDigest };
-    }
-    const observed = lastLeaderRun.observedActionabilityDigest;
-    if (observed === undefined)
-        return { kind: "wake", digest: currentDigest };
-    if (observed === currentDigest) {
-        return { kind: "suppress", digest: currentDigest, observedDigest: observed };
-    }
-    return { kind: "wake", digest: currentDigest };
-}