@zq-silk/yui 0.14.0 → 0.14.2

package/dist/review/reviewOutcomeClassifier.js

@@ -1,255 +0,0 @@
-import { isTaskRecordRetired, operationalTaskRecords } from "../task/taskRecordRetirement.js";
-const INFRA_SIGNATURES = [
-    { kind: "session-not-stopped", pattern: /session must be stopped before workspace migration/iu },
-    { kind: "turn-start", pattern: /role turn could not start|could not start (?:the )?(?:reviewer|role) turn/iu },
-    { kind: "storage-lock", pattern: /\.state\.lock|state lock|lock timeout|storage lock/iu },
-    { kind: "tmux-exit", pattern: /tmux[^\n]{0,80}(?:exited|exit|died|vanished)|pane (?:exited|died)/iu },
-    { kind: "turn-identity", pattern: /wrong turn id|unknown turn id|turn id (?:is )?(?:invalid|unknown|mismatch)/iu },
-    { kind: "policy", pattern: /cyber_?policy|policy denial|permission denied by policy/iu },
-    { kind: "baseline-contamination", pattern: /cross[-\s]?baseline|baseline pollution|contaminated baseline|wrong base sha/iu },
-    { kind: "context-load", pattern: /(?:turn )?(?:context|context pack) load (?:failed|unavailable|unauthorized|stale|mismatched|malformed)/iu },
-    { kind: "workspace-binding", pattern: /workspace is not the durable owner|workspace-binding failure/iu }
-];
-/** Classify one terminal Round without rewriting it. */
-export function classifyReviewRoundOutcome(round, evidence) {
-    if (round.status !== "completed" && round.status !== "failed")
-        return null;
-    if (evidence !== undefined && round.reviewerTurnId !== undefined
-        && isTaskRecordRetired(evidence.listEvents(round.taskId), "turn", round.reviewerTurnId)) {
-        return {
-            kind: "non-semantic",
-            infraKind: "turn-identity",
-            reason: `Reviewer Turn ${round.reviewerTurnId} was retired from operational evidence.`
-        };
-    }
-    const infraKind = classifyInfraKind(`${round.summary ?? ""}\n${round.report ?? ""}`);
-    if (round.status === "failed") {
-        const semanticEvidence = failedRoundSemanticEvidence(round, evidence);
-        return semanticEvidence === null
-            ? {
-                kind: "non-semantic",
-                infraKind,
-                reason: "Failed Review execution carries no semantic report evidence."
-            }
-            : {
-                kind: "ambiguous",
-                infraKind,
-                reason: semanticEvidence
-            };
-    }
-    if (!explicitCompletedReviewInfrastructureFailure(round.summary ?? "", round)) {
-        return { kind: "semantic", reason: "Reviewer delivered a terminal report." };
-    }
-    if (evidence === undefined) {
-        return {
-            kind: "ambiguous",
-            infraKind,
-            reason: "Completed Round claims an infrastructure failure but corroborating Turn/Event evidence was not supplied."
-        };
-    }
-    const corroborationFailure = completedInfrastructureCorroborationFailure(round, evidence);
-    return corroborationFailure === null
-        ? {
-            kind: "non-semantic",
-            infraKind,
-            reason: "Completed Round and Turn agree on an explicit pre-review infrastructure failure."
-        }
-        : {
-            kind: "ambiguous",
-            infraKind,
-            reason: corroborationFailure
-        };
-}
-/** True only when a Round contains semantic Reviewer evidence. */
-export function isSemanticReviewRound(round, evidence) {
-    return classifyReviewRoundOutcome(round, evidence)?.kind === "semantic";
-}
-function classifyInfraKind(text) {
-    return INFRA_SIGNATURES.find(({ pattern }) => pattern.test(text))?.kind ?? "other-infra";
-}
-function failedRoundSemanticEvidence(round, evidence) {
-    if ((round.checks ?? []).length > 0)
-        return "Failed Round records review checks.";
-    if (round.evidenceCommit !== undefined)
-        return "Failed Round records a review evidence commit.";
-    if (round.deltaRecheck?.disposition !== undefined || round.deltaRecheck?.reasoning !== undefined) {
-        return "Failed Round records a semantic delta-recheck disposition.";
-    }
-    if (round.report !== round.summary)
-        return "Failed Round stores a report distinct from its terminal summary.";
-    if (runtimeFailureSummaryHasReviewerOutput(round.report ?? "")) {
-        return "Failed Round stores non-empty Reviewer output in its runtime failure summary.";
-    }
-    if (looksLikeStructuredReviewReport(round.report ?? "")) {
-        return "Failed Round stores a structured Reviewer report.";
-    }
-    const semanticLane = (round.executionGroup?.lanes ?? []).find((lane) => ((lane.result?.checks ?? []).length > 0
-        || (lane.result?.findings ?? []).length > 0
-        || (lane.result?.evidence ?? []).length > 0
-        || lane.result?.evidenceCommit !== undefined
-        || lane.result?.gitSnapshot !== undefined
-        || lane.status === "completed"));
-    if (semanticLane !== undefined)
-        return `Reviewer Lane ${semanticLane.id} delivered semantic evidence.`;
-    if (evidence !== undefined) {
-        const events = evidence.listEvents(round.taskId);
-        const reviewRun = operationalTaskRecords(evidence.listTurns(round.taskId), events, "turn").find((run) => (run.purpose === "review"
-            && run.reviewRoundId === round.id
-            && (run.status === "completed"
-                || runtimeFailureSummaryHasReviewerOutput(run.result?.output ?? ""))));
-        if (reviewRun !== undefined)
-            return `Reviewer Turn ${reviewRun.id} records Reviewer output.`;
-        const finding = evidence.listReviewFindings(round.taskId).find((entry) => (entry.firstReviewRoundId === round.id || entry.lastReviewRoundId === round.id));
-        if (finding !== undefined)
-            return `Review finding ${finding.id} references the Round.`;
-        const completion = events.find((event) => (event.type === "review.completed" && event.payload.reviewRoundId === round.id));
-        if (completion !== undefined)
-            return `Review completion Event ${completion.id} exists.`;
-    }
-    return null;
-}
-function completedInfrastructureCorroborationFailure(round, store) {
-    if ((round.checks ?? []).length > 0)
-        return "Completed Round records review checks.";
-    if (round.evidenceCommit !== round.reviewBaseCommit) {
-        return "Completed Round lacks an exact frozen-head evidence commit.";
-    }
-    if (round.report !== round.summary) {
-        return "Completed Round stores a report distinct from its terminal summary.";
-    }
-    if (runtimeFailureSummaryHasReviewerOutput(round.report ?? "")) {
-        return "Completed Round stores non-empty Reviewer output in its runtime failure summary.";
-    }
-    if (round.deltaRecheck?.disposition !== undefined || round.deltaRecheck?.reasoning !== undefined) {
-        return "Completed Round records a semantic delta-recheck disposition.";
-    }
-    if (looksLikeStructuredReviewReport(round.report ?? "")) {
-        return "Completed Round stores a structured Reviewer report.";
-    }
-    for (const lane of round.executionGroup?.lanes ?? []) {
-        if (lane.status === "pending" || lane.status === "running") {
-            return `Reviewer Lane ${lane.id} is still active.`;
-        }
-        if ((lane.result?.checks ?? []).length > 0
-            || (lane.result?.findings ?? []).length > 0
-            || (lane.result?.evidence ?? []).length > 0
-            || (lane.result?.evidenceCommit !== undefined
-                && lane.result.evidenceCommit !== round.reviewBaseCommit)
-            || lane.result?.gitSnapshot !== undefined) {
-            return `Reviewer Lane ${lane.id} delivered semantic evidence.`;
-        }
-        if (lane.status === "completed") {
-            if (lane.result === undefined
-                || lane.result.summary !== round.summary
-                || lane.result.report !== round.report
-                || lane.result.evidenceCommit !== round.reviewBaseCommit) {
-                return `Reviewer Lane ${lane.id} output is absent or differs from the Round.`;
-            }
-        }
-        else {
-            return `Completed Round has non-completed Reviewer Lane ${lane.id}/${lane.status}.`;
-        }
-    }
-    const allEvents = store.listEvents(round.taskId);
-    const runs = operationalTaskRecords(store.listTurns(round.taskId), allEvents, "turn").filter((run) => (run.purpose === "review" && run.reviewRoundId === round.id));
-    const active = runs.find(({ status }) => status === "active");
-    if (active !== undefined)
-        return `Reviewer Turn ${active.id} is still active.`;
-    const output = runs.find((run) => (run.status === "failed" && runtimeFailureSummaryHasReviewerOutput(run.result?.output ?? "")));
-    if (output !== undefined)
-        return `Reviewer Turn ${output.id} records Reviewer output.`;
-    const completed = runs.filter(({ status }) => status === "completed");
-    if (round.reviewerTurnId === undefined
-        || completed.length !== 1
-        || completed[0].id !== round.reviewerTurnId) {
-        return "Completed Round lacks one exact completed Reviewer Turn.";
-    }
-    const run = completed[0];
-    if (run.roleName !== round.reviewerRoleName
-        || run.result?.output !== round.summary) {
-        return `Reviewer Turn ${run.id} does not match the non-semantic Round result.`;
-    }
-    const finding = store.listReviewFindings(round.taskId).find((entry) => (entry.firstReviewRoundId === round.id || entry.lastReviewRoundId === round.id));
-    if (finding !== undefined)
-        return `Review finding ${finding.id} references the Round.`;
-    const events = allEvents.filter((event) => (event.type === "review.completed" && event.payload.reviewRoundId === round.id));
-    if (events.length !== 1)
-        return "Completed Round lacks one exact completion Event.";
-    const event = events[0];
-    if (event.payload.workItemId !== round.workItemId
-        || event.payload.candidateId !== round.candidateId
-        || event.payload.reviewBaseCommit !== round.reviewBaseCommit
-        || event.payload.evidenceCommit !== round.reviewBaseCommit
-        || event.payload.checks !== "none") {
-        return `Review completion Event ${event.id} carries mismatched or semantic evidence.`;
-    }
-    return null;
-}
-function explicitCompletedReviewInfrastructureFailure(summary, round) {
-    if (exactCompletedReviewInfrastructureFailureReport(summary))
-        return true;
-    const report = summary.trim();
-    if (report === `Role Turn workspace is not the durable owner: ${round.taskId}/${round.reviewerRoleName}.`
-        || (round.reviewerTurnId !== undefined
-            && report === `Review Turn workspace is not the durable owner: ${round.reviewerTurnId}.`)) {
-        return true;
-    }
-    return /^(?:Turn )?(?:Context|Context Pack) load (?:failed|unavailable|unauthorized|stale|mismatched|malformed)(?:: (?:failure|mismatch|unavailable|unauthorized|stale|mismatched|malformed))?\.?$/iu
-        .test(report);
-}
-function exactCompletedReviewInfrastructureFailureReport(summary) {
-    const lines = summary.trim().split(/\r?\n/u);
-    const envelope = [
-        /^# Review result: (?:context-load|workspace-binding) failure$/u,
-        /^$/u,
-        /^The assigned Turn context could not be safely matched to this native session, so no candidate review was performed\.$/u,
-        /^$/u,
-        /^- Turn: `[^`\r\n]+`$/u,
-        /^- ReviewRound: `[^`\r\n]+`$/u,
-        /^- Review base commit: `[0-9a-f]{40}`$/u,
-        /^- Frozen target: `[^`\r\n]+`$/u,
-        /^- Authorized workspace from the exact Context Pack: `[^`\r\n]+`$/u,
-        /^- Session-attached workspace: `[^`\r\n]+`$/u,
-        /^- Verification: both paths resolve distinctly and have different filesystem inodes \(`[^`\r\n]+` vs `[^`\r\n]+`\)\.$/u,
-        /^$/u,
-        /^## Findings$/u,
-        /^$/u,
-        /^- Verified-fixed findings: none; review did not start\.$/u,
-        /^- New findings: none; candidate sources were intentionally not inspected\.$/u,
-        /^- Accepted risks: none accepted\.$/u,
-        /^- Residual verification gaps: the complete frozen diff, changed control-flow paths, callers, data-integrity behavior, and required deterministic checks remain unreviewed because the Review workspace binding is mismatched\.$/u,
-        /^$/u,
-        /^## Checks actually run$/u,
-        /^$/u,
-        /^- Exact Context API load: passed for Task\/Turn\/Role\/purpose\/subject\/snapshot\/adapter\.$/u,
-        /^- Workspace binding verification: failed\.$/u,
-        /^- Candidate build\/tests\/package checks: not run\.$/u,
-        /^- Real-provider E2E: not run and not authorized\.$/u,
-        /^$/u,
-        /^## Required next action$/u,
-        /^$/u,
-        /^Attach the native Reviewer session to the exact workspace recorded by the Context Pack, or issue a fresh internally consistent Review Turn\/Context Pack\. Then perform the complete bounded Task-final review at the frozen head\.$/u
-    ];
-    return lines.length === envelope.length
-        && envelope.every((pattern, index) => pattern.test(lines[index]));
-}
-function runtimeFailureSummaryHasReviewerOutput(summary) {
-    const output = /(?:^|\n)last_assistant_message:[ \t]*([\s\S]*)$/u.exec(summary)?.[1];
-    return output !== undefined && output.trim().length > 0;
-}
-function looksLikeStructuredReviewReport(report) {
-    let parsed;
-    try {
-        parsed = JSON.parse(report);
-    }
-    catch {
-        return false;
-    }
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
-        return false;
-    const record = parsed;
-    return [
-        "summary", "report", "checks", "findings", "evidence", "evidenceCommit",
-        "deltaDisposition", "deltaReasoning"
-    ].some((key) => Object.hasOwn(record, key));
-}

package/dist/scheduler/resourceQueueProjection.js

@@ -1,71 +0,0 @@
-import { currentWorkItemExecutionGroup } from "../workItem/workItem.js";
-import { executionStageSpendClosed, observedExecutionResourceUsage, projectExecutionStageResources } from "../execution/resourceBroker.js";
-/** Exact durable Broker queue used by resource admission. */
-export function projectQueuedResourceLaneIdentities(store, now) {
-    return store.listActiveTaskIds().flatMap((taskId) => {
-        const taskTurns = store.listTurns(taskId);
-        const taskEvents = store.listEvents(taskId);
-        const workItemLanes = store.listWorkItems(taskId).flatMap((item) => {
-            if (item.status !== "running")
-                return [];
-            const group = currentWorkItemExecutionGroup(item);
-            if (group === undefined || group.resolution !== undefined)
-                return [];
-            if (group.stage !== undefined) {
-                const resources = projectExecutionStageResources({
-                    group,
-                    stageGroups: item.executionGroups,
-                    usage: observedExecutionResourceUsage({
-                        group,
-                        stageGroups: item.executionGroups,
-                        turns: taskTurns,
-                        events: taskEvents
-                    }),
-                    now
-                });
-                if (executionStageSpendClosed(resources))
-                    return [];
-            }
-            return group.lanes.flatMap((lane) => {
-                if (lane.status !== "pending"
-                    || lane.effective === undefined
-                    || lane.turnId !== undefined)
-                    return [];
-                return [{
-                        taskId,
-                        workItemId: item.id,
-                        executionGroupId: group.id,
-                        executionLaneId: lane.id,
-                        providerId: lane.effective.adapterId,
-                        agentId: lane.effective.agentId,
-                        ...(lane.effective.model === undefined ? {} : { model: lane.effective.model }),
-                        requestedAt: lane.updatedAt
-                    }];
-            });
-        });
-        const reviewLanes = store.listReviewRounds(taskId).flatMap((round) => {
-            if (round.status !== "pending" && round.status !== "running")
-                return [];
-            const group = round.executionGroup;
-            if (group === undefined || group.resolution !== undefined)
-                return [];
-            return group.lanes.flatMap((lane) => {
-                if (lane.status !== "pending"
-                    || lane.effective === undefined
-                    || lane.turnId !== undefined)
-                    return [];
-                return [{
-                        taskId,
-                        ...(round.workItemId === undefined ? {} : { workItemId: round.workItemId }),
-                        executionGroupId: group.id,
-                        executionLaneId: lane.id,
-                        providerId: lane.effective.adapterId,
-                        agentId: lane.effective.agentId,
-                        ...(lane.effective.model === undefined ? {} : { model: lane.effective.model }),
-                        requestedAt: lane.updatedAt
-                    }];
-            });
-        });
-        return [...workItemLanes, ...reviewLanes];
-    });
-}

package/dist/task/repairWave.js

@@ -1,150 +0,0 @@
-const SEVERITY_RANK = {
-    p1: 5,
-    critical: 4,
-    high: 3,
-    p2: 2,
-    medium: 1,
-    low: 0
-};
-const PATH_PATTERN = /(?:[\w.-]+\/)+[\w.-]+\.(?:ts|tsx|js|mjs|cjs|json|md|py|sh|yml|yaml|toml|css|html)(?::\d+)?/gu;
-/**
- * Extract open findings from a ReviewRound. Structured ExecutionFindings on
- * the Review's ExecutionGroup lanes win; when none exist, fall back to
- * parsing P1/P2 lines from the Review report text.
- */
-export function extractReviewFindings(round) {
-    const structured = (round.executionGroup?.lanes ?? [])
-        .flatMap((lane) => lane.result?.findings ?? [])
-        .filter((finding) => finding.status === "open");
-    if (structured.length > 0) {
-        return structured.map((finding) => ({
-            id: finding.id,
-            severity: finding.severity,
-            summary: finding.summary,
-            paths: extractPaths(finding.summary),
-            source: "structured"
-        }));
-    }
-    return parseReportFindings(round.report ?? "");
-}
-export function planRepairWave(reviewRoundId, findings, strategy = "consolidated") {
-    if (findings.length === 0) {
-        return { reviewRoundId, openFindingCount: 0, groups: [] };
-    }
-    if (strategy === "consolidated") {
-        const ordered = [...findings].sort((left, right) => (left.id.localeCompare(right.id, undefined, { numeric: true })));
-        return {
-            reviewRoundId,
-            openFindingCount: findings.length,
-            groups: [{
-                    id: "repair-1",
-                    findingIds: ordered.map(({ id }) => id),
-                    paths: [...new Set(ordered.flatMap(({ paths }) => paths))].sort(),
-                    reason: "Consolidated by default to minimize repair, integration, and review churn"
-                }]
-        };
-    }
-    const parent = new Array(findings.length).fill(0).map((_, index) => index);
-    const find = (index) => {
-        let current = index;
-        while (parent[current] !== current)
-            current = parent[current];
-        return current;
-    };
-    const union = (left, right) => {
-        const leftRoot = find(left);
-        const rightRoot = find(right);
-        if (leftRoot !== rightRoot)
-            parent[rightRoot] = leftRoot;
-    };
-    const unpathable = [];
-    for (let index = 0; index < findings.length; index += 1) {
-        if (findings[index].paths.length === 0)
-            unpathable.push(index);
-    }
-    // Unprovable findings merge together: the planner cannot prove they are
-    // disjoint from anything, so serializing them is the fail-closed choice.
-    for (let index = 1; index < unpathable.length; index += 1) {
-        union(unpathable[0], unpathable[index]);
-    }
-    for (let left = 0; left < findings.length; left += 1) {
-        for (let right = left + 1; right < findings.length; right += 1) {
-            if (sharePath(findings[left], findings[right]))
-                union(left, right);
-        }
-    }
-    const byRoot = new Map();
-    for (let index = 0; index < findings.length; index += 1) {
-        const root = find(index);
-        byRoot.set(root, [...(byRoot.get(root) ?? []), index]);
-    }
-    const groups = [...byRoot.values()]
-        .map((members, position) => {
-        const waveFindings = members.map((index) => findings[index]);
-        const paths = [...new Set(waveFindings.flatMap((finding) => finding.paths))]
-            .sort();
-        const reason = paths.length === 0
-            ? "No parseable paths; merged conservatively"
-            : waveFindings.length === 1
-                ? `Distinct path ${paths[0]}; parallel-safe`
-                : `Shared path(s) ${paths.join(", ")}; merged`;
-        return {
-            id: `repair-${position + 1}`,
-            findingIds: waveFindings.map((finding) => finding.id),
-            paths,
-            reason
-        };
-    })
-        .sort((left, right) => {
-        const leftRank = Math.max(...left.findingIds.map((id) => SEVERITY_RANK[findings.find((finding) => finding.id === id).severity]));
-        const rightRank = Math.max(...right.findingIds.map((id) => SEVERITY_RANK[findings.find((finding) => finding.id === id).severity]));
-        if (leftRank !== rightRank)
-            return rightRank - leftRank;
-        return left.id.localeCompare(right.id, undefined, { numeric: true });
-    })
-        .map((group, index) => ({ ...group, id: `repair-${index + 1}` }));
-    return {
-        reviewRoundId,
-        openFindingCount: findings.length,
-        groups
-    };
-}
-function sharePath(left, right) {
-    if (left.paths.length === 0 || right.paths.length === 0)
-        return false;
-    const rightPaths = new Set(right.paths.map(filePart));
-    return left.paths.some((path) => rightPaths.has(filePart(path)));
-}
-function filePart(path) {
-    return path.split(":")[0];
-}
-export function extractPaths(text) {
-    const matches = text.match(PATH_PATTERN) ?? [];
-    return [...new Set(matches)].sort();
-}
-/**
- * Fallback finding extraction for Reviews without structured findings: parse
- * P1/P2 lines from the report body. A line like "P1: src/foo.ts:12 ..." or
- * "- P2 src/bar.ts ..." becomes one finding.
- */
-export function parseReportFindings(report) {
-    const findings = [];
-    const lines = report.split(/\r?\n/u);
-    let index = 0;
-    for (const line of lines) {
-        const match = /^\s*(?:[-*]\s*)?(P[12])\b[:\s-]+(.+)$/u.exec(line);
-        if (match === null)
-            continue;
-        index += 1;
-        const severity = match[1].toLowerCase();
-        const summary = match[2].trim();
-        findings.push({
-            id: `report-p${severity === "p1" ? 1 : 2}-${index}`,
-            severity,
-            summary,
-            paths: extractPaths(summary),
-            source: "report"
-        });
-    }
-    return findings;
-}