@zq-silk/yui 0.6.13 → 0.6.15

package/dist/observability/executionAudit.js

@@ -16,6 +16,7 @@ import { openCompatibleFileTaskStore } from "../storage/compatibleTaskStore.js";
 import { resolveTaskStoreBackendForHome } from "../storage/sqliteStore.js";
 import { runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
 import { classifyAgentRunFailure, classifyIntegrationAttempt, classifyReviewRound, classifyWakeReasons, countFaultClasses } from "./faultClassification.js";
+import { RUNTIME_LAUNCH_KINDS, RUNTIME_LAUNCH_PHASES } from "../runtime/launchDiagnostics.js";
 import { UNSUPPORTED } from "./runtimeIdentity.js";
 export function createProductionExecutionAuditPorts() {
     return {
@@ -84,11 +85,86 @@ function roleBucket(roleName) {
     }
     return "other";
 }
+/** Maps a provider-retry lifecycle event to its last recorded decision. */
+function providerRetryDecision(event) {
+    if (event.type === "runtime.provider-retry-waiting")
+        return "waiting";
+    if (event.type === "runtime.provider-retry-resume")
+        return "resume";
+    if (event.type === "runtime.provider-retry-session-dead")
+        return "session-dead";
+    if (event.type === "runtime.provider-retry-budget-exhausted")
+        return "budget-exhausted";
+    if (event.payload.note === "native-turn-completion-durable")
+        return "suppressed:completion-durable";
+    if (event.payload.note === "retry-budget-exhausted")
+        return "budget-exhausted";
+    if (event.payload.wouldRetry === "true")
+        return "retrying";
+    if (event.payload.shadow === "true")
+        return "shadow";
+    return "not-retried";
+}
 function durationMs(run) {
     if (run.endedAt === undefined)
         return 0;
     return Math.max(0, Date.parse(run.endedAt) - Date.parse(run.createdAt));
 }
+function emptyLaunchFailureCounts() {
+    const counts = {
+        total: 0,
+        byPhase: Object.fromEntries(RUNTIME_LAUNCH_PHASES.map((phase) => [phase, 0])),
+        byKind: Object.fromEntries(RUNTIME_LAUNCH_KINDS.map((kind) => [kind, 0]))
+    };
+    return counts;
+}
+function addLaunchFailureCounts(counts, summary) {
+    if (summary === undefined)
+        return;
+    const phase = /failurePhase=([a-z-]+)/u.exec(summary)?.[1];
+    const kind = /failureKind=([a-z-]+)/u.exec(summary)?.[1];
+    if (phase === undefined
+        || kind === undefined
+        || !RUNTIME_LAUNCH_PHASES.includes(phase)
+        || !RUNTIME_LAUNCH_KINDS.includes(kind)) {
+        return;
+    }
+    counts.byPhase[phase] += 1;
+    counts.byKind[kind] += 1;
+    counts.total += 1;
+}
+/**
+ * Issue 09: classify a terminal Session (stopped/broken) by its relationship
+ * to the last Run it carried. Runs and Sessions are separate axes: a Session
+ * that stops after its Run yielded is a post-completion stop, not a Run
+ * failure. Correlation is by Role + Agent + Adapter (the durable identity a
+ * Run and its Session share) and the Session's terminal update timestamp.
+ */
+function classifyTerminalSessionRunRelation(runs, roleName, session, counts) {
+    const terminalAt = Date.parse(session.updatedAt);
+    const carried = runs
+        .filter((run) => (run.roleName === roleName
+        && run.effective.agentId === session.agentId
+        && run.effective.adapterId === session.adapterId
+        && Date.parse(run.createdAt) <= terminalAt))
+        .sort((left, right) => Date.parse(right.createdAt) - Date.parse(left.createdAt));
+    const lastRun = carried[0];
+    if (lastRun === undefined) {
+        counts.noRun += 1;
+        return;
+    }
+    if (lastRun.status === "yielded"
+        && lastRun.endedAt !== undefined
+        && Date.parse(lastRun.endedAt) <= terminalAt) {
+        counts.postRunYielded += 1;
+        return;
+    }
+    if (lastRun.status === "failed") {
+        counts.runFailed += 1;
+        return;
+    }
+    counts.activeRun += 1;
+}
 function ok(data) {
     return { status: "ok", data };
 }
@@ -126,7 +202,9 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
             sessions: section,
             reviews: section,
             integrations: section,
+            publications: section,
             events: section,
+            providerRetries: section,
             workItems: section,
             storage: section,
             topLongRunning: section
@@ -174,6 +252,7 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
             const byRole = { leader: 0, reviewer: 0, implementer: 0, other: 0 };
             const byPurpose = { execution: 0, review: 0 };
             const failures = [];
+            const launchFailures = emptyLaunchFailureCounts();
             for (const taskId of taskIds) {
                 for (const run of store.listAgentRuns(taskId)) {
                     if (!inWindow(run.createdAt, options))
@@ -197,6 +276,7 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
                         failedCount += 1;
                         failedDurationMs += duration;
                         cumulativeDurationMs += duration;
+                        addLaunchFailureCounts(launchFailures, run.summary);
                         failures.push(classifyAgentRunFailure(run));
                     }
                 }
@@ -211,7 +291,8 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
                 failedDurationMs,
                 byRole,
                 byPurpose,
-                faultClasses: countFaultClasses(failures)
+                faultClasses: countFaultClasses(failures),
+                launchFailures
             });
         }
         catch (error) {
@@ -224,6 +305,7 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
             let withWakeReasons = 0;
             let orphanWakes = 0;
             let orphanYieldOnly = 0;
+            let suppressedWakes = 0;
             const byReason = new Map();
             for (const taskId of taskIds) {
                 for (const run of store.listAgentRuns(taskId)) {
@@ -247,6 +329,13 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
                             orphanYieldOnly += 1;
                     }
                 }
+                for (const event of store.listEvents(taskId)) {
+                    if (event.type !== "wake.suppressed")
+                        continue;
+                    if (!inWindow(event.createdAt, options))
+                        continue;
+                    suppressedWakes += 1;
+                }
             }
             return ok({
                 leaderRuns,
@@ -254,9 +343,10 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
                 orphanWakes,
                 orphanYieldOnly,
                 byReason: Object.fromEntries([...byReason.entries()].sort((left, right) => right[1] - left[1])),
-                // The quiescence/suppression counter is owned by the scheduler Issue;
-                // this build has no producer, so report unsupported rather than 0.
-                suppressedWakes: { status: "unsupported" }
+                // Scheduler single-flight suppression: wakes that were coalesced
+                // because the Role runtime lifecycle lane was busy. These are
+                // scheduler outcomes, never failed Runs.
+                suppressedWakes: { status: "ok", data: suppressedWakes }
             });
         }
         catch (error) {
@@ -272,7 +362,14 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
             let resets = 0;
             let lifecycleEvents = 0;
             let stopFailures = 0;
+            const terminalByRunRelation = {
+                postRunYielded: 0,
+                runFailed: 0,
+                activeRun: 0,
+                noRun: 0
+            };
             for (const taskId of taskIds) {
+                const runs = store.listAgentRuns(taskId);
                 for (const set of store.listRoleSessionSets(taskId)) {
                     const history = Array.isArray(set.history) ? set.history : [];
                     for (const session of [...history, ...Object.values(set.sessions)]) {
@@ -283,6 +380,9 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
                             stopped += 1;
                         else
                             other += 1;
+                        if (session.status === "broken" || session.status === "stopped") {
+                            classifyTerminalSessionRunRelation(runs, set.owner.roleName, session, terminalByRunRelation);
+                        }
                     }
                 }
                 for (const event of store.listEvents(taskId)) {
@@ -304,7 +404,8 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
                 other,
                 resets,
                 lifecycleEvents,
-                stopFailures
+                stopFailures,
+                terminalByRunRelation
             });
         }
         catch (error) {
@@ -318,6 +419,10 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
             let failedCount = 0;
             let infraFailed = 0;
             let semanticNegative = 0;
+            let deltaTotal = 0;
+            let deltaAccepted = 0;
+            let deltaFinding = 0;
+            let deltaEscalated = 0;
             const classes = [];
             for (const taskId of taskIds) {
                 for (const round of store.listReviewRounds(taskId)) {
@@ -328,6 +433,15 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
                         completed += 1;
                     else if (round.status === "failed")
                         failedCount += 1;
+                    if (round.deltaRecheck !== undefined) {
+                        deltaTotal += 1;
+                        if (round.deltaRecheck.disposition === "equivalent-and-accepted")
+                            deltaAccepted += 1;
+                        else if (round.deltaRecheck.disposition === "finding")
+                            deltaFinding += 1;
+                        else if (round.deltaRecheck.disposition === "requires-full-review")
+                            deltaEscalated += 1;
+                    }
                     const classification = classifyReviewRound(round);
                     if (classification.faultClass === "review-infra")
                         infraFailed += 1;
@@ -344,7 +458,13 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
                 failed: failedCount,
                 infraFailed,
                 semanticNegative,
-                faultClasses: countFaultClasses(classes)
+                faultClasses: countFaultClasses(classes),
+                deltaRechecks: {
+                    total: deltaTotal,
+                    equivalentAndAccepted: deltaAccepted,
+                    finding: deltaFinding,
+                    requiresFullReview: deltaEscalated
+                }
             });
         }
         catch (error) {
@@ -411,6 +531,41 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
             return failed(error);
         }
     })();
+    const publications = (() => {
+        try {
+            let total = 0;
+            let merged = 0;
+            let verified = 0;
+            let open = 0;
+            let closed = 0;
+            let superseded = 0;
+            for (const taskId of taskIds) {
+                const references = store.listPublicationReferences(taskId);
+                const supersededIds = new Set(references
+                    .map((reference) => reference.supersedes)
+                    .filter((id) => id !== undefined));
+                for (const reference of references) {
+                    if (!inWindow(reference.createdAt, options))
+                        continue;
+                    total += 1;
+                    if (reference.state === "merged")
+                        merged += 1;
+                    if (reference.state === "open")
+                        open += 1;
+                    if (reference.state === "closed")
+                        closed += 1;
+                    if (reference.verification === "verified")
+                        verified += 1;
+                    if (supersededIds.has(reference.id))
+                        superseded += 1;
+                }
+            }
+            return ok({ total, merged, verified, open, closed, superseded });
+        }
+        catch (error) {
+            return failed(error);
+        }
+    })();
     const events = (() => {
         try {
             let total = 0;
@@ -445,6 +600,57 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
             return failed(error);
         }
     })();
+    const providerRetries = (() => {
+        try {
+            const entries = new Map();
+            for (const taskId of taskIds) {
+                for (const event of store.listEvents(taskId)) {
+                    if (!inWindow(event.createdAt, options))
+                        continue;
+                    if (!event.type.startsWith("runtime.provider-retry-"))
+                        continue;
+                    const runId = event.payload.runId;
+                    if (typeof runId !== "string")
+                        continue;
+                    const key = `${taskId}/${runId}`;
+                    const previous = entries.get(key);
+                    const attempt = Number(event.payload.attempt ?? "0");
+                    const decision = providerRetryDecision(event);
+                    const terminal = decision === "session-dead" || decision === "budget-exhausted";
+                    const next = {
+                        taskId,
+                        runId,
+                        roleName: typeof event.payload.roleName === "string"
+                            ? event.payload.roleName
+                            : previous?.roleName ?? "",
+                        attempts: Number.isFinite(attempt) ? Math.max(previous?.attempts ?? 0, attempt) : (previous?.attempts ?? 0),
+                        errorClass: typeof event.payload.errorClass === "string"
+                            ? event.payload.errorClass
+                            : previous?.errorClass ?? "",
+                        firstFailureAt: previous?.firstFailureAt ?? event.createdAt,
+                        lastFailureAt: event.createdAt,
+                        ...(typeof event.payload.nextAttemptAt === "string"
+                            ? { lastBackoffAt: event.payload.nextAttemptAt }
+                            : previous?.lastBackoffAt !== undefined
+                                ? { lastBackoffAt: previous.lastBackoffAt }
+                                : {}),
+                        decision,
+                        terminal: (previous?.terminal ?? false) || terminal
+                    };
+                    entries.set(key, next);
+                }
+            }
+            const list = [...entries.values()];
+            return ok({
+                total: list.length,
+                terminal: list.filter((entry) => entry.terminal).length,
+                entries: list.map(({ terminal: _terminal, ...entry }) => entry)
+            });
+        }
+        catch (error) {
+            return failed(error);
+        }
+    })();
     const workItems = (() => {
         try {
             let total = 0;
@@ -540,7 +746,9 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
         sessions,
         reviews,
         integrations,
+        publications,
         events,
+        providerRetries,
         workItems,
         storage,
         topLongRunning

package/dist/output/table.js

@@ -1,4 +1,22 @@
 import { padVisibleEnd, visibleWidth, wrapVisibleText } from "./terminal.js";
+/**
+ * The shared renderer for every command whose output is row/column data
+ * (lists, overviews, settings such as `config show`). The consistent rules:
+ *
+ * - Column width: each column declares `minWidth`/`maxWidth`; widths start at
+ *   the widest cell and shrink largest-spare-first until the table fits.
+ * - Alignment: cells are left-aligned and padded by visible width, so CJK and
+ *   other wide characters align correctly.
+ * - Empty values: rendered as empty cells (trimmed at line end); the
+ *   narrow-terminal record fallback skips empty detail values.
+ * - Terminal width: callers pass `defaultTableWidth()` (46–140 columns) unless
+ *   a command has a narrower natural bound.
+ * - JSON mode: commands that have structured data pass it as `emit`'s `data`
+ *   argument; the table text is the human view of the same values.
+ *
+ * Do not use this for long-form prose, diagnostic detail, or interactive
+ * prompts — those keep their own non-tabular formats.
+ */
 export function renderTable(title, columns, rows, maxWidth) {
     if (columns.length === 0)
         return title;

package/dist/repository/gitWorkspace.js

@@ -80,6 +80,44 @@ export class NodeGitWorkspace {
         ]);
         return output.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
     }
+    /** Issue 07: exact unified diff text between two commits. */
+    async diffTextBetween(input) {
+        return git([
+            "-C", input.repositoryPath,
+            "diff", "--no-color", "--no-ext-diff",
+            input.fromCommit, input.toCommit
+        ]);
+    }
+    /** Issue 07: sums `git diff --numstat` added/deleted lines. */
+    async diffNumstatBetween(input) {
+        const output = await git([
+            "-C", input.repositoryPath,
+            "diff", "--numstat",
+            input.fromCommit, input.toCommit
+        ]);
+        let addedLines = 0;
+        let deletedLines = 0;
+        for (const line of output.split("\n")) {
+            const trimmed = line.trim();
+            if (trimmed.length === 0)
+                continue;
+            const [added, deleted] = trimmed.split("\t");
+            // Binary files report "-" for both counts; they change the tree and
+            // must not be treated as zero-line edits.
+            if (added === "-" || deleted === "-") {
+                throw new Error("Delta recheck cannot assess a binary diff.");
+            }
+            const addedCount = Number(added);
+            const deletedCount = Number(deleted);
+            if (!Number.isInteger(addedCount) || !Number.isInteger(deletedCount)
+                || addedCount < 0 || deletedCount < 0) {
+                throw new Error("Git returned invalid numstat output.");
+            }
+            addedLines += addedCount;
+            deletedLines += deletedCount;
+        }
+        return { addedLines, deletedLines };
+    }
     /**
      * Files deleted between two commits.  Uses `--diff-filter=D` so a rename
      * reports its source path here (and its destination in `changedFilesBetween`),
@@ -541,6 +579,60 @@ export class NodeGitWorkspace {
             safeRef(descendant)
         ]);
     }
+    async inspectRemoteTracking(input) {
+        const root = (await this.inspect(input.repositoryPath)).root;
+        const wantedUrl = requireText(input.remoteUrl, "Project remote URL");
+        let output;
+        try {
+            output = await git([
+                "-C", root,
+                "config", "--get-regexp", "--null",
+                "^remote\\..*\\.url$"
+            ]);
+        }
+        catch {
+            return null;
+        }
+        const records = output.split("\0").filter((record) => record.length > 0);
+        const matches = [];
+        for (const record of records) {
+            const separator = record.indexOf("\n");
+            if (separator < 0)
+                continue;
+            const key = record.slice(0, separator).trim();
+            const url = record.slice(separator + 1).trim();
+            const prefix = "remote.";
+            const suffix = ".url";
+            if (!key.startsWith(prefix) || !key.endsWith(suffix) || url !== wantedUrl)
+                continue;
+            matches.push({ remoteName: key.slice(prefix.length, -suffix.length), url });
+        }
+        if (matches.length !== 1)
+            return null;
+        const remoteName = requireText(matches[0].remoteName, "Git remote name");
+        const branch = await safeFetchBranch(input.branch);
+        const ref = `refs/remotes/${remoteName}/${branch}`;
+        if (!await gitSucceeds(["check-ref-format", ref])) {
+            throw new Error("Git remote tracking ref is invalid.");
+        }
+        if (!await this.refExists(root, ref))
+            return null;
+        return {
+            remoteName,
+            remoteUrl: matches[0].url,
+            ref,
+            commit: (await this.inspect(root, ref)).baseCommit
+        };
+    }
+    async mergeBase(input) {
+        const root = (await this.inspect(input.repositoryPath)).root;
+        return gitLine([
+            "-C", root,
+            "merge-base",
+            safeRef(input.leftCommit),
+            safeRef(input.rightCommit)
+        ]);
+    }
     async headRef(repositoryPath) {
         const requested = await canonicalDirectory(repositoryPath, "Project");
         return gitLine(["-C", requested, "rev-parse", "--abbrev-ref", "HEAD"]);