@zq-silk/yui 0.15.12 → 0.16.0

package/dist/completion/completionWizard.js

@@ -1,125 +0,0 @@
-import { resolve } from "node:path";
-import { usageError } from "../errors/cliError.js";
-import { installCompletion, uninstallCompletion } from "./completionInstaller.js";
-import { COMPLETION_SHELLS, activationBlock, activationIsAutomatic, currentCompletionShell, inspectCompletionStates, renderCompletionStateTable, shellQuote, suggestedCompletionInstallation } from "./completionState.js";
-export async function runCompletionWizard(operation, store, env, identity, question, options = {}) {
-    const states = inspectCompletionStates(store.getConfig(), env, identity);
-    const current = currentCompletionShell(env);
-    let shell;
-    if (options.shell === undefined) {
-        const defaultSelection = options.defaultSelection ?? "current-shell";
-        const defaultHint = defaultSelection === "skip"
-            ? " [skip]"
-            : current === undefined ? "" : ` [${current}]`;
-        const skipHint = defaultSelection === "skip" ? "" : " (or skip)";
-        const answer = await question(`${renderCompletionStateTable(states, options.width)}\n`
-            + `Choose shell by number or name${defaultHint}${skipHint}: `);
-        const normalized = answer.trim().toLowerCase();
-        if (normalized === "skip" || (normalized.length === 0 && defaultSelection === "skip")) {
-            return `Completion ${operation} skipped.\n`;
-        }
-        shell = parseSelection(answer, current);
-    }
-    else {
-        shell = options.shell;
-    }
-    const state = states.find((candidate) => candidate.shell === shell);
-    if (state === undefined)
-        throw usageError("Completion shell selection is invalid.");
-    if (operation === "uninstall") {
-        if (state.installation === undefined) {
-            return `Completion ${shell} is not installed.\n`;
-        }
-        const confirm = normalize(await question(`Remove managed ${shell} completion?\n`
-            + `Script: ${state.installation.scriptPath}\n`
-            + `Activation: ${state.installation.activationPath}\n`
-            + "Remove now? [y/N]: "));
-        if (confirm !== "y" && confirm !== "yes") {
-            return `Completion ${shell} uninstall skipped.\n`;
-        }
-        uninstallCompletion(store, shell, identity);
-        return `Completion ${shell} uninstalled.\n`;
-    }
-    const suggested = state.installation
-        ?? suggestedCompletionInstallation(shell, env, identity);
-    const automatic = activationIsAutomatic(shell, suggested, env, identity);
-    const decision = normalize(await question(`Selected: ${shell} (${state.action})\n`
-        + `Script: ${suggested.scriptPath}\n`
-        + `Activation: ${suggested.activationPath}`
-        + `${automatic ? " (automatic)" : " (managed startup block)"}\n`
-        + "Install using these paths? [Y/n/customize]: "));
-    if (decision === "n" || decision === "no") {
-        return `Completion ${shell} installation skipped.\n`;
-    }
-    let installation = suggested;
-    let customized = false;
-    if (decision === "customize") {
-        const scriptPath = resolve((await question(`Completion script path [${suggested.scriptPath}]: `)).trim()
-            || suggested.scriptPath);
-        const activationPath = resolve((await question(`Activation file path [${suggested.activationPath}]: `)).trim()
-            || suggested.activationPath);
-        installation = { scriptPath, activationPath };
-        customized = true;
-    }
-    else if (decision !== "" && decision !== "y" && decision !== "yes") {
-        throw usageError("Choose Y, n, or customize.");
-    }
-    const needsActivation = !activationIsAutomatic(shell, installation, env, identity);
-    let activate = false;
-    let activationReady = !needsActivation;
-    if (needsActivation) {
-        const activationAnswer = normalize(await question(`${activationBlock(shell, installation, identity)}\n`
-            + `Update ${installation.activationPath} with the managed Yui block? [Y/n]: `));
-        if (activationAnswer !== ""
-            && activationAnswer !== "y"
-            && activationAnswer !== "yes"
-            && activationAnswer !== "n"
-            && activationAnswer !== "no") {
-            throw usageError("Choose Y or n.");
-        }
-        activate = activationAnswer === ""
-            || activationAnswer === "y"
-            || activationAnswer === "yes";
-        activationReady = activate || (!customized && state.status === "Installed");
-    }
-    installCompletion(store, shell, installation, env, identity, activate);
-    if (!activationReady) {
-        return `Completion ${shell} script installed; activation still required.\n`;
-    }
-    const result = `Completion ${shell} ${pastTense(state.action)}.\n`;
-    return needsActivation
-        ? `${result}${activationGuidance(shell, installation, env, identity)}`
-        : result;
-}
-function activationGuidance(shell, installation, env, identity) {
-    const unchanged = "The current shell is unchanged.\n";
-    const defaultActivationPath = suggestedCompletionInstallation(shell, env, identity).activationPath;
-    if (installation.activationPath !== defaultActivationPath) {
-        return `${unchanged}From a ${shell} session, load the custom activation file: source ${shellQuote(installation.activationPath)}\n`;
-    }
-    return currentCompletionShell(env) === shell
-        ? `${unchanged}Restart the current shell to activate completion: exec ${shell}\n`
-        : `${unchanged}Switch this terminal to ${shell} to activate completion: exec ${shell}\n`;
-}
-function parseSelection(value, current) {
-    const normalized = value.trim().toLowerCase();
-    if (normalized.length === 0 && current !== undefined)
-        return current;
-    if (/^[1-3]$/.test(normalized)) {
-        return COMPLETION_SHELLS[Number.parseInt(normalized, 10) - 1];
-    }
-    if (COMPLETION_SHELLS.includes(normalized)) {
-        return normalized;
-    }
-    throw usageError("Choose Bash, Zsh, or Fish by number or name.");
-}
-function pastTense(action) {
-    switch (action) {
-        case "Install": return "installed";
-        case "Refresh": return "refreshed";
-        case "Repair": return "repaired";
-    }
-}
-function normalize(value) {
-    return value?.trim().toLowerCase() ?? "";
-}

package/dist/context/dispatchContext.js

@@ -1,110 +0,0 @@
-export function buildRoleContext(context) {
-    return context.role.name === "leader"
-        ? buildLeaderContext(context)
-        : buildWorkerContext(context);
-}
-export function buildLeaderContext(context) {
-    return renderDispatchContext("leader", context);
-}
-export function buildWorkerContext(context) {
-    return renderDispatchContext("worker", context);
-}
-const WORKER_RUN_COMPLETION_MARKER = "Yui Role AgentRun result requirement:";
-const WORKER_RUN_COMPLETION_REQUIREMENT = [
-    WORKER_RUN_COMPLETION_MARKER,
-    "End the Provider turn with a truthful final report. Yui records that native turn result "
-        + "for the current AgentRun automatically; no completion command is required.",
-    "If you cannot finally determine success, failure, completeness, or the correct "
-        + "disposition, do not guess, silently stop, or hide uncertainty behind a success "
-        + "summary. Label the final report uncertain, incomplete, "
-        + "blocked, or requiring Leader judgment.",
-    "Report the most complete truthful evidence available and, when applicable: exact AgentRun, "
-        + "WorkItem, and native Session identity; actions actually performed; changed paths "
-        + "and commit/worktree state; checks actually run and their outcomes; provider, runtime, "
-        + "or permission errors; the last confirmed lifecycle boundary; work not performed; "
-        + "unresolved assumptions or decisions; residual risks; confidence; and bounded next options.",
-    "The Provider turn ending closes only this AgentRun. It does not imply Leader acceptance, "
-        + "WorkItem completion, ChangeSet capture, Integration, or Task completion. Review AgentRuns "
-        + "report findings, verification gaps, and limits; the Leader decides disposition."
-].join("\n");
-export function ensureWorkerRunCompletionRequirement(input) {
-    return input.endsWith(`\n\n${WORKER_RUN_COMPLETION_REQUIREMENT}`)
-        ? input
-        : `${input}\n\n${WORKER_RUN_COMPLETION_REQUIREMENT}`;
-}
-function renderDispatchContext(kind, context) {
-    const profile = context.role;
-    const binding = profile.agentBindings[profile.activeAgentId];
-    const profileLines = [
-        `Task: ${context.taskId}`,
-        `Role: ${profile.name}`,
-        `Active Agent: ${profile.activeAgentId}`,
-        `Runtime: ${binding.adapterId}; model: ${binding.config.model ?? "CLI default"}; effort: ${binding.config.effort ?? "CLI default"}; permission: ${binding.config.permission.strategy}`,
-        profile.description === undefined ? null : `Description: ${profile.description}`,
-        ...(profile.responsibilities ?? []).map((item) => `Responsibility: ${item}`),
-        ...(profile.constraints ?? []).map((item) => `Constraint: ${item}`),
-        profile.expectedOutput === undefined ? null : `Expected output: ${profile.expectedOutput}`
-    ].filter((line) => line !== null);
-    const workLines = kind === "worker"
-        ? renderWorkerScope(context)
-        : [];
-    const rendered = [
-        `Follow the injected yui-${kind} Skill for this Yui dispatch.`,
-        renderContextLayers(context, kind),
-        profileLines.join("\n"),
-        workLines.length === 0 ? null : workLines.join("\n"),
-        "Yui dispatch:",
-        requireText(context.input, "dispatch input")
-    ].filter((section) => section !== null && section.length > 0)
-        .join("\n\n");
-    return kind === "worker"
-        ? ensureWorkerRunCompletionRequirement(rendered)
-        : rendered;
-}
-function renderContextLayers(context, kind) {
-    const projects = context.projectPolicy ?? [];
-    const policyLines = projects.length === 0
-        ? ["- none (this Task is not Project-backed)"]
-        : projects.map(({ projectId, directory }) => {
-            const label = directory === undefined ? projectId : `${directory} (${projectId})`;
-            return `- ${label}: \`yui project show ${projectId}\`; then \`yui project knowledge list ${projectId}\` and show the relevant entries`;
-        });
-    return [
-        "Context layers:",
-        "- Yui Core: durable identity, lifecycle, access, workspace, and exact handoff safety.",
-        `- Generic ${kind} Skill: reusable role behavior and evidence discipline.`,
-        "- Project Policy: project-owned build, test, migration, release, and review rules; it is not a Yui Core default.",
-        ...["Project Policy references:", ...policyLines],
-        "- Task Contract: the current Task brief, WorkItem objective, acceptance criteria, and dispatch input.",
-        "Do not import rules from another Project or Task, and do not infer Project Policy from repository files alone."
-    ].join("\n");
-}
-function renderWorkerScope(context) {
-    if (context.workItem === undefined || context.workspace === undefined)
-        return [];
-    const writable = context.workspace.entries.filter(({ access }) => access === "write");
-    const contextOnly = context.workspace.entries.filter(({ access }) => access === "read");
-    const projectLines = (label, entries) => [
-        `${label}:`,
-        ...(entries.length === 0
-            ? ["- none"]
-            : entries.map(({ directory, projectId }) => `- ${directory} (${projectId})`))
-    ];
-    return [
-        `WorkItem: ${context.workItem.id}`,
-        `Workspace root: ${context.workspace.root}`,
-        ...projectLines("Writable Projects", writable),
-        ...projectLines("Context-only Projects", contextOnly),
-        `Read the full Task state with \`yui task context ${context.taskId}\`.`,
-        `Read the current WorkItem scope with \`yui task work list ${context.taskId}\`.`,
-        "Modify only Writable Projects. If another Project must change, stop and ask "
-            + "the Task Leader to expand this WorkItem scope before continuing."
-    ];
-}
-function requireText(value, label) {
-    const normalized = value.trim();
-    if (normalized.length === 0 || normalized.includes("\0")) {
-        throw new Error(`${label} is required.`);
-    }
-    return normalized;
-}

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;
-}