@zq-silk/yui 0.6.0 → 0.6.2

package/dist/commands/taskIntegrationQueueCommands.js

@@ -0,0 +1,228 @@
+import { usageError } from "../errors/cliError.js";
+import { defaultTableWidth, renderTable } from "../output/table.js";
+import { resolveProject } from "../repository/project.js";
+import { NodeGitWorkspace } from "../repository/gitWorkspace.js";
+import { enqueueIntegrationQueueEntry, processIntegrationQueue, reconcileIntegrationQueueEntry, requeueIntegrationQueueEntry, supersedeIntegrationQueueEntry } from "../integration/integrationQueueService.js";
+import { taskActor } from "./taskActor.js";
+import { parseRepeatable } from "./taskIntegrationCommands.js";
+import { resolveTaskRecordReference } from "../task/taskRecordReference.js";
+/**
+ * `yui task integration queue` — the serialized merge queue.  Only terminal
+ * Candidates explicitly enqueued enter the queue; the queue never blocks
+ * parallel development, it orders exact-commit integration.
+ */
+export async function runTaskIntegrationQueueCommand(args, store, home, options = {}) {
+    const [command, ...rest] = args;
+    if (command === "enqueue")
+        return enqueue(rest, store, options, home);
+    if (command === "list")
+        return list(rest, store);
+    if (command === "show")
+        return show(rest, store, options.environment);
+    if (command === "process")
+        return process(rest, store, home, options);
+    if (command === "supersede")
+        return supersede(rest, store, options);
+    if (command === "requeue")
+        return requeue(rest, store, options);
+    if (command === "reconcile")
+        return reconcile(rest, store, options);
+    throw usageError(command === undefined
+        ? "Task Integration queue command is required."
+        : `Unknown command: task integration queue ${command}`);
+}
+async function enqueue(args, store, options, home) {
+    const usage = "Task Integration queue enqueue usage: yui task integration queue enqueue <task> --project <project> --change-set <id> [--target <ref>] [--check <command> ...].";
+    const parsed = parseRepeatable(args, new Set(["--check"]), new Set(["--project", "--change-set", "--target"]), usage);
+    if (parsed.positionals.length !== 1)
+        throw usageError(usage);
+    const task = requireActiveTask(store, parsed.positionals[0]);
+    requireLeader(options.environment, task.id);
+    const projectRef = parsed.one.get("--project");
+    const changeSetId = parsed.one.get("--change-set");
+    if (projectRef === undefined || changeSetId === undefined)
+        throw usageError(usage);
+    const projectId = resolveProjectId(store, projectRef);
+    const result = await enqueueIntegrationQueueEntry({
+        store,
+        taskId: task.id,
+        projectId,
+        changeSetId,
+        targetRef: parsed.one.get("--target"),
+        checkCommands: parsed.many.get("--check") ?? [],
+        now: options.now
+    });
+    const label = {
+        queued: "Enqueued",
+        "already-queued": "Already queued",
+        "already-committed": "Already committed",
+        converged: "Converged"
+    }[result.outcome];
+    return {
+        output: `${label} ${result.entry.changeSetId} as ${result.entry.id} (${result.entry.status})\n`,
+        data: result
+    };
+}
+function list(args, store) {
+    const usage = "Task Integration queue list usage: yui task integration queue list <task> [--project <project>].";
+    const parsed = parseRepeatable(args, new Set(), new Set(["--project"]), usage);
+    if (parsed.positionals.length !== 1)
+        throw usageError(usage);
+    const task = requireActiveTask(store, parsed.positionals[0]);
+    const projectRef = parsed.one.get("--project");
+    const projectId = projectRef === undefined ? undefined : resolveProjectId(store, projectRef);
+    // The store already returns entries in numeric id order; trust it instead of
+    // re-sorting with a lexicographic compare (which yields 1, 10, 2, ...).
+    const entries = store.listIntegrationQueueEntries(task.id)
+        .filter((entry) => projectId === undefined || entry.projectId === projectId);
+    const output = entries.length === 0
+        ? "Integration queue is empty.\n"
+        : `${renderTable(`Integration queue: ${task.id}`, [
+            { header: "Entry", minWidth: 12, maxWidth: 24 },
+            { header: "Project", minWidth: 8, maxWidth: 20 },
+            { header: "ChangeSet", minWidth: 10, maxWidth: 20 },
+            { header: "Target", minWidth: 8, maxWidth: 30 },
+            { header: "Status", minWidth: 8, maxWidth: 16 }
+        ], entries.map((entry) => [
+            entry.id,
+            entry.projectId,
+            entry.changeSetId,
+            entry.targetRef,
+            entry.status
+        ]), defaultTableWidth())}\n`;
+    return { output, data: { entries } };
+}
+function show(args, store, environment) {
+    const usage = "Task Integration queue show usage: yui task integration queue show <task>/<entry>.";
+    if (args.length !== 1)
+        throw usageError(usage);
+    const entry = requireQueueEntry(store, args[0], environment);
+    const lines = [
+        `Integration queue entry: ${entry.id}`,
+        `Task: ${entry.taskId}`,
+        `Project: ${entry.projectId}`,
+        `ChangeSet: ${entry.changeSetId}`,
+        `Target: ${entry.targetRef}`,
+        `Status: ${entry.status}`,
+        `Target before: ${entry.targetBefore ?? "-"}`,
+        `Target after: ${entry.targetAfter ?? "-"}`,
+        `Integration: ${entry.integrationAttemptId ?? "-"}`,
+        `Affected paths: ${entry.affectedPaths === undefined ? "-" : entry.affectedPaths.join(", ")}`,
+        `Evidence: ${entry.evidenceRefs.length === 0 ? "-" : entry.evidenceRefs.join(", ")}`,
+        `Conflict: ${entry.conflictSummary ?? "-"}`,
+        `Superseded: ${entry.supersedeReason ?? "-"}`
+    ];
+    return { output: `${lines.join("\n")}\n`, data: { entry } };
+}
+async function process(args, store, home, options) {
+    const usage = "Task Integration queue process usage: yui task integration queue process <task> [--project <project>] [--limit <n>].";
+    const parsed = parseRepeatable(args, new Set(), new Set(["--project", "--limit"]), usage);
+    if (parsed.positionals.length !== 1)
+        throw usageError(usage);
+    const task = requireActiveTask(store, parsed.positionals[0]);
+    requireLeader(options.environment, task.id);
+    const limitValue = parsed.one.get("--limit");
+    const limit = limitValue === undefined ? undefined : Number.parseInt(limitValue, 10);
+    if (limitValue !== undefined && (!Number.isSafeInteger(limit) || limit < 1)) {
+        throw usageError(`--limit must be a positive integer: ${limitValue}.`);
+    }
+    const projectRef = parsed.one.get("--project");
+    const projectId = projectRef === undefined ? undefined : resolveProjectId(store, projectRef);
+    const processed = await processIntegrationQueue(store, home, task.id, {
+        projectId,
+        limit,
+        now: options.now,
+        environment: options.environment
+    });
+    const lines = processed.map(({ entry, result }) => {
+        if (result.status === "committed") {
+            return `${entry.id} committed ${entry.changeSetId} -> ${entry.targetAfter ?? "-"}`;
+        }
+        if (result.status === "blocked") {
+            return `${entry.id} conflicted ${entry.changeSetId}: ${entry.conflictSummary ?? "blocked"}`;
+        }
+        return `${entry.id} conflicted ${entry.changeSetId}: ${entry.conflictSummary ?? "gate failure"}`;
+    });
+    const output = processed.length === 0
+        ? "Integration queue: nothing to process.\n"
+        : `${lines.join("\n")}\n`;
+    return { output, data: { processed } };
+}
+function supersede(args, store, options) {
+    const usage = "Task Integration queue supersede usage: yui task integration queue supersede <task>/<entry> --reason <text>.";
+    const parsed = parseRepeatable(args, new Set(), new Set(["--reason"]), usage);
+    if (parsed.positionals.length !== 1)
+        throw usageError(usage);
+    const entry = requireQueueEntry(store, parsed.positionals[0], options.environment);
+    requireLeader(options.environment, entry.taskId);
+    const reason = parsed.one.get("--reason");
+    if (reason === undefined)
+        throw usageError(usage);
+    const superseded = supersedeIntegrationQueueEntry(store, entry.taskId, entry.id, reason, options.now ?? (() => new Date()));
+    return {
+        output: `Superseded ${superseded.id}: ${reason}\n`,
+        data: { entry: superseded }
+    };
+}
+function requeue(args, store, options) {
+    const usage = "Task Integration queue requeue usage: yui task integration queue requeue <task>/<entry>.";
+    if (args.length !== 1)
+        throw usageError(usage);
+    const entry = requireQueueEntry(store, args[0], options.environment);
+    requireLeader(options.environment, entry.taskId);
+    const waiting = requeueIntegrationQueueEntry(store, entry.taskId, entry.id, options.now ?? (() => new Date()));
+    return {
+        output: `Requeued ${waiting.id}; it will be processed again on the next queue run\n`,
+        data: { entry: waiting }
+    };
+}
+async function reconcile(args, store, options) {
+    const usage = "Task Integration queue reconcile usage: yui task integration queue reconcile <task>/<entry>.";
+    if (args.length !== 1)
+        throw usageError(usage);
+    const entry = requireQueueEntry(store, args[0], options.environment);
+    requireLeader(options.environment, entry.taskId);
+    const committed = await reconcileIntegrationQueueEntry(store, entry.taskId, entry.id, new NodeGitWorkspace(), options.now ?? (() => new Date()));
+    return {
+        output: `Reconciled ${committed.id} as committed -> ${committed.targetAfter ?? "-"}\n`,
+        data: { entry: committed }
+    };
+}
+function requireActiveTask(store, taskId) {
+    const task = store.getTask(taskId);
+    if (task === null)
+        throw usageError(`Task not found: ${taskId}.`);
+    if (task.status !== "active") {
+        throw usageError(`Task is not active: ${task.id}/${task.status}.`);
+    }
+    return task;
+}
+function resolveProjectId(store, reference) {
+    const project = resolveProject(store.listProjects(), reference);
+    if (project === null)
+        throw usageError(`Project not found: ${reference}.`);
+    return project.id;
+}
+function requireQueueEntry(store, value, environment) {
+    let reference;
+    try {
+        reference = resolveTaskRecordReference(value, {
+            kind: "integrationQueue",
+            contextTaskId: environment?.YUI_TASK_ID,
+            label: "Integration queue entry"
+        });
+    }
+    catch (error) {
+        throw usageError(error instanceof Error ? error.message : String(error));
+    }
+    const entry = store.getIntegrationQueueEntry(reference.taskId, reference.localId);
+    if (entry === null) {
+        throw usageError(`Integration queue entry not found: ${reference.taskId}/${reference.localId}.`);
+    }
+    return entry;
+}
+function requireLeader(environment, taskId) {
+    if (taskActor(environment, taskId) !== "leader") {
+        throw usageError("Only the Task Leader can change the integration queue.");
+    }
+}

package/dist/commands/taskNextActionCommand.js

@@ -0,0 +1,100 @@
+import { taskNotFound, usageError } from "../errors/cliError.js";
+import { projectNextAction } from "../task/nextAction.js";
+import { extractReviewFindings, planRepairWave } from "../task/repairWave.js";
+/**
+ * Issue 07 (Leader convergence): read-only `yui task next-action <task>`.
+ * Folds the existing durable records into exactly one protocol-level next
+ * action with exact refs, preconditions, recommended command, alternatives, and
+ * the judgment that remains owned by the Leader.
+ * The command never mutates state; when the action is `route-review-findings`
+ * it also prints the minimal repair wave for the failing Review.
+ */
+export function runTaskNextActionCommand(args, store) {
+    const usage = "Task next-action usage: yui task next-action <task> [--json].";
+    const positionals = args.filter((arg) => arg !== "--json");
+    const asJson = args.includes("--json");
+    if (positionals.length !== 1 || positionals[0]?.trim().length === 0) {
+        throw usageError(usage);
+    }
+    const taskId = positionals[0].trim();
+    const data = store.transaction((reader) => {
+        const facts = reader.readNextActionFacts(taskId);
+        if (facts === null)
+            throw taskNotFound(taskId);
+        const action = projectNextAction(facts);
+        const repairWave = repairWaveFor(action, facts);
+        return { action, repairWave };
+    });
+    if (asJson) {
+        return {
+            kind: "output",
+            output: `${JSON.stringify(data, null, 2)}\n`,
+            data
+        };
+    }
+    return {
+        kind: "output",
+        output: renderNextAction(data.action, data.repairWave),
+        data
+    };
+}
+function repairWaveFor(action, facts) {
+    if (action.kind !== "route-review-findings")
+        return null;
+    const reviewRef = action.refs.find((ref) => ref.kind === "review-round");
+    if (reviewRef === undefined)
+        return null;
+    const round = facts.reviewRounds.find((candidate) => candidate.id === reviewRef.id);
+    if (round === undefined)
+        return null;
+    const findings = extractReviewFindings(round);
+    if (findings.length === 0)
+        return null;
+    return planRepairWave(round.id, findings);
+}
+function renderNextAction(action, repairWave) {
+    const lines = [
+        `Task: ${action.taskId}`,
+        `Next action: ${action.kind}`,
+        `Reason: ${action.reason}`,
+        ...(action.refs.length === 0
+            ? ["Refs: none"]
+            : ["Refs:", ...action.refs.map((ref) => `  ${ref.kind}: ${ref.id}`)]),
+        "Preconditions:",
+        ...action.preconditions.map((precondition) => {
+            const ref = precondition.ref === undefined
+                ? ""
+                : ` (${precondition.ref.kind} ${precondition.ref.id})`;
+            return `  ${precondition.satisfied ? "[x]" : "[ ]"} ${precondition.fact}${ref}`;
+        }),
+        ...(action.recommendedCommand === undefined
+            ? []
+            : [`Recommended: ${action.recommendedCommand}`]),
+        ...(action.judgmentRequired === undefined
+            ? []
+            : [`Judgment: ${action.judgmentRequired}`]),
+        ...(action.alternatives === undefined || action.alternatives.length === 0
+            ? []
+            : [
+                "Alternatives:",
+                ...action.alternatives.map((alternative) => {
+                    const command = alternative.recommendedCommand === undefined
+                        ? ""
+                        : ` — ${alternative.recommendedCommand}`;
+                    return `  ${alternative.kind}: ${alternative.reason}${command}`;
+                })
+            ]),
+        ...(action.conflicts === undefined || action.conflicts.length === 0
+            ? []
+            : [
+                "Conflicts:",
+                ...action.conflicts.map((conflict) => `  ${conflict.kind}: ${conflict.id}`)
+            ])
+    ];
+    if (repairWave !== null) {
+        lines.push(`Repair wave (${repairWave.openFindingCount} open finding(s), ${repairWave.groups.length} group(s)):`, ...repairWave.groups.map((group) => `  ${group.id}: findings ${group.findingIds.join(", ")}`
+            + ` — paths ${group.paths.length === 0 ? "none" : group.paths.join(", ")}`
+            + ` — ${group.reason}`));
+    }
+    return `${lines.join("\n")}\n`;
+}

package/dist/commands/taskOverlapCommands.js

@@ -0,0 +1,120 @@
+import { usageError } from "../errors/cliError.js";
+import { diagnoseOverlap, overlapSubjectFromChangeSet, overlapSubjectKey } from "../integration/overlapDiagnostics.js";
+import { resolveProject } from "../repository/project.js";
+/**
+ * Read-only cross-Task overlap diagnostics.  Gathers the latest ChangeSet
+ * per (Task, WorkItem, Project) and reports semantic overlap, a suggested
+ * integration order, and semantic review areas.  Never mutates state.
+ */
+export async function runTaskOverlapCommand(args, store) {
+    const parsed = parseOverlapArgs(args);
+    const projectId = resolveProjectFilter(store, parsed.project);
+    const tasks = store.listTasks()
+        .filter((task) => parsed.tasks.size === 0 || parsed.tasks.has(task.id));
+    const latest = new Map();
+    for (const task of tasks) {
+        for (const changeSet of store.listChangeSets(task.id)) {
+            if (projectId !== undefined && changeSet.projectId !== projectId)
+                continue;
+            if (parsed.base !== undefined && changeSet.baseCommit !== parsed.base)
+                continue;
+            const key = `${changeSet.taskId}/${changeSet.workItemId}/${changeSet.projectId}`;
+            const current = latest.get(key);
+            if (current === undefined || isNewer(changeSet, current)) {
+                latest.set(key, changeSet);
+            }
+        }
+    }
+    const subjects = [...latest.values()].map(overlapSubjectFromChangeSet);
+    const report = diagnoseOverlap(subjects);
+    return {
+        output: renderOverlapReport(report.findings, report.suggestedOrder, report.reviewAreas, subjects),
+        data: { report }
+    };
+}
+function isNewer(candidate, current) {
+    if (candidate.createdAt !== current.createdAt) {
+        return candidate.createdAt > current.createdAt;
+    }
+    return candidate.id.localeCompare(current.id) > 0;
+}
+function resolveProjectFilter(store, reference) {
+    if (reference === undefined)
+        return undefined;
+    const project = resolveProject(store.listProjects(), reference);
+    if (project === null)
+        throw usageError(`Project not found: ${reference}.`);
+    return project.id;
+}
+function parseOverlapArgs(args) {
+    let project;
+    let base;
+    const tasks = new Set();
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--project") {
+            project = requireValue(args, index, "--project");
+            index += 1;
+        }
+        else if (arg === "--base") {
+            base = requireValue(args, index, "--base");
+            index += 1;
+        }
+        else if (arg === "--task") {
+            tasks.add(requireValue(args, index, "--task"));
+            index += 1;
+        }
+        else {
+            throw usageError("Task overlap usage: yui task overlap [--project <project>] [--base <sha>] [--task <task>] ...");
+        }
+    }
+    return { project, base, tasks };
+}
+function requireValue(args, index, option) {
+    const value = args[index + 1];
+    if (value === undefined || value.startsWith("--")) {
+        throw usageError(`Task overlap option ${option} requires a value.`);
+    }
+    return value;
+}
+function renderOverlapReport(findings, suggestedOrder, reviewAreas, subjects) {
+    const lines = [
+        `Overlap: ${subjects.length} subjects, ${findings.length} findings`
+    ];
+    if (subjects.length === 0) {
+        lines.push("No ChangeSets match the given filters.");
+        return `${lines.join("\n")}\n`;
+    }
+    lines.push("Subjects:");
+    for (const subject of subjects) {
+        const tags = subject.manifestTags.length === 0 ? "-" : subject.manifestTags.join(",");
+        lines.push(`  ${subject.changeSetId} ${subject.taskId}/${subject.workItemId} ${subject.projectId} `
+            + `base=${subject.baseCommit.slice(0, 12)} head=${subject.headCommit.slice(0, 12)} tags=${tags}`);
+    }
+    if (findings.length === 0) {
+        lines.push("No semantic overlap detected.");
+    }
+    else {
+        lines.push("Findings:");
+        for (const finding of findings) {
+            lines.push(`  [${finding.risk}] ${finding.kind}: ${finding.changeSetIds.join(" vs ")}`);
+            for (const path of finding.paths)
+                lines.push(`    ${path}`);
+            lines.push(`    ${finding.detail}`);
+        }
+    }
+    lines.push("Suggested integration order:");
+    suggestedOrder.forEach((ref, index) => {
+        const subject = subjects.find((candidate) => overlapSubjectKey(candidate) === ref);
+        lines.push(`  ${index + 1}. ${ref}${subject === undefined ? "" : ` (${subject.workItemId})`}`);
+    });
+    if (reviewAreas.length === 0) {
+        lines.push("Review areas: none (no high/medium findings)");
+    }
+    else {
+        lines.push("Review areas:");
+        for (const area of reviewAreas)
+            lines.push(`  - ${area}`);
+    }
+    return `${lines.join("\n")}\n`;
+}

package/dist/commands/taskOverviewCommand.js

@@ -1,8 +1,9 @@
 import { usageError } from "../errors/cliError.js";
 import { isRoleRunStalled, latestStallProgressAt } from "../scheduler/roleRunStall.js";
 import { formatTimestamp } from "../output/timePresentation.js";
+import { pendingWakeupProjection } from "../storage/taskStore.js";
 import { defaultTableWidth, renderTable } from "../output/table.js";
-import { buildTaskExecutionProjection } from "../scheduler/taskExecutionProjection.js";
+import { projectTaskExecutionFromFacts } from "../scheduler/taskExecutionProjection.js";
 export function parseTaskListOptions(args) {
     const allowed = new Set(["--all", "--verbose"]);
     if (args.some((argument) => !allowed.has(argument))
@@ -53,15 +54,27 @@ export function renderTaskOverview(result, options, timeZone, width = defaultTab
 }
 function buildTaskOverviewEntry(task, store) {
     const brief = store.getTaskBrief(task.id);
-    const leaderRole = store.getRole(task.id, "leader");
+    const roles = store.listRoles(task.id);
+    const leaderRole = roles.find((role) => role.name === "leader") ?? null;
     const workItems = store.listWorkItems(task.id);
     const inputRequests = store.listInputRequests(task.id);
     const openInputRequests = inputRequests.filter((request) => request.status === "open");
     const agentRuns = store.listAgentRuns(task.id);
     const events = store.listEvents(task.id);
-    const attention = collectAttention(task, agentRuns, events, store.getLeaderFailure(task.id), store.getOperatorNotification(task.id));
+    const leaderFailure = store.getLeaderFailure(task.id);
+    const operatorNotification = store.getOperatorNotification(task.id);
+    const leaderMailbox = store.getWorkMailbox({ kind: "role", taskId: task.id, roleName: "leader" });
+    const pendingWakeup = pendingWakeupProjection(leaderMailbox);
+    const reviewRounds = store.listReviewRounds(task.id);
+    const changeSets = store.listChangeSets(task.id);
+    const integrations = store.listIntegrationAttempts(task.id);
+    const roleSessions = roles.flatMap((role) => {
+        const session = store.getRoleSession(task.id, role.name);
+        return session === null ? [] : [{ roleName: role.name, ...session }];
+    });
+    const attention = collectAttention(task, agentRuns, events, leaderFailure, operatorNotification);
     const blockers = collectBlockers(workItems, openInputRequests, attention);
-    const next = deriveNextAction(task, brief, workItems, openInputRequests, blockers, store.getPendingWakeup(task.id));
+    const next = deriveNextAction(task, brief, workItems, openInputRequests, blockers, pendingWakeup);
     const leader = {
         role: "leader",
         roleStatus: leaderRole?.status ?? "missing",
@@ -88,10 +101,25 @@ function buildTaskOverviewEntry(task, store) {
         activeRunCount: runtimeRuns.length,
         pendingDeliveryCount: runtimeRuns.filter((run) => run.delivery === "pending").length
     };
-    const execution = buildTaskExecutionProjection(store, task.id, task);
-    if (execution === null) {
-        throw new Error(`Task execution projection disappeared: ${task.id}.`);
-    }
+    // Fold the execution projection from the facts already read above instead of
+    // reading the store a second time for the same unchanged revision.
+    const execution = projectTaskExecutionFromFacts({
+        task,
+        roles,
+        runs: agentRuns,
+        workItems,
+        inputRequests,
+        reviewRounds,
+        changeSets,
+        integrations,
+        events,
+        brief,
+        pendingWakeup,
+        leaderMailbox,
+        leaderFailure,
+        operatorNotification,
+        roleSessions
+    });
     return {
         ...task,
         brief,