@zq-silk/yui 0.12.2 → 0.12.4

package/dist/run/rejectedYieldAttempt.js

@@ -0,0 +1,221 @@
+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/runtime/tmuxAdapters.js

@@ -183,9 +183,18 @@ export class TmuxSessionHost {
                 : { environment: request.environment }),
             ...(request.mode === "resume" ? { nativeSessionId: request.nativeSessionId } : {})
         };
-        const planned = request.owner.scope === "task"
-            ? this.planner.plan({ taskId: request.owner.taskId, ...input })
-            : this.planner.planGlobalRole(input);
+        let planned;
+        try {
+            planned = request.owner.scope === "task"
+                ? this.planner.plan({ taskId: request.owner.taskId, ...input })
+                : this.planner.planGlobalRole(input);
+        }
+        catch (error) {
+            throw toRuntimeLaunchFailure(error, "validation", {
+                cwd: request.workspace,
+                agentId: request.agentId
+            });
+        }
         if (planned.role.name !== request.owner.roleName) {
             throw new Error("Planned Role does not match the runtime owner.");
         }

package/dist/scheduler/activeRoleRunDelivery.js

@@ -304,6 +304,9 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
                             run,
                             session: existingSession,
                             summary: error.message,
+                            leaderRecovery: role.name === "leader" && error.diagnostic.kind === "config"
+                                ? "blocked"
+                                : "automatic",
                             now
                         });
                         results.push({
@@ -375,6 +378,7 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
                         run,
                         session: existingSession,
                         summary: `Role Run could not start: ${message}`,
+                        leaderRecovery: "automatic",
                         now
                     });
                     results.push({

package/dist/storage/sqliteStore.js

@@ -535,6 +535,24 @@ export class SqliteTaskStore {
          ON CONFLICT(task_id, kind) DO UPDATE SET high_water = MAX(high_water, ?)`).run(taskId, kind, highWater, highWater);
         });
     }
+    /** Restore one validated historical grant into a disposable migration output. */
+    migrationRestoreCapabilityGrant(taskId, grant) {
+        if (!this.#migration) {
+            throw new StorageRecordError("Historical capability grants may only be restored into a migration sidecar.");
+        }
+        const stored = storedCapabilityGrant(grant);
+        if (stored.taskId !== taskId) {
+            throw new StorageRecordError(`Capability grant belongs to another Task: ${stored.taskId}`);
+        }
+        this.#requireTask(taskId);
+        this.#mutate(() => {
+            const existing = this.#getPayload("capability_grants", "task_id = ? AND grant_id = ?", [taskId, stored.id]);
+            if (existing !== null) {
+                throw new StorageRecordError(`Migration cannot overwrite capability grant: ${taskId}/${stored.id}`);
+            }
+            this.#db.prepare("INSERT INTO capability_grants (task_id, grant_id, payload, updated_at) VALUES (?, ?, ?, ?)").run(taskId, stored.id, this.#json(stored), this.#now());
+        });
+    }
     // -- generic payload helpers ------------------------------------------------
     #getPayload(table, where, params) {
         const row = this.#db.prepare(`SELECT payload FROM ${table} WHERE ${where}`).get(...params);

package/dist/storage/upgrade/sqliteStateMigration.js

@@ -404,7 +404,7 @@ export function populateSqliteFromState(home, state, databaseFilename) {
                 }
                 // Capability grants and release workflows (task-15 record families).
                 for (const grant of Object.values(stored.capabilityGrants)) {
-                    store.saveCapabilityGrant(taskId, grant);
+                    store.migrationRestoreCapabilityGrant(taskId, grant);
                 }
                 for (const workflow of Object.values(stored.releaseWorkflows)) {
                     store.saveReleaseWorkflow(taskId, workflow);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zq-silk/yui",
-  "version": "0.12.2",
+  "version": "0.12.4",
   "description": "Local control plane for long-running native agent CLI sessions backed by tmux.",
   "license": "MIT",
   "private": false,