@zq-silk/yui 0.15.12 → 0.16.0

package/dist/release/fakeReleasePorts.js

@@ -1,55 +0,0 @@
-/**
- * The deterministic double for every external system (GitHub, npm, Home,
- * Controller). No real network, process, or filesystem side effect: the
- * engine's at-most-once and recovery guarantees are proven against this.
- */
-export function createFakeReleasePorts(scripts) {
-    const counters = new Map();
-    for (const stepId of Object.keys(scripts)) {
-        counters.set(stepId, { execute: 0, query: 0, keys: [] });
-    }
-    const tally = (stepId) => {
-        let calls = counters.get(stepId);
-        if (calls === undefined) {
-            calls = { execute: 0, query: 0, keys: [] };
-            counters.set(stepId, calls);
-        }
-        return calls;
-    };
-    const next = (queue, stepId, kind, consumed) => {
-        if (queue === undefined || consumed >= queue.length) {
-            throw new Error(`Fake release ports: no more scripted ${kind} outcomes for step ${stepId}.`);
-        }
-        const entry = queue[consumed];
-        return typeof entry === "function" ? entry() : entry;
-    };
-    return {
-        async executeStep(input) {
-            const calls = tally(input.step.id);
-            const effect = next(scripts[input.step.id]?.execute, input.step.id, "execute", calls.execute);
-            calls.execute += 1;
-            calls.keys.push(input.idempotencyKey);
-            return effect;
-        },
-        async queryStepEffect(input) {
-            const calls = tally(input.step.id);
-            const query = next(scripts[input.step.id]?.query, input.step.id, "query", calls.query);
-            calls.query += 1;
-            return query;
-        },
-        calls(stepId) {
-            const calls = tally(stepId);
-            return { execute: calls.execute, query: calls.query, keys: Object.freeze([...calls.keys]) };
-        },
-        exhausted() {
-            for (const [stepId, script] of Object.entries(scripts)) {
-                const calls = counters.get(stepId);
-                if ((script.execute?.length ?? 0) !== calls.execute)
-                    return false;
-                if ((script.query?.length ?? 0) !== calls.query)
-                    return false;
-            }
-            return true;
-        }
-    };
-}

package/dist/runtime/sessionOwnerRegistry.js

@@ -1,137 +0,0 @@
-import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { createSessionOwnerIdentity, sessionOwnerProcessKey } from "./sessionOwnerIdentity.js";
-/**
- * Durable, enumerable physical owner records for runtime Sessions.
- *
- * One JSON file per process identity under `<home>/runtime/session-owners/`. The
- * directory is runtime state (like the tmux socket), not aggregate domain
- * state, so it needs no schema migration; it survives a Controller restart and
- * stays enumerable after the durable Session map or history is cleared, which
- * is exactly the gap the audit proved (durable pointers empty, physical
- * processes still live).
- */
-export class FileSessionOwnerRegistry {
-    #directory;
-    constructor(home) {
-        this.#directory = join(resolve(home), "runtime", "session-owners");
-    }
-    get directory() {
-        return this.#directory;
-    }
-    /** Atomically records (or replaces) one Session's owner identity. */
-    record(identity) {
-        mkdirSync(this.#directory, { recursive: true, mode: 0o700 });
-        const target = this.#path(sessionOwnerProcessKey(identity));
-        const temporary = `${target}.tmp-${process.pid}`;
-        writeFileSync(temporary, JSON.stringify(identity, null, 2) + "\n", { mode: 0o600 });
-        renameSync(temporary, target);
-    }
-    get(processKey) {
-        if (!isSafeProcessKey(processKey))
-            return null;
-        try {
-            return parseOwnerRecord(readFileSync(this.#path(processKey), "utf8"));
-        }
-        catch {
-            return null;
-        }
-    }
-    list() {
-        let entries;
-        try {
-            entries = readdirSync(this.#directory, { encoding: "utf8" });
-        }
-        catch {
-            return [];
-        }
-        const records = [];
-        for (const entry of entries) {
-            if (!entry.endsWith(".json"))
-                continue;
-            try {
-                records.push(parseOwnerRecord(readFileSync(join(this.#directory, entry), "utf8")));
-            }
-            catch {
-                // A malformed record must not hide the exact candidates beside it.
-            }
-        }
-        records.sort((left, right) => left.recordedAt.localeCompare(right.recordedAt));
-        return records;
-    }
-    listForOwner(owner) {
-        return this.list().filter((record) => (record.owner.scope === owner.scope
-            && (owner.scope === "global"
-                || record.owner.taskId === owner.taskId)
-            && record.owner.roleName === owner.roleName));
-    }
-    /** Removes a record whose physical resources were proven absent. */
-    remove(processKey) {
-        if (!isSafeProcessKey(processKey))
-            return;
-        try {
-            rmSync(this.#path(processKey), { force: true });
-        }
-        catch {
-            // A stale record is harmless: reconciliation re-verifies physical
-            // identity before acting on it.
-        }
-    }
-    exists() {
-        return existsSync(this.#directory);
-    }
-    #path(processKey) {
-        if (!isSafeProcessKey(processKey))
-            throw new Error("Invalid process key.");
-        return join(this.#directory, `${processKey}.json`);
-    }
-}
-function isSafeProcessKey(processKey) {
-    return /^[1-9][0-9]*-[0-9]+$/u.test(processKey);
-}
-function parseOwnerRecord(raw) {
-    const parsed = JSON.parse(raw);
-    if (typeof parsed !== "object" || parsed === null) {
-        throw new Error("Session owner record is invalid.");
-    }
-    const record = parsed;
-    const owner = record.owner;
-    const tmux = record.tmux;
-    const providerRoot = record.providerRoot;
-    if (!["launch-env", "pane-pid", "owned-child"].includes(String(providerRoot.attribution))) {
-        throw new Error("Session owner process attribution is invalid.");
-    }
-    return createSessionOwnerIdentity({
-        owner: {
-            scope: owner.scope === "global" ? "global" : "task",
-            ...(owner.taskId === undefined ? {} : { taskId: String(owner.taskId) }),
-            roleName: String(owner.roleName)
-        },
-        agentId: String(record.agentId),
-        adapterId: String(record.adapterId),
-        ...(record.nativeSessionId === undefined
-            ? {}
-            : { nativeSessionId: String(record.nativeSessionId) }),
-        tmux: {
-            serverName: String(tmux.serverName),
-            socketPath: String(tmux.socketPath),
-            sessionName: String(tmux.sessionName),
-            windowName: String(tmux.windowName),
-            ...(tmux.panePid === undefined ? {} : { panePid: Number(tmux.panePid) })
-        },
-        providerRoot: {
-            pid: Number(providerRoot.pid),
-            startIdentity: String(providerRoot.startIdentity),
-            ...(providerRoot.processGroupId === undefined
-                ? {}
-                : { processGroupId: Number(providerRoot.processGroupId) }),
-            ...(providerRoot.processSessionId === undefined
-                ? {}
-                : { processSessionId: Number(providerRoot.processSessionId) }),
-            attribution: providerRoot.attribution === "pane-pid" ? "pane-pid"
-                : providerRoot.attribution === "owned-child" ? "owned-child" : "launch-env"
-        },
-        ...(record.runtimeRoot === undefined ? {} : { runtimeRoot: String(record.runtimeRoot) }),
-        recordedAt: new Date(String(record.recordedAt))
-    });
-}

package/dist/task/deliveryGuard.js

@@ -1,226 +0,0 @@
-import { isCompletedTaskReviewEvidenceFromRuns } from "../review/reviewAcceptance.js";
-const OPEN_WORK_ITEM_STATUSES = new Set(["open"]);
-export function detectDeliveryDuplicates(facts, intent) {
-    switch (intent.kind) {
-        case "create-work-item":
-            return detectWorkItemDuplicates(facts, intent.scope);
-        case "integration-start":
-            return detectIntegrationDuplicates(facts, intent);
-        case "review-request":
-            return detectReviewDuplicates(facts, intent);
-        case "complete-task":
-            return detectCompleteDuplicates(facts);
-    }
-}
-/**
- * Apply the configured mode. `display` never interferes; `warn` reports every
- * match as a warning; `enforce` hard-blocks on exact evidence and warns on
- * suspected duplicates.
- */
-export function evaluateDeliveryGuard(duplicates, mode) {
-    if (mode === "display" || duplicates.length === 0) {
-        return { blocked: null, warnings: [] };
-    }
-    const exact = duplicates.filter((duplicate) => duplicate.severity === "exact");
-    const suspected = duplicates.filter((duplicate) => duplicate.severity === "suspected");
-    if (mode === "enforce" && exact.length > 0) {
-        return { blocked: exact[0], warnings: suspected };
-    }
-    return { blocked: null, warnings: [...exact, ...suspected] };
-}
-export function formatDeliveryDuplicate(duplicate) {
-    const refs = duplicate.refs.map((ref) => `${ref.kind} ${ref.id}`).join(", ");
-    const reuse = duplicate.reuseCommand === undefined
-        ? ""
-        : ` Existing proof: ${duplicate.reuseCommand}`;
-    return `${duplicate.severity === "exact" ? "Exact duplicate" : "Suspected duplicate"}: ${duplicate.reason} (${refs}).${reuse}`;
-}
-function detectWorkItemDuplicates(facts, scope) {
-    const wanted = normalizeScope(scope);
-    const duplicates = [];
-    for (const item of facts.workItems) {
-        const existing = normalizeScope({
-            title: item.title,
-            objective: item.objective,
-            acceptance: item.acceptance,
-            writeProjectIds: item.writeProjectIds
-        });
-        const sameScope = existing.title === wanted.title
-            && existing.objective === wanted.objective
-            && existing.acceptance === wanted.acceptance
-            && existing.writeProjectIds === wanted.writeProjectIds;
-        const ref = { kind: "work-item", id: item.id };
-        if (sameScope && OPEN_WORK_ITEM_STATUSES.has(item.status)) {
-            duplicates.push({
-                severity: "exact",
-                reason: `Work Item ${item.id} is already open with the identical scope`,
-                refs: [ref],
-                reuseCommand: `yui task work show ${facts.task.id}/${item.id}`
-            });
-            continue;
-        }
-        if (sameScope && item.status === "accepted") {
-            duplicates.push({
-                severity: "suspected",
-                reason: `Work Item ${item.id} already delivered the identical scope; re-creating it may be a duplicate successor`,
-                refs: [ref],
-                reuseCommand: `yui task work show ${facts.task.id}/${item.id}`
-            });
-            continue;
-        }
-        if (!sameScope
-            && OPEN_WORK_ITEM_STATUSES.has(item.status)
-            && existing.writeProjectIds === wanted.writeProjectIds
-            && wanted.writeProjectIds.length > 0
-            && overlap(existing.acceptance, wanted.acceptance)) {
-            duplicates.push({
-                severity: "suspected",
-                reason: `Open Work Item ${item.id} shares the same Project scope and acceptance lines`,
-                refs: [ref]
-            });
-        }
-    }
-    return duplicates;
-}
-function detectIntegrationDuplicates(facts, intent) {
-    const duplicates = [];
-    for (const attempt of facts.integrations) {
-        if (attempt.projectId !== intent.projectId)
-            continue;
-        const sameSource = attempt.source.kind === "work-item"
-            && attempt.source.workItemId === intent.workItemId
-            && attempt.source.resultCommit === intent.resultCommit;
-        const ref = { kind: "integration-attempt", id: attempt.id };
-        if (sameSource && attempt.status === "committed") {
-            duplicates.push({
-                severity: "exact",
-                reason: `Integration ${attempt.id} already committed this exact WorkItem result`,
-                refs: [ref],
-                reuseCommand: `yui task integration show ${facts.task.id}/${attempt.id}`
-            });
-            continue;
-        }
-        if (sameSource
-            && (attempt.status === "running" || attempt.status === "validating")) {
-            duplicates.push({
-                severity: "suspected",
-                reason: `Integration ${attempt.id} is already ${attempt.status} for this WorkItem result`,
-                refs: [ref],
-                reuseCommand: `yui task integration show ${facts.task.id}/${attempt.id}`
-            });
-        }
-    }
-    return duplicates;
-}
-function detectReviewDuplicates(facts, intent) {
-    const wanted = new Set(intent.taskCandidateCommits.map((commit) => commit.toLowerCase()));
-    const duplicates = [];
-    for (const round of facts.reviewRounds) {
-        if ((round.scope ?? "work-item") !== "task")
-            continue;
-        if (round.reviewerRoleName !== intent.reviewerRoleName)
-            continue;
-        const commits = new Set((round.taskCandidate?.projects ?? []).map((project) => project.commit.toLowerCase()));
-        const sameCandidate = commits.size === wanted.size
-            && commits.size > 0
-            && [...wanted].every((commit) => commits.has(commit));
-        if (!sameCandidate)
-            continue;
-        const ref = { kind: "review-round", id: round.id };
-        if (isCompletedTaskReviewEvidenceFromRuns(round, facts.reviewOutcomeEvidence?.runs ?? [])) {
-            duplicates.push({
-                severity: "exact",
-                reason: `Task-final Review ${round.id} already attests this exact head`,
-                refs: [ref]
-            });
-        }
-        else if (round.status === "pending" || round.status === "running") {
-            duplicates.push({
-                severity: "suspected",
-                reason: `Task-final Review ${round.id} is already ${round.status} for this exact head`,
-                refs: [ref]
-            });
-        }
-    }
-    return duplicates;
-}
-function detectCompleteDuplicates(facts) {
-    if (facts.task.status === "completed" || facts.task.status === "archived") {
-        return [{
-                severity: "exact",
-                reason: `Task ${facts.task.id} is already ${facts.task.status}`,
-                refs: [{ kind: "task", id: facts.task.id }]
-            }];
-    }
-    return [];
-}
-function normalizeScope(scope) {
-    return {
-        title: scope.title.trim().toLowerCase(),
-        objective: scope.objective.trim().toLowerCase(),
-        acceptance: [...scope.acceptance]
-            .map((line) => line.trim().toLowerCase())
-            .filter((line) => line.length > 0)
-            .sort()
-            .join("\n"),
-        writeProjectIds: [...scope.writeProjectIds].map((id) => id.trim()).sort().join(",")
-    };
-}
-function overlap(left, right) {
-    const rightLines = new Set(right.split("\n"));
-    return left.split("\n").some((line) => line.length > 0 && rightLines.has(line));
-}
-/**
- * Default number of consecutive completed Leader turns that must produce no
- * durable delivery change before the budget is exhausted.
- */
-export const DEFAULT_SEMANTIC_BUDGET_RUNS = 3;
-/**
- * Evaluate the semantic-progress budget from existing records only. The
- * budget is exhausted when the last `runs` Leader AgentRuns all completed and no
- * WorkItem/ChangeSet/Integration/Review record changed at or after the first
- * of those AgentRuns. Active execution (any AgentRun) never exhausts the budget: a
- * slow but progressing Worker or Leader is never interrupted.
- */
-export function evaluateSemanticBudget(facts, runs = DEFAULT_SEMANTIC_BUDGET_RUNS) {
-    if (facts.activeRuns.length > 0) {
-        return {
-            exhausted: false,
-            reason: "Active execution is in flight; the budget never interrupts a progressing AgentRun.",
-            evidence: facts.activeRuns.map((run) => run.id)
-        };
-    }
-    const recentLeaderRuns = facts.leaderRuns
-        .filter((run) => run.status === "completed")
-        .slice(-runs);
-    if (recentLeaderRuns.length < runs) {
-        return {
-            exhausted: false,
-            reason: `Fewer than ${runs} consecutive completed Leader runs.`,
-            evidence: recentLeaderRuns.map((run) => run.id)
-        };
-    }
-    const firstStartedAt = Math.min(...recentLeaderRuns.map((run) => Date.parse(run.createdAt)));
-    const changed = latestDeliveryChangeAt(facts);
-    if (changed >= firstStartedAt) {
-        return {
-            exhausted: false,
-            reason: "A delivery record changed during the recent Leader turns.",
-            evidence: recentLeaderRuns.map((run) => run.id)
-        };
-    }
-    return {
-        exhausted: true,
-        reason: `${runs} consecutive Leader runs produced no durable delivery change; record a diagnosis and wait for new facts instead of creating more records.`,
-        evidence: recentLeaderRuns.map((run) => run.id)
-    };
-}
-function latestDeliveryChangeAt(facts) {
-    const timestamps = [
-        ...facts.workItems.map((item) => Date.parse(item.updatedAt)),
-        ...facts.changeSets.map((changeSet) => Date.parse(changeSet.createdAt)),
-        ...facts.integrations.map((attempt) => Math.max(Date.parse(attempt.updatedAt), Date.parse(attempt.endedAt ?? attempt.updatedAt))),
-        ...facts.reviewRounds.map((round) => Math.max(Date.parse(round.createdAt), Date.parse(round.endedAt ?? round.createdAt)))
-    ];
-    return timestamps.length === 0 ? 0 : Math.max(...timestamps);
-}