@zq-silk/yui 0.11.3 → 0.12.0

package/dist/repository/taskWorkspacePreparer.js

@@ -2,13 +2,16 @@ import { lstat, mkdir, readlink, readdir, rmdir, symlink, unlink } from "node:fs
 import { isAbsolute, join, relative, resolve } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 import { retireTaskRoleSessionsForWorkspace } from "../executor/agentExecutor.js";
+import { formatWorkspacePreflightError } from "../executor/workspacePreflightClassification.js";
 import { updateRole } from "../role/role.js";
 import { hasRuntimeCleanupObligation, isRuntimeLaunchReservation, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { attachReviewRoundWorkspace, recordReviewWorkspaceDisposition } from "../review/reviewRound.js";
 import { StorageConflictError } from "../storage/taskStore.js";
-import { bindTaskWorkspaceIdentity } from "../task/task.js";
+import { activateTask, bindTaskWorkspaceIdentity } from "../task/task.js";
+import { createTaskEvent } from "../event/taskEvent.js";
+import { enqueueWork } from "../coordination/workMailboxQueue.js";
 import { createCandidateGitSnapshot, createDirectTaskMainSnapshot, workItemExecutionGroupById, recordWorkItemWorkspaceDisposition } from "../workItem/workItem.js";
-import { createManagedWorkspace, managedWorkspaceKey, managedWorktreeName, sameManagedWorkspaceIdentity } from "../worktree/managedWorkspace.js";
+import { createManagedWorkspace, isTaskOwnedWorkspace, managedWorkspaceKey, managedWorktreeName, sameManagedWorkspaceIdentity } from "../worktree/managedWorkspace.js";
 import { agentRunDeliveryReceiptId } from "../run/agentRun.js";
 import { NodeGitWorkspace, worktreeIdentity } from "./gitWorkspace.js";
 import { acquireProjectMaintenanceLocks } from "./projectMaintenanceLock.js";
@@ -80,7 +83,47 @@ export class FileTaskWorkspacePreparer {
                 const task = requireTask(this.store, taskId);
                 const { release, current } = this.#acquireTaskProjectMaintenanceLocks(task);
                 try {
-                    return await this.#prepareTaskWorkspaceLocked(current.id);
+                    return await this.#prepareTaskWorkspaceLocked(current.id, false);
+                }
+                finally {
+                    release();
+                }
+            }
+            catch (error) {
+                if (error instanceof StorageConflictError
+                    && attempt < TASK_WORKSPACE_PREPARE_MAX_CONFLICT_RETRIES) {
+                    continue;
+                }
+                throw error;
+            }
+        }
+    }
+    /**
+     * Prepare every physical Task-main resource and adopt it in the same store
+     * transaction that moves the Task from Draft to active. A Draft never owns a
+     * durable writable workspace before this boundary, and any failed attempt
+     * discards its unadopted refs/worktrees.
+     */
+    async activateTaskWorkspace(taskId) {
+        for (let attempt = 0;; attempt += 1) {
+            try {
+                const task = requireTask(this.store, taskId);
+                if (task.status === "active") {
+                    const workspace = this.store.getTaskWorkspace(task.id);
+                    if (!isTaskOwnedWorkspace(workspace, task.id, task.cwd, task.projectBindings.map(({ projectId, directory }) => ({ projectId, directory })))) {
+                        throw new Error(`Active Task workspace adoption is invalid: ${task.id}.`);
+                    }
+                    return {
+                        task,
+                        taskId: task.id,
+                        status: "ready",
+                        ...(task.cwd === undefined ? {} : { path: task.cwd }),
+                        changed: false
+                    };
+                }
+                const { release, current } = this.#acquireTaskProjectMaintenanceLocks(task);
+                try {
+                    return await this.#prepareTaskWorkspaceLocked(current.id, true);
                 }
                 finally {
                     release();
@@ -137,59 +180,94 @@ export class FileTaskWorkspacePreparer {
     acquireTaskProjectMaintenanceLocks(taskId) {
         return this.#acquireTaskProjectMaintenanceLocks(requireTask(this.store, taskId));
     }
-    async #prepareTaskWorkspaceLocked(taskId) {
+    async #prepareTaskWorkspaceLocked(taskId, activate) {
         const task = requireTask(this.store, taskId);
-        if (!["draft", "active"].includes(task.status)) {
+        if (activate && task.status !== "draft") {
+            throw new Error(`Only a Draft Task can atomically adopt a workspace: ${task.id}/${task.status}.`);
+        }
+        if (!activate && task.status === "draft") {
+            throw new Error(`Draft Task workspace must be adopted by task activation: ${task.id}.`);
+        }
+        if (!activate && task.status !== "active") {
             throw new Error(`Task is not open for workspace preparation: ${task.id}.`);
         }
+        const existing = this.store.getTaskWorkspace(task.id);
+        if (activate && (task.workspaceIdentity !== undefined
+            || task.cwd !== undefined
+            || existing !== null)) {
+            throw new Error(`Draft Task already has adopted workspace state: ${task.id}. `
+                + "Inspect it with `yui task base status`, then retire and recreate the Draft.");
+        }
+        if (!activate && existing === null) {
+            throw new Error(`Active Task has no durable workspace owner: ${task.id}. `
+                + "Use `yui task base status` to diagnose the incomplete activation.");
+        }
         if (task.projectBindings.length === 0) {
-            const existing = this.store.getTaskWorkspace(task.id);
             const root = this.#taskWorkspaceRoot(task.id);
-            if (existing !== null && (existing.owner.type !== "task"
-                || existing.owner.taskId !== task.id
-                || existing.root !== root
-                || existing.entries.length !== 0)) {
-                throw new Error(`Gitless Task workspace ownership is invalid: ${task.id}.`);
-            }
-            // Gitless Tasks still need a durable runtime owner. The empty view is
-            // Task-specific, so launches cannot fall back to a global workspace or
-            // repository root while no Project is bound.
-            await ensureWorkspaceView(root, []);
-            const workspace = createManagedWorkspace({
-                owner: { type: "task", taskId: task.id },
-                root,
-                entries: []
-            }, this.now());
-            this.#registerWorkspace(workspace);
-            this.store.transaction((tx) => {
-                const latest = requireTask(tx, task.id);
-                if (!['draft', 'active'].includes(latest.status)
-                    || latest.projectBindings.length !== 0) {
-                    throw new Error(`Task changed while preparing its Gitless workspace: ${task.id}.`);
-                }
-                const current = tx.getTaskWorkspace(task.id);
-                // `createManagedWorkspace` stamps a fresh updatedAt on every call.
-                // Gitless preparation is idempotent, so compare only stable identity
-                // and retain the existing durable record verbatim.
-                if (current !== null && !sameManagedWorkspaceIdentity(current, workspace)) {
-                    throw new Error(`Gitless Task workspace changed during preparation: ${task.id}.`);
-                }
-                const timestamp = this.now();
-                if (latest.cwd !== root) {
-                    tx.saveTask({ ...latest, cwd: root, updatedAt: timestamp.toISOString() });
-                }
-                if (current === null)
-                    tx.saveManagedWorkspace(workspace);
-                for (const role of tx.listRoles(task.id)) {
-                    if (role.workspace !== root) {
-                        retireWorkspaceBoundSession(tx, task.id, role.name, timestamp);
-                        tx.saveRole(task.id, updateRole(role, { workspace: root }, timestamp));
+            try {
+                if (existing !== null && (existing.owner.type !== "task"
+                    || existing.owner.taskId !== task.id
+                    || existing.root !== root
+                    || existing.entries.length !== 0)) {
+                    throw new Error(`Gitless Task workspace ownership is invalid: ${task.id}.`);
+                }
+                // Gitless Tasks still need a durable runtime owner. The empty view is
+                // Task-specific, so launches cannot fall back to a global workspace or
+                // repository root while no Project is bound.
+                await ensureWorkspaceView(root, []);
+                const workspace = createManagedWorkspace({
+                    owner: { type: "task", taskId: task.id },
+                    root,
+                    entries: []
+                }, this.now());
+                this.#registerWorkspace(workspace);
+                const persisted = this.store.transaction((tx) => {
+                    const latest = requireTask(tx, task.id);
+                    if (latest.status !== task.status
+                        || latest.projectBindings.length !== 0) {
+                        throw new Error(`Task changed while preparing its Gitless workspace: ${task.id}.`);
                     }
-                }
-            });
-            return { taskId, status: "ready", path: root };
+                    const current = tx.getTaskWorkspace(task.id);
+                    // `createManagedWorkspace` stamps a fresh updatedAt on every call.
+                    // Gitless preparation is idempotent, so compare only stable identity
+                    // and retain the existing durable record verbatim.
+                    if (current !== null && !sameManagedWorkspaceIdentity(current, workspace)) {
+                        throw new Error(`Gitless Task workspace changed during preparation: ${task.id}.`);
+                    }
+                    const timestamp = this.now();
+                    let next = latest.cwd === root
+                        ? latest
+                        : { ...latest, cwd: root, updatedAt: timestamp.toISOString() };
+                    if (activate)
+                        next = activateTask(next, timestamp);
+                    if (!isDeepStrictEqual(next, latest))
+                        tx.saveTask(next);
+                    if (current === null)
+                        tx.saveManagedWorkspace(workspace);
+                    for (const role of tx.listRoles(task.id)) {
+                        if (role.workspace !== root) {
+                            retireWorkspaceBoundSession(tx, task.id, role.name, timestamp);
+                            tx.saveRole(task.id, updateRole(role, { workspace: root }, timestamp));
+                        }
+                    }
+                    if (activate)
+                        recordTaskActivation(tx, latest, next, timestamp);
+                    return next;
+                });
+                return {
+                    task: persisted,
+                    taskId,
+                    status: "ready",
+                    path: root,
+                    changed: activate
+                };
+            }
+            catch (error) {
+                if (activate)
+                    await removeWorkspaceView(root);
+                throw error;
+            }
         }
-        const existing = this.store.getTaskWorkspace(task.id);
         if (existing !== null && existing.owner.type !== "task") {
             throw new Error(`Task main workspace ownership is invalid: ${task.id}.`);
         }
@@ -268,6 +346,18 @@ export class FileTaskWorkspacePreparer {
                     roleName: MAIN_WORKTREE,
                     baseRef: previous?.baseCommit ?? baseline.baseRef
                 });
+                if (previous !== undefined
+                    && !await this.git.isAncestor(physical.path, previous.baseCommit, physical.baseCommit)) {
+                    throw new Error(formatWorkspacePreflightError({
+                        kind: "physical-drift",
+                        reason: `Task main physical HEAD left its recorded lineage: ${task.id}/${project.id}.`,
+                        taskId: task.id,
+                        roleName: LEADER_ROLE,
+                        projectId: project.id,
+                        expectedCommit: previous.baseCommit,
+                        physicalCommit: physical.baseCommit
+                    }));
+                }
                 if (baseline.expectedCommit !== undefined
                     && physical.baseCommit !== baseline.expectedCommit) {
                     throw new Error(`Task Project workspace did not start at the fetched remote baseline: ${project.id}.`);
@@ -289,7 +379,7 @@ export class FileTaskWorkspacePreparer {
                         path: physical.path,
                         branch: physical.branch,
                         baseRef: previous?.baseRef ?? baseline.recordedBaseRef,
-                        baseCommit: physical.baseCommit
+                        baseCommit: previous?.baseCommit ?? physical.baseCommit
                     },
                     provenance
                 });
@@ -301,9 +391,9 @@ export class FileTaskWorkspacePreparer {
                 entries: prepared.map(({ entry }) => entry)
             }, this.now());
             this.#registerWorkspace(workspace);
-            this.store.transaction((tx) => {
+            const persisted = this.store.transaction((tx) => {
                 const latest = requireTask(tx, task.id);
-                if (!["draft", "active"].includes(latest.status)) {
+                if (latest.status !== task.status) {
                     throw new Error(`Task changed while preparing its workspace: ${task.id}.`);
                 }
                 if (!isDeepStrictEqual(latest.projectBindings, task.projectBindings)) {
@@ -358,6 +448,8 @@ export class FileTaskWorkspacePreparer {
                 if (persistedTask.cwd !== root) {
                     persistedTask = { ...persistedTask, cwd: root, updatedAt: timestamp.toISOString() };
                 }
+                if (activate)
+                    persistedTask = activateTask(persistedTask, timestamp);
                 if (!isDeepStrictEqual(persistedTask, latest)) {
                     tx.saveTask(persistedTask);
                 }
@@ -366,9 +458,10 @@ export class FileTaskWorkspacePreparer {
                     recordTaskBaseProvenanceEvents(tx, task.id, prepared.map(({ provenance }) => provenance), timestamp);
                 }
                 for (const role of tx.listRoles(task.id)) {
-                    // The Role field is only a cwd/snapshot hint.  Preserve the hint for
-                    // an active WorkItem assignment; the durable owner is the WorkItem,
-                    // not this Role record.  Other Roles use Task main.
+                    // The Role field is only a cwd/snapshot hint. Preserve it while a
+                    // durable WorkItem or ReviewRound workspace owns that cwd; Task-main
+                    // preparation must not move a Reviewer Session out from under an
+                    // active or retained ReviewRound. Other Roles use Task main.
                     // Prefer the active Run's exact WorkItem for this Role; fall back
                     // to the first queued WorkItem only when no active Run owns the Role.
                     const activeRoleRun = tx.getActiveAgentRun(task.id, role.name);
@@ -387,7 +480,14 @@ export class FileTaskWorkspacePreparer {
                     const assignedWorkspace = assignedItem === undefined
                         ? null
                         : tx.getWorkItemWorkspace(task.id, assignedItem.id);
-                    const target = assignedWorkspace?.root ?? root;
+                    const reviewWorkspace = tx.listManagedWorkspaces(task.id).find((candidate) => {
+                        if (candidate.owner.type !== "review-round"
+                            || candidate.root !== role.workspace)
+                            return false;
+                        return tx.getReviewRound(task.id, candidate.owner.reviewRoundId)
+                            ?.reviewerRoleName === role.name;
+                    });
+                    const target = assignedWorkspace?.root ?? reviewWorkspace?.root ?? root;
                     if (role.workspace !== target) {
                         if (assignedItem === undefined
                             || assignedWorkspace === null
@@ -397,14 +497,25 @@ export class FileTaskWorkspacePreparer {
                         tx.saveRole(task.id, updateRole(role, { workspace: target }, timestamp));
                     }
                 }
+                if (activate)
+                    recordTaskActivation(tx, latest, persistedTask, timestamp);
+                return persistedTask;
             });
-            return { taskId, status: "ready", path: root };
+            return {
+                task: persisted,
+                taskId,
+                status: "ready",
+                path: root,
+                changed: activate
+            };
         }
         catch (error) {
             // A failed or conflicted preparation owns no durable record: drop the
             // branches too, so a retry mints a clean identity without half-created
             // refs behind. Adopted (already catalogued) worktrees are never touched.
             await this.#discardUnadoptedEntries(task, taskSegment, prepared, MAIN_WORKTREE, true);
+            if (activate)
+                await removeWorkspaceView(root);
             throw error;
         }
     }
@@ -418,7 +529,7 @@ export class FileTaskWorkspacePreparer {
     async #prepareTaskWorkspaceWithRetries(taskId, lockedProjectIds) {
         for (let attempt = 0;; attempt += 1) {
             try {
-                return await this.#prepareTaskWorkspaceLocked(taskId);
+                return await this.#prepareTaskWorkspaceLocked(taskId, false);
             }
             catch (error) {
                 if (!(error instanceof StorageConflictError)
@@ -1869,8 +1980,8 @@ export class FileTaskWorkspacePreparer {
      */
     async rebuildTaskWorkspace(taskId, options = {}) {
         const task = requireTask(this.store, taskId);
-        if (!["draft", "active"].includes(task.status)) {
-            throw new Error(`Only a draft or active Task can be rebuilt in place: ${task.id}/${task.status}.`);
+        if (task.status !== "active") {
+            throw new Error(`Only an active Task can rebuild its adopted workspace: ${task.id}/${task.status}.`);
         }
         // The rebuild holds every touched Project's maintenance fence for its
         // whole duration, so the Controller defers preparation and no other
@@ -2521,6 +2632,11 @@ export class FileTaskWorkspacePreparer {
         });
     }
 }
+function recordTaskActivation(store, previous, active, now) {
+    enqueueWork(store, { kind: "role", taskId: active.id, roleName: LEADER_ROLE }, "task-created", now, [{ type: "task", id: active.id }]);
+    enqueueWork(store, { kind: "task", taskId: active.id }, "task-activated", now, [{ type: "task", id: active.id }]);
+    store.saveEvent(active.id, createTaskEvent(store.nextEventId(active.id), active.id, "task.activated", { fromStatus: previous.status, status: active.status }, now));
+}
 function requireTask(store, taskId) {
     const task = store.getTask(taskId);
     if (task === null)

package/dist/resources/sqliteResourceRegistry.js

@@ -34,7 +34,7 @@ export class SqliteResourceRegistry {
         this.#db.pragma("journal_mode = WAL");
         this.#db.pragma("foreign_keys = ON");
         this.#db.pragma("busy_timeout = 5000");
-        migrateSqliteSchema(this.#db);
+        migrateSqliteSchema(this.#db, { mode: "validate" });
     }
     load() {
         const rows = this.#db.prepare(`SELECT payload FROM ${SQLITE_RESOURCE_REGISTRY_TABLE}`).all();

package/dist/review/deltaRecheck.js

@@ -1,14 +1,12 @@
 import { createHash } from "node:crypto";
-import { deltaRecheckMaxChangedFiles, deltaRecheckMaxChangedLines } from "./reviewConfig.js";
 import { validateDeltaRecheckRecord } from "./reviewRound.js";
 import { isSemanticReviewRound } from "./reviewOutcomeClassifier.js";
 /**
- * Assesses whether a delta-recheck may be attempted.  Every deterministic
- * gate fails closed here; semantic equivalence is always left to the
- * Reviewer's explicit disposition.
+ * 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, config } = input;
+    const { repositoryPaths, previousRound, candidate, git } = input;
     if (!isSemanticReviewRound(previousRound)
         || (previousRound.scope ?? "work-item") !== "task") {
         return {
@@ -23,6 +21,12 @@ export async function assessDeltaRecheck(input) {
         };
     }
     const previousByProject = new Map(previousRound.taskCandidate.projects.map((project) => [project.projectId, project.commit]));
+    if (previousByProject.size !== candidate.projects.length) {
+        return {
+            kind: "ineligible",
+            reason: "Delta recheck Project scope differs from the accepted baseline."
+        };
+    }
     const diffByProject = {};
     const changedFiles = [];
     let addedLines = 0;
@@ -91,31 +95,6 @@ export async function assessDeltaRecheck(input) {
             reason: "Frozen heads are unchanged; the previous acceptance already covers this candidate."
         };
     }
-    const maxFiles = deltaRecheckMaxChangedFiles(config);
-    if (changedFiles.length > maxFiles) {
-        return {
-            kind: "ineligible",
-            reason: `Delta recheck attempt threshold exceeded: ${changedFiles.length} changed file(s) > ${maxFiles}.`
-        };
-    }
-    const maxLines = deltaRecheckMaxChangedLines(config);
-    if (addedLines + deletedLines > maxLines) {
-        return {
-            kind: "ineligible",
-            reason: `Delta recheck attempt threshold exceeded: ${addedLines + deletedLines} changed line(s) > ${maxLines}.`
-        };
-    }
-    // Evidence overlap: a diff touching a file the previous Round cited as
-    // evidence cannot be proven equivalent by a delta recheck.
-    const evidencePaths = extractEvidencePaths(previousRound);
-    const overlapping = changedFiles.filter((file) => (evidencePaths.some((evidence) => pathEvidenceMatches(evidence, file))));
-    if (overlapping.length > 0) {
-        return {
-            kind: "ineligible",
-            reason: "Delta recheck cannot prove evidence validity for changed evidence file(s): "
-                + `${overlapping.join(", ")}.`
-        };
-    }
     const record = validateDeltaRecheckRecord({
         schemaVersion: 1,
         previousReviewRoundId: previousRound.id,
@@ -148,7 +127,7 @@ export function buildDeltaRecheckDispatchContext(input) {
         "- finding: the diff introduces a material problem; report it as a finding.",
         "- requires-full-review: you cannot prove equivalence (uncertainty, cross-scope,",
         "  semantic change, evidence doubt). This is the safe default.",
-        "Path/line thresholds only allowed this attempt; they never imply safety.",
+        "Yui verified only the technical delta boundary; the Leader selected this mode.",
         `Previous accepted ReviewRound: ${previousRound.id}@${record.previousBaseCommit}`,
         `Previous acceptance summary: ${compact(previousRound.summary ?? previousRound.report ?? "")}`,
         ...(round.taskCandidate?.projects.map((project) => {
@@ -187,15 +166,6 @@ function digestDiff(diffByProject) {
         .map(([projectId, diff]) => [projectId, diff]));
     return createHash("sha256").update(canonical).digest("hex");
 }
-/**
- * Extracts path-like evidence references from the previous Round's report.
- * Free-form evidence that is not a path is still passed to the Reviewer in
- * the dispatch context; only path-like entries drive the deterministic gate.
- */
-function extractEvidencePaths(round) {
-    return previousEvidenceReferences(round)
-        .filter((entry) => isPathLike(entry));
-}
 /** All path-like evidence references from Markdown or JSON Review reports. */
 function previousEvidenceReferences(round) {
     const report = round.report ?? "";
@@ -222,9 +192,8 @@ function extractDeclaredEvidence(report) {
 }
 /**
  * Reviewer reports intentionally accept clear Markdown or JSON without a
- * fixed schema. Extract conservative repo-relative path tokens from the full
- * preserved report so evidence overlap cannot be bypassed by presentation
- * format, nested JSON, Markdown links, backticks, or line-qualified paths.
+ * 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) ?? [];
@@ -244,11 +213,3 @@ function isPathLike(value) {
         return false;
     return value.includes("/") || /\.[A-Za-z0-9]{1,12}$/u.test(value);
 }
-function pathEvidenceMatches(evidencePath, changedFile) {
-    const normalizedEvidence = evidencePath.replace(/^\.\//u, "").replace(/\/+$/u, "");
-    const normalizedFile = changedFile.replace(/^\.\//u, "").replace(/\/+$/u, "");
-    if (normalizedEvidence === normalizedFile)
-        return true;
-    // A directory-level evidence reference covers every file under it.
-    return normalizedFile.startsWith(`${normalizedEvidence}/`);
-}

package/dist/review/reviewAcceptance.js

@@ -0,0 +1,26 @@
+import { isSemanticReviewRound } from "./reviewOutcomeClassifier.js";
+/**
+ * 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.
+ */
+export function isAcceptedTaskReviewBaseline(store, round) {
+    return isAcceptedTaskReviewBaselineFromEvidence(round, store);
+}
+/** Pure evidence form shared by read-only projections and mutation paths. */
+export function isAcceptedTaskReviewBaselineFromEvidence(round, evidence) {
+    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")
+        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")));
+}

package/dist/review/reviewConfig.js

@@ -6,11 +6,6 @@ export const REVIEW_TRIGGERS = ["always", "leader", "final"];
  * Task completion closed on undispositioned open P1/P2 findings.
  */
 export const REVIEW_FINDING_LEDGER_MODES = ["shadow", "enforce"];
-/** Issue 07: delta-recheck is opt-in per Project review policy. */
-export const REVIEW_DELTA_RECHECK_MODES = ["enabled", "disabled"];
-/** Issue 07: conservative defaults for whether a delta attempt is allowed. */
-export const DEFAULT_DELTA_RECHECK_MAX_CHANGED_LINES = 200;
-export const DEFAULT_DELTA_RECHECK_MAX_CHANGED_FILES = 5;
 export function validateReviewConfig(config) {
     requireIdentity(config.roleName, "Review Role");
     if (!REVIEW_TRIGGERS.includes(config.trigger)) {
@@ -20,31 +15,5 @@ export function validateReviewConfig(config) {
         && !REVIEW_FINDING_LEDGER_MODES.includes(config.findingLedger)) {
         throw new Error(`Review finding ledger mode is invalid: ${String(config.findingLedger)}.`);
     }
-    if (config.deltaRecheck !== undefined
-        && !REVIEW_DELTA_RECHECK_MODES.includes(config.deltaRecheck)) {
-        throw new Error(`Review delta-recheck mode is invalid: ${String(config.deltaRecheck)}.`);
-    }
-    if (config.deltaRecheckMaxChangedLines !== undefined
-        && (!Number.isInteger(config.deltaRecheckMaxChangedLines)
-            || config.deltaRecheckMaxChangedLines < 1)) {
-        throw new Error("Review delta-recheck max changed lines must be a positive integer.");
-    }
-    if (config.deltaRecheckMaxChangedFiles !== undefined
-        && (!Number.isInteger(config.deltaRecheckMaxChangedFiles)
-            || config.deltaRecheckMaxChangedFiles < 1)) {
-        throw new Error("Review delta-recheck max changed files must be a positive integer.");
-    }
     return config;
 }
-/** Issue 07: resolves the delta-recheck policy; absent config defaults to disabled. */
-export function deltaRecheckEnabled(config) {
-    return config?.deltaRecheck === "enabled";
-}
-/** Issue 07: resolves the line threshold with its conservative default. */
-export function deltaRecheckMaxChangedLines(config) {
-    return config?.deltaRecheckMaxChangedLines ?? DEFAULT_DELTA_RECHECK_MAX_CHANGED_LINES;
-}
-/** Issue 07: resolves the file threshold with its conservative default. */
-export function deltaRecheckMaxChangedFiles(config) {
-    return config?.deltaRecheckMaxChangedFiles ?? DEFAULT_DELTA_RECHECK_MAX_CHANGED_FILES;
-}

package/dist/review/reviewDecision.js

@@ -0,0 +1,113 @@
+import { isDeepStrictEqual } from "node:util";
+import { isAcceptedTaskReviewBaseline } 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, runs, rounds, reviewConfig, currentCandidate } = input;
+    const taskRounds = rounds.filter((round) => (round.scope ?? "work-item") === "task");
+    const accepted = [...taskRounds]
+        .filter((round) => isAcceptedTaskReviewBaseline(store, round))
+        .sort(compareRoundIdentity)
+        .at(-1);
+    const latestAcceptedBaseline = accepted?.taskCandidate === undefined
+        ? null
+        : {
+            reviewRoundId: accepted.id,
+            reviewerRoleName: accepted.reviewerRoleName,
+            candidate: accepted.taskCandidate,
+            relationToCurrent: candidateRelation(accepted.taskCandidate, currentCandidate)
+        };
+    const activeReviews = taskRounds
+        .filter((round) => (round.status === "pending" || round.status === "running"))
+        .map((round) => {
+        const activeRun = runs.find((run) => (run.status === "active" && run.reviewRoundId === round.id));
+        const workspaceRoot = round.workspace?.root ?? activeRun?.workspace?.root;
+        return {
+            reviewRoundId: round.id,
+            reviewerRoleName: round.reviewerRoleName,
+            mode: round.deltaRecheck === undefined ? "full" : "delta-recheck",
+            status: round.status,
+            ...(activeRun === undefined ? {} : { activeRunId: activeRun.id }),
+            startedAt: activeRun?.createdAt ?? round.createdAt,
+            frozenCandidate: round.taskCandidate ?? null,
+            candidateRelation: candidateRelation(round.taskCandidate ?? null, currentCandidate),
+            ...(workspaceRoot === undefined ? {} : { workspaceRoot })
+        };
+    });
+    const reviewerNames = [...new Set([
+            ...(reviewConfig === null ? [] : [reviewConfig.roleName]),
+            ...taskRounds.flatMap((round) => [
+                round.reviewerRoleName,
+                ...(round.executionGroup?.lanes.map(({ roleName }) => roleName) ?? [])
+            ])
+        ])].sort();
+    const reviewers = reviewerNames.map((reviewerRoleName) => {
+        const role = roles.find(({ name }) => name === reviewerRoleName);
+        if (role === undefined && store.getGlobalRole(reviewerRoleName) === null) {
+            return {
+                reviewerRoleName,
+                status: "unavailable",
+                retryable: false
+            };
+        }
+        const availability = projectReviewerAvailability(store, task.id, reviewerRoleName);
+        if (availability.kind === "available") {
+            return {
+                reviewerRoleName,
+                status: "available",
+                retryable: true
+            };
+        }
+        return {
+            reviewerRoleName,
+            status: "busy",
+            phase: availability.phase,
+            ...(availability.activeRunId === undefined
+                ? {}
+                : { activeRunId: availability.activeRunId }),
+            ...(availability.activeReviewRoundId === undefined
+                ? {}
+                : { activeReviewRoundId: availability.activeReviewRoundId }),
+            ...(availability.startedAt === undefined
+                ? {}
+                : { startedAt: availability.startedAt }),
+            retryable: true,
+            retryAfterSeconds: availability.retryAfterSeconds
+        };
+    });
+    const delta = latestAcceptedBaseline === null
+        ? {
+            technicalAvailability: "unavailable",
+            reason: "No accepted Task-final Review baseline is available."
+        }
+        : latestAcceptedBaseline.relationToCurrent === "exact"
+            ? {
+                technicalAvailability: "unavailable",
+                reason: "The accepted baseline already covers the current durable candidate; there is no delta to recheck."
+            }
+            : currentCandidate === null
+                ? {
+                    technicalAvailability: "unavailable",
+                    reason: "The current durable Task candidate is unavailable."
+                }
+                : {
+                    technicalAvailability: "requires-preflight",
+                    reason: "An accepted baseline exists; Git ancestry, scope and exact diff must be verified."
+                };
+    return {
+        currentCandidate,
+        activeReviews,
+        reviewers,
+        latestAcceptedBaseline,
+        delta
+    };
+}
+function candidateRelation(candidate, current) {
+    if (candidate === null || current === null)
+        return "unavailable";
+    return isDeepStrictEqual(candidate, current) ? "exact" : "requires-preflight";
+}
+function compareRoundIdentity(left, right) {
+    return left.createdAt.localeCompare(right.createdAt)
+        || left.id.localeCompare(right.id, undefined, { numeric: true });
+}