@zq-silk/yui 0.14.0 → 0.14.2

package/dist/resources/liveReferences.js

@@ -10,7 +10,6 @@ import { createHash } from "node:crypto";
 import { existsSync, readFileSync, readdirSync, readlinkSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { promisify } from "node:util";
-import { parseExactTaskRuntimeDescriptor } from "../runtime/exactControlPlane.js";
 import { readRuntimeIdentity, releasesDirectory, resolveActiveRelease } from "../release/runtimeRelease.js";
 import { isControllerSocketPathForHome } from "../core/controllerEndpoint.js";
 import { parseControllerDiscovery } from "../core/protocol.js";
@@ -105,20 +104,18 @@ export async function scanLiveReferences(input) {
     }
     if (discovery.diagnostic !== undefined)
         diagnostics.push(discovery.diagnostic);
-    // 4. Runtime identity and exact Task descriptors are durable live-ownership
-    //    claims. Resolved runtime paths and descriptor workspaces stay protected
-    //    while their owning process identity is alive.
+    // 4. Runtime identity is a durable live-ownership claim. Resolved runtime
+    //    paths stay protected while their owning process identity is alive.
+    //    Managed workspaces are claimed from their durable records below, which
+    //    is the same authority the Controller schedules from.
     const runtimeClaims = readRuntimeIdentityClaims(home);
     diagnostics.push(...runtimeClaims.diagnostics);
-    const descriptorClaims = readExactTaskRuntimeClaims(home);
-    diagnostics.push(...descriptorClaims.diagnostics);
     const activeReleaseClaims = readActiveReleaseClaims(home);
     diagnostics.push(...activeReleaseClaims.diagnostics);
     const sessionOwnerClaims = readSessionOwnerClaims(home);
     diagnostics.push(...sessionOwnerClaims.diagnostics);
     for (const claim of [
         ...runtimeClaims.claims,
-        ...descriptorClaims.claims,
         ...activeReleaseClaims.claims,
         ...sessionOwnerClaims.claims
     ]) {
@@ -209,52 +206,6 @@ function readRuntimeIdentityClaims(home) {
         });
     }
 }
-function readExactTaskRuntimeClaims(home) {
-    const directory = join(home, "runtime", "exact-task-runtime");
-    let entries;
-    try {
-        entries = readdirSync(directory, { withFileTypes: true });
-    }
-    catch (error) {
-        if (error.code === "ENOENT") {
-            return Object.freeze({ claims: Object.freeze([]), diagnostics: Object.freeze([]) });
-        }
-        return Object.freeze({
-            claims: Object.freeze([]),
-            diagnostics: Object.freeze([{
-                    source: "controller",
-                    severity: "error",
-                    message: `exact Task runtime descriptors are unreadable: ${error instanceof Error ? error.message : "unknown error"}`
-                }])
-        });
-    }
-    const claims = [];
-    const diagnostics = [];
-    for (const entry of entries) {
-        if (!entry.isFile() || !entry.name.endsWith(".json"))
-            continue;
-        const path = join(directory, entry.name);
-        try {
-            const descriptor = parseExactTaskRuntimeDescriptor(readFileSync(path, "utf8"));
-            claims.push({ path, token: `exact-task-runtime:${descriptor.taskId}` });
-            claims.push({
-                path: resolve(descriptor.workspace),
-                token: `exact-task-runtime:workspace:${descriptor.taskId}`
-            });
-        }
-        catch (error) {
-            diagnostics.push({
-                source: "controller",
-                severity: "error",
-                message: `exact Task runtime descriptor is unreadable at ${path}: ${error instanceof Error ? error.message : "unknown error"}`
-            });
-        }
-    }
-    return Object.freeze({
-        claims: Object.freeze(claims),
-        diagnostics: Object.freeze(diagnostics)
-    });
-}
 function readActiveReleaseClaims(home) {
     try {
         const active = resolveActiveRelease(home);
@@ -281,7 +232,7 @@ function readActiveReleaseClaims(home) {
     }
 }
 /**
- * Read Session owner records (`runtime/session-owners/<launchId>.json`). A
+ * Read Session owner records (`runtime/session-owners/<runtimeGenerationId>.json`). A
  * record whose Provider root is physically alive with a matching start
  * identity protects its runtime root. A dead PID is stale (reconciliation
  * removes those records); an identity conflict or unreadable record fails
@@ -350,7 +301,7 @@ function readSessionOwnerClaims(home) {
         if (typeof record.runtimeRoot === "string" && record.runtimeRoot.length > 0) {
             claims.push({
                 path: resolve(record.runtimeRoot),
-                token: `session-owner:${typeof record.launchId === "string" ? record.launchId : entry.name}`
+                token: `session-owner:${typeof record.runtimeGenerationId === "string" ? record.runtimeGenerationId : entry.name}`
             });
         }
     }

package/dist/resources/resourceDiscovery.js

@@ -164,36 +164,7 @@ export async function discoverResources(input) {
 function discoverRuntimeArtifacts(home, input) {
     const discovered = [];
     const now = input.now;
-    // 3a. Exact Task runtime descriptors: runtime/exact-task-runtime/<digest>.json
-    const exactDirectory = join(home, "runtime", "exact-task-runtime");
-    for (const entry of safeReaddir(exactDirectory)) {
-        if (!entry.name.endsWith(".json"))
-            continue;
-        const path = join(exactDirectory, entry.name);
-        const descriptor = readJsonFile(path);
-        const taskId = typeof descriptor?.taskId === "string" ? descriptor.taskId : undefined;
-        const owner = {
-            home,
-            ...(taskId === undefined ? {} : { taskId }),
-            basis: taskId === undefined ? "unattributed" : "descriptor"
-        };
-        const taskStatus = taskId === undefined ? undefined : input.taskStatusById.get(taskId);
-        discovered.push({
-            record: createResourceRecord({
-                kind: "runtime-artifact",
-                path: resolve(path),
-                owner,
-                ...(sizeOf(path) === undefined ? {} : { sizeBytes: sizeOf(path) }),
-                cleanliness: "n/a",
-                activeRefs: [],
-                disposition: "active"
-            }, now),
-            ownerTerminal: taskId === undefined
-                ? false
-                : isTerminalTaskStatus(taskStatus)
-        });
-    }
-    // 3b. Task runtime isolation roots: <home>.task-runtimes/<taskId>/<owner>/<launch>/
+    // 3a. Task runtime isolation roots: <home>.task-runtimes/<taskId>/<owner>/<launch>/
     const runtimeRoot = `${resolve(home)}.task-runtimes`;
     if (existsSync(runtimeRoot)) {
         for (const taskEntry of safeReaddir(runtimeRoot)) {

package/dist/resources/resourceRegistrar.js

@@ -80,29 +80,6 @@ export class ResourceRegistrar {
             cleanliness: "n/a"
         })));
     }
-    registerExactTaskRuntimeDescriptor(descriptor, sourcePath) {
-        try {
-            this.#registerExactTaskRuntimeDescriptor(descriptor, sourcePath);
-        }
-        catch {
-            // Best-effort receipt; descriptor writes must proceed regardless.
-        }
-    }
-    #registerExactTaskRuntimeDescriptor(descriptor, sourcePath) {
-        const path = resolve(sourcePath);
-        if (!existsSync(path) || isReleaseNamespacePath(this.#home, path))
-            return;
-        this.#save([this.#record({
-                kind: "runtime-artifact",
-                path,
-                owner: {
-                    home: this.#home,
-                    taskId: descriptor.taskId,
-                    basis: "descriptor"
-                },
-                cleanliness: "n/a"
-            })]);
-    }
     registerSessionContext(path, owner) {
         try {
             this.#registerSessionContext(path, owner);

package/dist/review/deltaRecheck.js

@@ -1,13 +1,13 @@
 import { createHash } from "node:crypto";
 import { validateDeltaRecheckRecord } from "./reviewRound.js";
-import { isSemanticReviewRound } from "./reviewOutcomeClassifier.js";
 /**
  * Assesses whether a trustworthy delta can be constructed. Only technical
  * unavailability fails closed; Agents retain the semantic judgment.
  */
 export async function assessDeltaRecheck(input) {
     const { repositoryPaths, previousRound, candidate, git } = input;
-    if (!isSemanticReviewRound(previousRound)
+    if (previousRound.status !== "completed"
+        || previousRound.reviewerTurnId === undefined
         || (previousRound.scope ?? "work-item") !== "task") {
         return {
             kind: "ineligible",
@@ -114,7 +114,7 @@ export function verifyDeltaRecheckDiff(record, diffByProject) {
 }
 /** Builds the delta-recheck dispatch context block. */
 export function buildDeltaRecheckDispatchContext(input) {
-    const { round, previousRound, diffByProject, ledgerContext } = input;
+    const { round, previousRound, diffByProject } = input;
     const record = round.deltaRecheck;
     if (record === undefined) {
         throw new Error(`ReviewRound is not a delta-recheck: ${round.id}.`);
@@ -129,7 +129,8 @@ export function buildDeltaRecheckDispatchContext(input) {
         "  semantic change, evidence doubt). This is the safe default.",
         "Yui verified only the technical delta boundary; a Task-control Agent selected this mode.",
         `Previous accepted ReviewRound: ${previousRound.id}@${record.previousBaseCommit}`,
-        `Previous acceptance summary: ${compact(previousRound.summary ?? previousRound.report ?? "")}`,
+        `Previous Reviewer Turn: ${previousRound.reviewerTurnId ?? "unavailable"}`,
+        "Read that exact source Turn's original result from the frozen Context Snapshot.",
         ...(round.taskCandidate?.projects.map((project) => {
             const previous = previousRound.taskCandidate?.projects
                 .find((entry) => entry.projectId === project.projectId)?.commit;
@@ -143,73 +144,15 @@ export function buildDeltaRecheckDispatchContext(input) {
         ...Object.entries(diffByProject).flatMap(([projectId, diff]) => (diff.trim().length === 0
             ? []
             : [`--- ${projectId} ---`, diff])),
-        ...(previousEvidenceReferences(previousRound).length === 0
-            ? []
-            : [
-                "Previous evidence references:",
-                ...previousEvidenceReferences(previousRound).map((entry) => `- ${entry}`)
-            ]),
-        ledgerContext,
-        "Report JSON with deltaDisposition (one of the three values above) and deltaReasoning",
-        "(the explicit proof or the reason a full Review is required). Findings, checks, and",
-        "evidence use the same fields as a full Review."
+        "Return one complete result with the chosen disposition, reasoning, findings,",
+        "verification, uncertainty, and recommended next action. Markdown or JSON is acceptable;",
+        "Yui Core preserves the original text and does not parse or validate its structure."
     ];
     return lines.join("\n");
 }
-function compact(text, limit = 600) {
-    const flattened = text.replace(/\s+/gu, " ").trim();
-    return flattened.length <= limit ? flattened : `${flattened.slice(0, limit)}...`;
-}
 function digestDiff(diffByProject) {
     const canonical = JSON.stringify(Object.entries(diffByProject)
         .sort(([left], [right]) => left.localeCompare(right))
         .map(([projectId, diff]) => [projectId, diff]));
     return createHash("sha256").update(canonical).digest("hex");
 }
-/** All path-like evidence references from Markdown or JSON Review reports. */
-function previousEvidenceReferences(round) {
-    const report = round.report ?? "";
-    return [...new Set([
-            ...extractDeclaredEvidence(report),
-            ...extractEvidenceReferences(report)
-        ])];
-}
-/** Preserve the free-form evidence array that older JSON reports exposed. */
-function extractDeclaredEvidence(report) {
-    let parsed;
-    try {
-        parsed = JSON.parse(report);
-    }
-    catch {
-        return [];
-    }
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
-        return [];
-    const evidence = parsed.evidence;
-    if (!Array.isArray(evidence))
-        return [];
-    return evidence.flatMap((entry) => (typeof entry === "string" && entry.trim().length > 0 ? [entry.trim()] : []));
-}
-/**
- * Reviewer reports intentionally accept clear Markdown or JSON without a
- * fixed schema. Extract likely repo-relative references from the preserved
- * report so the next Reviewer can inspect the earlier evidence directly.
- */
-function extractEvidenceReferences(report) {
-    const references = report.match(/(?:\.{0,2}\/)?[A-Za-z0-9_.-]+(?:\/[A-Za-z0-9_.-]+)+|[A-Za-z0-9_.-]+\.[A-Za-z0-9]{1,12}/gu) ?? [];
-    return [...new Set(references.map((entry) => entry.replace(/^\.\//u, "")))]
-        .filter((entry) => isPathLike(entry));
-}
-function isPathLike(value) {
-    if (value.length === 0 || value.length > 512)
-        return false;
-    if (/\s/u.test(value))
-        return false;
-    if (value.includes("://"))
-        return false;
-    // A repo-relative path: at least one slash or a known file extension, no
-    // shell/argument metacharacters.
-    if (/[;&|`$(){}!<>]/u.test(value))
-        return false;
-    return value.includes("/") || /\.[A-Za-z0-9]{1,12}$/u.test(value);
-}

package/dist/review/reviewAcceptance.js

@@ -1,26 +1,29 @@
-import { isSemanticReviewRound } from "./reviewOutcomeClassifier.js";
+export function isCompletedReviewExecutionFromTurns(round, turns) {
+    if (round.status !== "completed" || round.reviewerTurnId === undefined)
+        return false;
+    const turn = turns.find(({ id }) => id === round.reviewerTurnId);
+    return turn !== undefined
+        && turn.status === "completed"
+        && turn.result !== undefined
+        && turn.purpose === "review"
+        && turn.taskId === round.taskId
+        && turn.reviewRoundId === round.id
+        && turn.roleName === round.reviewerRoleName
+        && turn.executionGroupId === undefined
+        && turn.effective.reviewBaseCommit === round.reviewBaseCommit;
+}
 /**
- * Whether a completed Task-final Round is a trustworthy accepted baseline.
- * Semantic completion alone is insufficient when it returned a non-accepting
- * delta disposition or still owns an open material finding.
+ * Whether a Task-final ReviewRound has one exact completed main Reviewer Turn.
+ * This is structural evidence only and never means the Leader accepted it.
  */
-export function isAcceptedTaskReviewBaseline(store, round) {
-    return isAcceptedTaskReviewBaselineFromEvidence(round, store);
+export function isCompletedTaskReviewEvidence(store, round) {
+    return isCompletedTaskReviewEvidenceFromTurns(round, store.listTurns(round.taskId));
 }
-/** Pure evidence form shared by read-only projections and mutation paths. */
-export function isAcceptedTaskReviewBaselineFromEvidence(round, evidence) {
+export function isCompletedTaskReviewEvidenceFromTurns(round, turns) {
     if ((round.scope ?? "work-item") !== "task"
-        || round.status !== "completed"
         || round.taskCandidate === undefined
-        || round.taskCandidate.projects.length === 0
-        || !isSemanticReviewRound(round, evidence))
-        return false;
-    if ((round.checks ?? []).some(({ outcome }) => outcome === "failed"))
-        return false;
-    if (round.deltaRecheck !== undefined
-        && round.deltaRecheck.disposition !== "equivalent-and-accepted")
+        || round.taskCandidate.projects.length === 0) {
         return false;
-    return !(evidence?.listReviewFindings(round.taskId) ?? []).some((finding) => (finding.lastReviewRoundId === round.id
-        && (finding.severity === "p1" || finding.severity === "p2")
-        && (finding.disposition === "open" || finding.disposition === "fixed-pending-review")));
+    }
+    return isCompletedReviewExecutionFromTurns(round, turns);
 }

package/dist/review/reviewConfig.js

@@ -1,19 +1,9 @@
 import { requireIdentity } from "../domain/validation.js";
 export const REVIEW_TRIGGERS = ["always", "leader", "final"];
-/**
- * Issue 06 feature flag. `shadow` records the finding ledger and serves Leader
- * commands without changing completion behavior; `enforce` additionally fails
- * Task completion closed on undispositioned open P1/P2 findings.
- */
-export const REVIEW_FINDING_LEDGER_MODES = ["shadow", "enforce"];
 export function validateReviewConfig(config) {
     requireIdentity(config.roleName, "Review Role");
     if (!REVIEW_TRIGGERS.includes(config.trigger)) {
         throw new Error(`Review trigger is invalid: ${String(config.trigger)}.`);
     }
-    if (config.findingLedger !== undefined
-        && !REVIEW_FINDING_LEDGER_MODES.includes(config.findingLedger)) {
-        throw new Error(`Review finding ledger mode is invalid: ${String(config.findingLedger)}.`);
-    }
     return config;
 }

package/dist/review/reviewDecision.js

@@ -1,12 +1,12 @@
 import { isDeepStrictEqual } from "node:util";
-import { isAcceptedTaskReviewBaseline } from "./reviewAcceptance.js";
+import { isCompletedTaskReviewEvidence } from "./reviewAcceptance.js";
 import { projectReviewerAvailability } from "./reviewerAvailability.js";
 /** Read-only facts for Leader judgment; this projection never blocks an action. */
 export function projectReviewDecision(input) {
     const { store, task, roles, turns, rounds, reviewConfig, currentCandidate } = input;
     const taskRounds = rounds.filter((round) => (round.scope ?? "work-item") === "task");
     const accepted = [...taskRounds]
-        .filter((round) => isAcceptedTaskReviewBaseline(store, round))
+        .filter((round) => isCompletedTaskReviewEvidence(store, round))
         .sort(compareRoundIdentity)
         .at(-1);
     const latestAcceptedBaseline = accepted?.taskCandidate === undefined