@zq-silk/yui 0.15.11 → 0.16.0

package/dist/context/wakeNotification.js

@@ -1,144 +0,0 @@
-import { renderWakeReason } from "../scheduler/wakeReason.js";
-import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
-/**
- * Issue 04 (context token budget) — long-term design:
- *
- * A Leader wake is a NOTIFICATION, not a context dump. The wake envelope
- * carries only what the Agent needs for immediate orientation: the wake id,
- * aggregated reason tags, delta window, and a bounded list of active frozen
- * Task Reviews. The Agent reads delta content on demand with
- * `yui task wake show <wake-id>` and the full projection with
- * `yui task context <task>`.
- *
- * The envelope is mode-agnostic: fresh Sessions and resumed Sessions
- * receive the same minimal text. The native Session is a disposable cache of
- * working context; Yui's durable Task records (including the wake ledger) are
- * the checkpoint.
- */
-/** Structural guardrail: the envelope stays far below a normal model context window. */
-export const WAKE_ENVELOPE_HARD_BYTES = 2_000;
-/** Maximum reason tags rendered before elision to a count. */
-const REASON_DISPLAY_LIMIT = 6;
-export function buildTaskWakeEnvelope(reader, request) {
-    const task = reader.getTask(request.taskId);
-    if (task === null)
-        throw new Error(`Task not found: ${request.taskId}.`);
-    if (request.reasons.length === 0) {
-        throw new Error(`Wake envelope ${request.wakeId} must carry at least one reason.`);
-    }
-    const fromTime = Date.parse(request.fromCursor);
-    const events = reader.listEvents(request.taskId);
-    const deltaEvents = events.filter((record) => Date.parse(record.createdAt) > fromTime);
-    const runs = operationalTaskRecords(reader.listRuns(request.taskId), events, "run");
-    const referencedRunIds = referencedWakeRunIds(runs, events, deltaEvents);
-    const changedRunIds = new Set([
-        ...runs
-            .filter((record) => Date.parse(record.createdAt) > fromTime)
-            .map(({ id }) => id),
-        ...referencedRunIds
-    ]);
-    const counts = {
-        events: deltaEvents.length,
-        messages: operationalTaskRecords(reader.listMessages(request.taskId), events, "message")
-            .filter((record) => Date.parse(record.createdAt) > fromTime).length,
-        runs: changedRunIds.size
-    };
-    const activeReviews = reader.listReviewRounds(request.taskId).filter((round) => ((round.scope ?? "work-item") === "task"
-        && (round.status === "pending" || round.status === "running")));
-    const renderReviewOrientation = (limit) => activeReviews.slice(0, limit).map((round) => {
-        const projects = round.taskCandidate?.projects ?? [];
-        const heads = projects.slice(0, 2).map(({ projectId, commit }) => (`${projectId}@${commit.slice(0, 12)}`)).join("+");
-        return `${round.id}/${round.reviewerRoleName}`
-            + `/${round.deltaRecheck === undefined ? "full" : "delta"}`
-            + `[${round.status}]`
-            + `@${heads || round.reviewBaseCommit.slice(0, 12)}`
-            + `${projects.length > 2 ? `+${projects.length - 2}` : ""}`;
-    }).join(", ");
-    const render = (reasonLimit, resultRunLimit, reviewLimit) => {
-        const reviewOrientation = renderReviewOrientation(reviewLimit);
-        return [
-            `Wake: ${request.wakeId} — delta since ${request.fromCursor}`,
-            `  Reasons: ${renderReasons(request.reasons, reasonLimit)}`,
-            `  Changed: ${counts.events} events, ${counts.messages} messages, ${counts.runs} AgentRuns`
-                + ` → yui task wake show ${request.taskId} ${request.wakeId}`,
-            `  Result AgentRuns: ${renderResultRuns(request.taskId, referencedRunIds, resultRunLimit)}`,
-            `  Active Task Reviews: ${activeReviews.length === 0
-                ? "none"
-                : reviewLimit === 0
-                    ? `${activeReviews.length} → yui task context ${request.taskId}`
-                    : `${reviewOrientation}${activeReviews.length > reviewLimit
-                        ? `, … (+${activeReviews.length - reviewLimit})`
-                        : ""}`}`,
-            `Full context: yui task context ${request.taskId}`
-        ].join("\n");
-    };
-    let reasonLimit = Math.min(REASON_DISPLAY_LIMIT, request.reasons.length);
-    let resultRunLimit = Math.min(4, referencedRunIds.length);
-    let reviewLimit = Math.min(3, activeReviews.length);
-    let body = render(reasonLimit, resultRunLimit, reviewLimit);
-    while (byteLength(body) + 1 > WAKE_ENVELOPE_HARD_BYTES) {
-        if (resultRunLimit > 0)
-            resultRunLimit -= 1;
-        else if (reasonLimit > 0)
-            reasonLimit -= 1;
-        else if (reviewLimit > 0)
-            reviewLimit -= 1;
-        else
-            break;
-        body = render(reasonLimit, resultRunLimit, reviewLimit);
-    }
-    if (byteLength(body) + 1 > WAKE_ENVELOPE_HARD_BYTES) {
-        body = fitUtf8([
-            `Wake: ${request.wakeId}`,
-            `Inspect: yui task wake show ${request.taskId} ${request.wakeId}`,
-            `Full context: yui task context ${request.taskId}`
-        ].join("\n"), WAKE_ENVELOPE_HARD_BYTES - 1);
-    }
-    const totalBytes = byteLength(body) + 1;
-    return Object.freeze({
-        taskId: request.taskId,
-        wakeId: request.wakeId,
-        fromCursor: request.fromCursor,
-        referencedRunIds: Object.freeze(referencedRunIds),
-        totalBytes,
-        text: `${body}\n`
-    });
-}
-export function referencedWakeRunIds(runs, allEvents, terminalEvents) {
-    const turnsById = new Map(operationalTaskRecords(runs, allEvents, "run").map((run) => [run.id, run]));
-    return [...new Set(terminalEvents.flatMap((event) => {
-            if (!["run.completed", "run.failed", "run.cancelled"].includes(event.type))
-                return [];
-            const runId = event.payload.runId;
-            return runId !== undefined && turnsById.has(runId) ? [runId] : [];
-        }))];
-}
-function renderReasons(reasons, limit) {
-    if (limit === 0)
-        return `${reasons.length} reason tags`;
-    const selected = reasons.slice(0, limit);
-    const elided = reasons.length - selected.length;
-    const rendered = selected.map(renderWakeReason).join(", ");
-    return elided === 0 ? rendered : `${rendered}, … (+${elided} more)`;
-}
-function renderResultRuns(taskId, runIds, limit) {
-    if (runIds.length === 0)
-        return "none";
-    if (limit === 0)
-        return `${runIds.length} → inspect the wake delta`;
-    return `${runIds.slice(0, limit)
-        .map((runId) => `${runId} → yui task run show ${taskId}/${runId}`)
-        .join(", ")}${runIds.length > limit ? `, … (+${runIds.length - limit})` : ""}`;
-}
-function fitUtf8(value, maxBytes) {
-    let fitted = "";
-    for (const character of value) {
-        if (byteLength(fitted) + byteLength(character) > maxBytes)
-            break;
-        fitted += character;
-    }
-    return fitted;
-}
-function byteLength(value) {
-    return Buffer.byteLength(value, "utf8");
-}

package/dist/integration/integrationCheckEvidenceReuse.js

@@ -1,53 +0,0 @@
-/** Internal, Controller-derived release fence carried by Integration jobs. */
-export const INTEGRATION_RUNTIME_RELEASE_ENV = "YUI_INTEGRATION_RUNTIME_RELEASE_ID";
-/**
- * Find exact reusable evidence without creating cache state. Every identity
- * field is read from the existing IntegrationAttempt and DurableJob records.
- */
-export function findReusableIntegrationCheckEvidence(input) {
-    const attempts = [...input.attempts]
-        .filter((attempt) => (attempt.taskId === input.taskId
-        && attempt.id !== input.currentAttemptId
-        && attempt.projectId === input.projectId
-        && sameOrderedText(attempt.checkCommands, input.checkCommands)))
-        .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
-    for (const attempt of attempts) {
-        if (attempt.jobId === undefined)
-            continue;
-        const job = input.jobs.find((candidate) => (candidate.id === attempt.jobId
-            && candidate.taskId === input.taskId
-            && candidate.owner.kind === "integration-attempt"
-            && candidate.owner.integrationAttemptId === attempt.id));
-        const resultSteps = job?.result?.steps ?? [];
-        const logPaths = resultSteps.map((step) => (input.logPathFor?.(job, step.logPath) ?? step.logPath));
-        if (job === undefined
-            || job.projectId !== input.projectId
-            || job.head !== input.candidateCommit
-            || job.status !== "succeeded"
-            || job.result?.outcome !== "succeeded"
-            || job.env[INTEGRATION_RUNTIME_RELEASE_ENV] !== input.runtimeReleaseId
-            || job.steps.length !== input.checkCommands.length
-            || job.steps.some((step, index) => (step.name !== `check-${index + 1}`
-                || step.command !== input.checkCommands[index]))
-            || resultSteps.length !== input.checkCommands.length
-            || resultSteps.some((step, index) => (step.name !== `check-${index + 1}`
-                || step.exitCode !== 0
-                || step.signal !== null
-                || step.timedOut
-                || step.head !== input.candidateCommit
-                || (input.logExists !== undefined && !input.logExists(logPaths[index]))))) {
-            continue;
-        }
-        const checks = resultSteps.map((step, index) => ({
-            name: input.checkCommands[index],
-            outcome: "passed",
-            details: `Reused successful check evidence from ${attempt.id}/${job.id}.`,
-            logPath: logPaths[index]
-        }));
-        return Object.freeze({ sourceAttempt: attempt, sourceJob: job, checks });
-    }
-    return null;
-}
-function sameOrderedText(left, right) {
-    return left.length === right.length && left.every((value, index) => value === right[index]);
-}

package/dist/integration/integrationQueueEntry.js

@@ -1,191 +0,0 @@
-import { normalizedUniqueIdentities, normalizedUniqueText, requireIdentity, requireText, requireTimestamp } from "../domain/validation.js";
-import { validateTaskRecordReference } from "../task/taskRecordReference.js";
-export function createIntegrationQueueEntry(input, now) {
-    const timestamp = now.toISOString();
-    return validateIntegrationQueueEntry({
-        schemaVersion: 1,
-        id: input.id,
-        taskId: input.taskId,
-        projectId: input.projectId,
-        changeSetId: input.changeSetId,
-        targetRef: input.targetRef,
-        status: "queued",
-        checkCommands: normalizedUniqueText(input.checkCommands ?? [], "Integration queue check command"),
-        evidenceRefs: normalizedUniqueText(input.evidenceRefs ?? [], "Integration queue evidence"),
-        createdAt: timestamp,
-        updatedAt: timestamp
-    });
-}
-/**
- * An entry whose ChangeSet is already represented on the target (an ancestor
- * or a same-tree commit) converges directly to committed with its proof.  The
- * entry still names the committed IntegrationAttempt that recorded the
- * convergence, so every acceptance and provenance consumer reads one
- * integration authority.
- */
-export function createConvergedIntegrationQueueEntry(input, now) {
-    const timestamp = now.toISOString();
-    return validateIntegrationQueueEntry({
-        schemaVersion: 1,
-        id: input.id,
-        taskId: input.taskId,
-        projectId: input.projectId,
-        changeSetId: input.changeSetId,
-        targetRef: input.targetRef,
-        status: "committed",
-        checkCommands: [],
-        targetBefore: input.targetHead,
-        targetAfter: input.targetHead,
-        evidenceRefs: [input.proof],
-        ...(input.integrationAttemptId === undefined
-            ? {}
-            : { integrationAttemptId: input.integrationAttemptId }),
-        createdAt: timestamp,
-        updatedAt: timestamp,
-        endedAt: timestamp
-    });
-}
-export function markIntegrationQueueRunning(entry, targetBefore, now) {
-    validateIntegrationQueueEntry(entry);
-    if (!["queued", "conflicted"].includes(entry.status)) {
-        throw new Error(`Integration queue entry cannot run from ${entry.status}: ${entry.id}.`);
-    }
-    const { conflictSummary: _previousConflict, ...rest } = entry;
-    return validateIntegrationQueueEntry({
-        ...rest,
-        status: "running",
-        targetBefore,
-        updatedAt: now.toISOString()
-    });
-}
-export function recordIntegrationQueueAttempt(entry, integrationAttemptId, now) {
-    validateIntegrationQueueEntry(entry);
-    if (entry.status !== "running") {
-        throw new Error(`Integration queue entry is not running: ${entry.id}/${entry.status}.`);
-    }
-    return validateIntegrationQueueEntry({
-        ...entry,
-        integrationAttemptId,
-        updatedAt: now.toISOString()
-    });
-}
-export function markIntegrationQueueBlocked(entry, conflictSummary, now) {
-    validateIntegrationQueueEntry(entry);
-    if (entry.status !== "running") {
-        throw new Error(`Integration queue entry is not running: ${entry.id}/${entry.status}.`);
-    }
-    return validateIntegrationQueueEntry({
-        ...entry,
-        status: "conflicted",
-        conflictSummary: requireText(conflictSummary, "Integration queue conflict summary"),
-        updatedAt: now.toISOString()
-    });
-}
-export function markIntegrationQueueCommitted(entry, targetAfter, now) {
-    validateIntegrationQueueEntry(entry);
-    if (entry.status !== "running" && entry.status !== "conflicted") {
-        throw new Error(`Integration queue entry cannot commit from ${entry.status}: ${entry.id}.`);
-    }
-    const timestamp = now.toISOString();
-    return validateIntegrationQueueEntry({
-        ...entry,
-        status: "committed",
-        targetAfter,
-        updatedAt: timestamp,
-        endedAt: timestamp
-    });
-}
-/** A conflicted entry is manually retried after its underlying issue was fixed. */
-export function markIntegrationQueueRequeued(entry, now) {
-    validateIntegrationQueueEntry(entry);
-    if (entry.status !== "conflicted") {
-        throw new Error(`Integration queue entry cannot requeue from ${entry.status}: ${entry.id}.`);
-    }
-    return validateIntegrationQueueEntry({
-        ...entry,
-        status: "queued",
-        updatedAt: now.toISOString()
-    });
-}
-export function recordIntegrationQueueAffectedPaths(entry, affectedPaths, now) {
-    validateIntegrationQueueEntry(entry);
-    if (entry.status !== "queued") {
-        throw new Error(`Integration queue entry cannot recompute overlap from ${entry.status}: ${entry.id}.`);
-    }
-    const previous = new Set(entry.affectedPaths ?? []);
-    const merged = [...new Set([...previous, ...affectedPaths])].sort();
-    return validateIntegrationQueueEntry({
-        ...entry,
-        affectedPaths: merged,
-        updatedAt: now.toISOString()
-    });
-}
-export function markIntegrationQueueSuperseded(entry, reason, now) {
-    validateIntegrationQueueEntry(entry);
-    if (!["queued", "conflicted"].includes(entry.status)) {
-        throw new Error(`Integration queue entry cannot be superseded from ${entry.status}: ${entry.id}.`);
-    }
-    const timestamp = now.toISOString();
-    return validateIntegrationQueueEntry({
-        ...entry,
-        status: "superseded",
-        supersedeReason: requireText(reason, "Integration queue supersede reason"),
-        updatedAt: timestamp,
-        endedAt: timestamp
-    });
-}
-export function validateIntegrationQueueEntry(entry) {
-    if (entry.schemaVersion !== 1) {
-        throw new Error("IntegrationQueueEntry must use schemaVersion 1.");
-    }
-    validateTaskRecordReference({ taskId: entry.taskId, localId: entry.id }, "integrationQueue");
-    validateTaskRecordReference({ taskId: entry.taskId, localId: entry.changeSetId }, "changeSet");
-    requireIdentity(entry.projectId, "Project id");
-    requireText(entry.targetRef, "Integration queue target ref");
-    normalizedUniqueText(entry.checkCommands, "Integration queue check command");
-    normalizedUniqueText(entry.evidenceRefs, "Integration queue evidence");
-    if (![
-        "queued",
-        "running",
-        "conflicted",
-        "committed",
-        "superseded"
-    ].includes(entry.status)) {
-        throw new Error(`Integration queue status is invalid: ${String(entry.status)}.`);
-    }
-    if (entry.targetBefore !== undefined)
-        requireCommit(entry.targetBefore, "Integration queue targetBefore");
-    if (entry.targetAfter !== undefined)
-        requireCommit(entry.targetAfter, "Integration queue targetAfter");
-    if (entry.integrationAttemptId !== undefined) {
-        normalizedUniqueIdentities([entry.integrationAttemptId], "Integration attempt id");
-    }
-    if (entry.conflictSummary !== undefined) {
-        requireText(entry.conflictSummary, "Integration queue conflict summary");
-    }
-    if (entry.affectedPaths !== undefined) {
-        normalizedUniqueText(entry.affectedPaths, "Integration queue affected path");
-    }
-    if (entry.supersedeReason !== undefined) {
-        requireText(entry.supersedeReason, "Integration queue supersede reason");
-    }
-    requireTimestamp(entry.createdAt, "Integration queue entry createdAt");
-    requireTimestamp(entry.updatedAt, "Integration queue entry updatedAt");
-    if (["committed", "superseded"].includes(entry.status)) {
-        requireTimestamp(entry.endedAt ?? "", "Integration queue entry endedAt");
-    }
-    if (entry.status === "committed") {
-        requireCommit(entry.targetAfter ?? "", "Integration queue targetAfter");
-    }
-    if (entry.status === "running") {
-        requireCommit(entry.targetBefore ?? "", "Integration queue targetBefore");
-    }
-    return entry;
-}
-function requireCommit(value, label) {
-    const normalized = requireText(value, label).toLowerCase();
-    if (!/^[a-f0-9]{40}(?:[a-f0-9]{24})?$/u.test(normalized)) {
-        throw new Error(`${label} is invalid.`);
-    }
-    return normalized;
-}