@zq-silk/yui 0.6.13 → 0.6.14

package/dist/commands/deliveryGuardPreflight.js

@@ -1,8 +1,8 @@
-import { leaderNextActionMode } from "../config/yuiConfig.js";
+import { resolveLeaderNextActionMode } from "../config/yuiConfig.js";
 import { usageError } from "../errors/cliError.js";
 import { detectDeliveryDuplicates, evaluateDeliveryGuard, evaluateSemanticBudget, formatDeliveryDuplicate } from "../task/deliveryGuard.js";
 export function runDeliveryGuardPreflight(store, taskId, intent, options = {}) {
-    const mode = leaderNextActionMode(store.getConfig().leaderNextActionMode, options.environment);
+    const mode = resolveLeaderNextActionMode(store.getConfig().leaderNextActionMode);
     if (mode === "display")
         return { warnings: [] };
     const facts = store.readNextActionFacts(taskId);

package/dist/commands/executionAuditCommands.js

@@ -104,6 +104,15 @@ export function renderExecutionAudit(report, width = defaultTableWidth()) {
                 { header: "Count", minWidth: 5, maxWidth: 8 }
             ], faultRows.map(([name, count]) => [name, String(count)]), width));
         }
+        if (runs.launchFailures.total > 0) {
+            const phaseRows = Object.entries(runs.launchFailures.byPhase)
+                .filter(([, count]) => count > 0)
+                .sort((left, right) => right[1] - left[1]);
+            const kindRows = Object.entries(runs.launchFailures.byKind)
+                .filter(([, count]) => count > 0)
+                .sort((left, right) => right[1] - left[1]);
+            lines.push("", `Launch failures: ${runs.launchFailures.total}`, `By phase: ${phaseRows.map(([name, count]) => `${name}=${count}`).join(" · ")}`, `By kind: ${kindRows.map(([name, count]) => `${name}=${count}`).join(" · ")}`);
+        }
     }
     else {
         lines.push("", ...sectionError("runs", report));
@@ -111,7 +120,10 @@ export function renderExecutionAudit(report, width = defaultTableWidth()) {
     if (report.wakes.status === "ok" && report.wakes.data !== undefined) {
         const wakes = report.wakes.data;
         lines.push("", `Leader wakes: ${wakes.leaderRuns} runs · ${wakes.withWakeReasons} with reasons · ${wakes.orphanWakes} orphan wakes (${wakes.orphanYieldOnly} yield-only)`);
-        if (wakes.suppressedWakes.status === "unsupported") {
+        if (wakes.suppressedWakes.status === "ok") {
+            lines.push(`Suppressed wakes: ${wakes.suppressedWakes.data ?? 0} (scheduler single-flight, not failed Runs)`);
+        }
+        else if (wakes.suppressedWakes.status === "unsupported") {
             lines.push("Suppressed wakes: unsupported (no quiescence producer in this build)");
         }
         const reasonRows = Object.entries(wakes.byReason).slice(0, 8);
@@ -127,14 +139,24 @@ export function renderExecutionAudit(report, width = defaultTableWidth()) {
     }
     if (report.sessions.status === "ok" && report.sessions.data !== undefined) {
         const sessions = report.sessions.data;
-        lines.push("", `Sessions: ${sessions.generations} generations · ${sessions.broken} broken · ${sessions.stopped} stopped · ${sessions.other} other`, `Resets: ${sessions.resets} · lifecycle events ${sessions.lifecycleEvents} · stop failures ${sessions.stopFailures}`);
+        lines.push("", `Sessions: ${sessions.generations} generations · ${sessions.broken} broken · ${sessions.stopped} stopped · ${sessions.other} other`, `Resets: ${sessions.resets} · lifecycle events ${sessions.lifecycleEvents} · stop failures ${sessions.stopFailures}`, `Terminal by Run relation: ${sessions.terminalByRunRelation.postRunYielded} post-run-yielded`
+            + ` · ${sessions.terminalByRunRelation.runFailed} run-failed`
+            + ` · ${sessions.terminalByRunRelation.activeRun} active-run`
+            + ` · ${sessions.terminalByRunRelation.noRun} no-run`);
     }
     else {
         lines.push("", ...sectionError("sessions", report));
     }
     if (report.reviews.status === "ok" && report.reviews.data !== undefined) {
         const reviews = report.reviews.data;
-        lines.push("", `Review rounds: ${reviews.total} total · ${reviews.completed} completed · ${reviews.failed} failed`, `Execution failures: ${reviews.infraFailed} · semantic negatives: ${reviews.semanticNegative}`);
+        lines.push("", `Review rounds: ${reviews.total} total · ${reviews.completed} completed · ${reviews.failed} failed`, `Execution failures: ${reviews.infraFailed} · semantic negatives: ${reviews.semanticNegative}`, ...(reviews.deltaRechecks.total === 0
+            ? []
+            : [
+                `Delta-rechecks: ${reviews.deltaRechecks.total} total · `
+                    + `${reviews.deltaRechecks.equivalentAndAccepted} accepted · `
+                    + `${reviews.deltaRechecks.finding} finding · `
+                    + `${reviews.deltaRechecks.requiresFullReview} escalated to full Review`
+            ]));
     }
     else {
         lines.push("", ...sectionError("reviews", report));
@@ -146,6 +168,13 @@ export function renderExecutionAudit(report, width = defaultTableWidth()) {
     else {
         lines.push("", ...sectionError("integrations", report));
     }
+    if (report.publications.status === "ok" && report.publications.data !== undefined) {
+        const publications = report.publications.data;
+        lines.push("", `Publication references: ${publications.total} total · ${publications.merged} merged · ${publications.verified} verified · ${publications.open} open · ${publications.closed} closed · ${publications.superseded} superseded`);
+    }
+    else {
+        lines.push("", ...sectionError("publications", report));
+    }
     if (report.events.status === "ok" && report.events.data !== undefined) {
         const events = report.events.data;
         lines.push("", `Events: ${events.total} total · ${events.progressEvents} provider-progress (${(events.progressShare * 100).toFixed(1)}%) · ${events.semanticEvents} semantic · ${events.obsoleteEvents} obsolete`, `Messages: ${events.messages}`);
@@ -153,6 +182,30 @@ export function renderExecutionAudit(report, width = defaultTableWidth()) {
     else {
         lines.push("", ...sectionError("events", report));
     }
+    if (report.providerRetries.status === "ok" && report.providerRetries.data !== undefined) {
+        const retries = report.providerRetries.data;
+        if (retries.total > 0) {
+            lines.push("", `Provider retries: ${retries.total} run(s) retried in place · ${retries.terminal} terminal`);
+            lines.push(renderTable("Provider retry lineages", [
+                { header: "Task", minWidth: 8, maxWidth: 14 },
+                { header: "Run", minWidth: 14, maxWidth: 24 },
+                { header: "Role", minWidth: 8, maxWidth: 12 },
+                { header: "Attempts", minWidth: 8, maxWidth: 10 },
+                { header: "Error class", minWidth: 14, maxWidth: 24 },
+                { header: "Decision", minWidth: 14, maxWidth: 26 }
+            ], retries.entries.map((entry) => [
+                entry.taskId,
+                entry.runId,
+                entry.roleName,
+                String(entry.attempts),
+                entry.errorClass,
+                entry.decision
+            ]), width));
+        }
+    }
+    else {
+        lines.push("", ...sectionError("providerRetries", report));
+    }
     if (report.workItems.status === "ok" && report.workItems.data !== undefined) {
         const items = report.workItems.data;
         lines.push("", `Work items: ${items.total} total · ${items.completed} completed · ${items.retired} retired`);

package/dist/commands/projectCommands.js

@@ -5,7 +5,8 @@ import { usageError } from "../errors/cliError.js";
 import { defaultTableWidth, renderTable } from "../output/table.js";
 import { NodeGitWorkspace } from "../repository/gitWorkspace.js";
 import { acquireProjectMaintenanceLock } from "../repository/projectMaintenanceLock.js";
-import { addProjectKnowledge, createProject, managedProjectPath, retireProjectKnowledge, resolveProject, updateProjectKnowledge, updateProjectMetadata, validateProject, validateProjectName } from "../repository/project.js";
+import { addProjectKnowledge, addKnowledgeProposal, decideKnowledgeProposal, createProject, findKnowledgeProposal, findKnowledgeProposalByFingerprint, knowledgeEvidenceDigest, knowledgeProposalFingerprint, managedProjectPath, planKnowledgeAcceptance, retireProjectKnowledge, resolveProject, updateProjectKnowledge, updateProjectMetadata, validateProject, validateProjectName } from "../repository/project.js";
+import { projectActor } from "./taskActor.js";
 export async function runProjectCommand(args, store, options = {}) {
     const [command, ...rest] = args;
     if (command === "add" || command === "clone") {
@@ -521,7 +522,8 @@ function showProject(args, store) {
         ...(project.remoteUrl === undefined ? [] : [`Remote: ${project.remoteUrl}`]),
         `Stable: ${project.stableBranch}`,
         `Development: ${project.developmentBranch}`,
-        `Knowledge: ${project.knowledge.filter(({ status }) => status === "active").length} active`
+        `Knowledge: ${project.knowledge.filter(({ status }) => status === "active").length} active`,
+        `Knowledge proposals: ${project.knowledgeProposals.filter(({ status }) => status === "pending").length} pending`
     ].join("\n").concat("\n");
 }
 function projectKnowledge(args, store, options) {
@@ -531,6 +533,7 @@ function projectKnowledge(args, store, options) {
         const parsed = parseSingleOption(rest, "--body", usage);
         if (parsed.positionals.length !== 2)
             throw usageError(usage);
+        assertKnowledgeOperator(options, "add");
         const added = store.transaction((tx) => {
             const project = requireProject(tx, parsed.positionals[0]);
             const id = nextKnowledgeId(project);
@@ -584,6 +587,21 @@ function projectKnowledge(args, store, options) {
                 `Project: ${project.id}`,
                 `Title: ${entry.title}`,
                 `Status: ${entry.status}`,
+                ...(entry.provenance === undefined ? [] : [
+                    `Source: ${entry.provenance.taskId}`
+                        + `${entry.provenance.decisionId === undefined ? "" : `/${entry.provenance.decisionId}`}`
+                        + `${entry.provenance.milestoneId === undefined ? "" : `/${entry.provenance.milestoneId}`}`
+                        + `${entry.provenance.commitSha === undefined ? "" : `@${entry.provenance.commitSha}`}`,
+                    ...(entry.provenance.evidenceDigest === undefined
+                        ? []
+                        : [`Evidence digest: ${entry.provenance.evidenceDigest}`]),
+                    ...(entry.provenance.proposalId === undefined
+                        ? []
+                        : [`Proposal: ${entry.provenance.proposalId}`]),
+                    ...(entry.provenance.promotedBy === undefined
+                        ? []
+                        : [`Promoted by: ${entry.provenance.promotedBy} at ${entry.provenance.promotedAt ?? "?"}`])
+                ]),
                 "",
                 entry.body
             ].join("\n").concat("\n"),
@@ -594,6 +612,7 @@ function projectKnowledge(args, store, options) {
     if (command === "update") {
         const usage = "Project knowledge update usage: yui project knowledge update <project> <knowledge> [--title <text>] [--body <text>].";
         const parsed = parseKnowledgeUpdateArguments(rest, usage);
+        assertKnowledgeOperator(options, "update");
         const updated = store.transaction((tx) => {
             const project = requireProject(tx, parsed.project);
             const next = updateProjectKnowledge(project, parsed.id, {
@@ -613,6 +632,7 @@ function projectKnowledge(args, store, options) {
         if (rest.length !== 2) {
             throw usageError("Project knowledge retire usage: yui project knowledge retire <project> <knowledge>.");
         }
+        assertKnowledgeOperator(options, "retire");
         const updated = store.transaction((tx) => {
             const project = requireProject(tx, rest[0]);
             const next = retireProjectKnowledge(project, rest[1], (options.now ?? (() => new Date()))());
@@ -625,6 +645,24 @@ function projectKnowledge(args, store, options) {
             knowledgeId: rest[1]
         };
     }
+    if (command === "propose") {
+        return proposeKnowledge(rest, store, options);
+    }
+    if (command === "proposals") {
+        const [sub, ...subRest] = rest;
+        if (sub === "list")
+            return listKnowledgeProposals(subRest, store);
+        if (sub === "show")
+            return showKnowledgeProposal(subRest, store);
+        throw usageError("Project knowledge proposals usage: yui project knowledge proposals list <project>"
+            + " [--status pending|accepted|rejected] [--all] | yui project knowledge proposals show <project> <proposal>.");
+    }
+    if (command === "accept") {
+        return acceptKnowledgeProposal(rest, store, options);
+    }
+    if (command === "reject") {
+        return rejectKnowledgeProposal(rest, store, options);
+    }
     throw usageError(command === undefined
         ? "Project knowledge command is required."
         : `Unknown command: project knowledge ${command}`);
@@ -643,6 +681,470 @@ function nextKnowledgeId(project) {
             return id;
     }
 }
+function nextProposalId(project) {
+    const used = new Set(project.knowledgeProposals.map(({ id }) => id));
+    for (let index = 1;; index += 1) {
+        const id = `proposal-${index}`;
+        if (!used.has(id))
+            return id;
+    }
+}
+/**
+ * Project Knowledge is an Operator authority. A managed Task Session (Leader,
+ * Reviewer, Worker) must use `propose` and let an Operator accept; it can
+ * never write the authoritative list directly.
+ */
+function assertKnowledgeOperator(options, action) {
+    const actor = projectActor(options.environment);
+    if (actor === "agent") {
+        throw usageError(`Project Knowledge is an Operator authority; a managed Task Session cannot ${action} it.`
+            + " Propose a candidate with `yui project knowledge propose` instead.");
+    }
+}
+const PROPOSE_OPTIONS = [
+    "--title", "--body", "--task", "--decision", "--milestone",
+    "--commit", "--scope", "--expires-when", "--supersedes"
+];
+function parseKnowledgeProposalOptions(args, usage) {
+    const values = {};
+    const positionals = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const value = args[index];
+        if (PROPOSE_OPTIONS.includes(value)) {
+            if (values[value] !== undefined) {
+                throw usageError(`${value} may only be provided once. ${usage}`);
+            }
+            const next = args[index + 1];
+            if (next === undefined || next.startsWith("--")) {
+                throw usageError(`${value} is required. ${usage}`);
+            }
+            values[value] = requireText(next, value);
+            index += 1;
+        }
+        else if (value.startsWith("--")) {
+            throw usageError(`Unknown option: ${value}. ${usage}`);
+        }
+        else {
+            positionals.push(value);
+        }
+    }
+    if (positionals.length !== 1)
+        throw usageError(usage);
+    if (values["--title"] === undefined || values["--body"] === undefined || values["--task"] === undefined) {
+        throw usageError(usage);
+    }
+    return {
+        project: positionals[0],
+        title: values["--title"],
+        body: values["--body"],
+        task: values["--task"],
+        ...(values["--decision"] === undefined ? {} : { decision: values["--decision"] }),
+        ...(values["--milestone"] === undefined ? {} : { milestone: values["--milestone"] }),
+        ...(values["--commit"] === undefined ? {} : { commit: values["--commit"] }),
+        ...(values["--scope"] === undefined ? {} : { scope: values["--scope"] }),
+        ...(values["--expires-when"] === undefined ? {} : { expiresWhen: values["--expires-when"] }),
+        ...(values["--supersedes"] === undefined ? {} : { supersedes: values["--supersedes"] })
+    };
+}
+/**
+ * Leader-proposed promotion candidate. The proposal is workflow state, not
+ * Knowledge: it never appears in `project knowledge list/show` until an
+ * Operator accepts it. A managed Task Session may propose only for its own
+ * Task. The same candidate (source identity + title + body) is deduplicated to
+ * the existing pending proposal instead of creating a second copy.
+ */
+function proposeKnowledge(args, store, options) {
+    const usage = "Project knowledge propose usage: yui project knowledge propose <project>"
+        + " --title <text> --body <text> --task <task> [--decision <id>] [--milestone <id>]"
+        + " [--commit <sha>] [--scope <text>] [--expires-when <text>] [--supersedes <knowledge-id>].";
+    const parsed = parseKnowledgeProposalOptions(args, usage);
+    const actor = projectActor(options.environment);
+    if (actor === "agent" && options.environment?.YUI_TASK_ID !== parsed.task) {
+        throw usageError("A managed Task Session may propose Knowledge only for its own Task.");
+    }
+    if (actor === "agent"
+        && options.environment?.YUI_ROLE !== "leader"
+        && options.environment?.YUI_ROLE !== "reviewer") {
+        throw usageError("Only a Leader or Reviewer Session may propose Knowledge promotion.");
+    }
+    const proposedBy = actor === "agent"
+        ? (options.environment?.YUI_ROLE === "reviewer" ? "reviewer" : "leader")
+        : actor;
+    const now = (options.now ?? (() => new Date()))();
+    const result = store.transaction((tx) => {
+        const project = requireProject(tx, parsed.project);
+        const source = requireProposalEvidence(tx, parsed);
+        const fingerprint = knowledgeProposalFingerprint({
+            projectId: project.id,
+            source,
+            title: parsed.title,
+            body: parsed.body
+        });
+        const pending = findKnowledgeProposalByFingerprint(project, fingerprint, "pending");
+        if (pending !== null) {
+            return {
+                projectId: project.id,
+                proposalId: pending.id,
+                deduped: true,
+                alreadyAccepted: false
+            };
+        }
+        const accepted = findKnowledgeProposalByFingerprint(project, fingerprint, "accepted");
+        if (accepted !== null) {
+            return {
+                projectId: project.id,
+                proposalId: accepted.id,
+                knowledgeId: accepted.knowledgeId,
+                deduped: true,
+                alreadyAccepted: true
+            };
+        }
+        const proposal = {
+            schemaVersion: 1,
+            id: nextProposalId(project),
+            projectId: project.id,
+            title: parsed.title,
+            body: parsed.body,
+            status: "pending",
+            source,
+            ...(parsed.scope === undefined ? {} : { scope: parsed.scope }),
+            ...(parsed.expiresWhen === undefined ? {} : { expiresWhen: parsed.expiresWhen }),
+            ...(parsed.supersedes === undefined ? {} : { supersedesKnowledgeId: parsed.supersedes }),
+            fingerprint,
+            ...(source.evidenceDigest === undefined ? {} : { evidenceDigest: source.evidenceDigest }),
+            proposedBy,
+            proposedAt: now.toISOString(),
+            updatedAt: now.toISOString()
+        };
+        tx.saveProject(addKnowledgeProposal(project, proposal));
+        return {
+            projectId: project.id,
+            proposalId: proposal.id,
+            deduped: false,
+            alreadyAccepted: false
+        };
+    });
+    const lines = [
+        result.deduped
+            ? `Knowledge proposal ${result.proposalId} already exists for ${result.projectId}`
+            : `Proposed knowledge ${result.proposalId} for ${result.projectId}`,
+        result.alreadyAccepted
+            ? `Already accepted as knowledge ${result.knowledgeId ?? "?"}`
+            : "Awaiting Operator decision: yui project knowledge proposals list "
+                + `${result.projectId} / yui project knowledge accept ${result.projectId} ${result.proposalId}`
+    ];
+    return {
+        output: `${lines.join("\n")}\n`,
+        projectId: result.projectId,
+        proposalId: result.proposalId,
+        ...(result.knowledgeId === undefined ? {} : { knowledgeId: result.knowledgeId })
+    };
+}
+/**
+ * Verify the cited Task/Decision/Milestone exist and capture the evidence
+ * digest at proposal time, so a later Agent can verify the source record.
+ */
+function requireProposalEvidence(store, parsed) {
+    if (store.getTask === undefined) {
+        throw usageError("Knowledge promotion requires Task evidence, which this store does not provide.");
+    }
+    const task = store.getTask(parsed.task);
+    if (task === null)
+        throw usageError(`Task not found: ${parsed.task}.`);
+    const source = {
+        taskId: task.id,
+        ...(parsed.decision === undefined ? {} : { decisionId: parsed.decision }),
+        ...(parsed.milestone === undefined ? {} : { milestoneId: parsed.milestone }),
+        ...(parsed.commit === undefined ? {} : { commitSha: parsed.commit })
+    };
+    let evidence;
+    if (parsed.decision !== undefined) {
+        if (store.getDecision === undefined) {
+            throw usageError("Knowledge promotion requires Decision evidence, which this store does not provide.");
+        }
+        const decision = store.getDecision(task.id, parsed.decision);
+        if (decision === null) {
+            throw usageError(`Decision not found: ${parsed.decision} in Task ${task.id}.`);
+        }
+        evidence = `${decision.title}\n${decision.rationale}`;
+    }
+    else if (parsed.milestone !== undefined) {
+        if (store.getMilestone === undefined) {
+            throw usageError("Knowledge promotion requires Milestone evidence, which this store does not provide.");
+        }
+        const milestone = store.getMilestone(task.id, parsed.milestone);
+        if (milestone === null) {
+            throw usageError(`Milestone not found: ${parsed.milestone} in Task ${task.id}.`);
+        }
+        evidence = `${milestone.title}\n${milestone.summary}`;
+    }
+    else {
+        evidence = task.completionSummary ?? task.title;
+    }
+    return { ...source, evidenceDigest: knowledgeEvidenceDigest(evidence) };
+}
+function listKnowledgeProposals(args, store) {
+    const usage = "Project knowledge proposals list usage: yui project knowledge proposals list <project>"
+        + " [--status pending|accepted|rejected] [--all].";
+    const positionals = [];
+    let status = "pending";
+    let sawAll = false;
+    let sawStatus = false;
+    for (let index = 0; index < args.length; index += 1) {
+        const value = args[index];
+        if (value === "--all") {
+            if (sawStatus)
+                throw usageError(`--all and --status are mutually exclusive. ${usage}`);
+            sawAll = true;
+            status = undefined;
+        }
+        else if (value === "--status") {
+            if (sawAll)
+                throw usageError(`--all and --status are mutually exclusive. ${usage}`);
+            sawStatus = true;
+            const next = args[index + 1];
+            if (next === undefined || next.startsWith("--"))
+                throw usageError(usage);
+            if (next !== "pending" && next !== "accepted" && next !== "rejected")
+                throw usageError(usage);
+            status = next;
+            index += 1;
+        }
+        else if (value.startsWith("--")) {
+            throw usageError(`Unknown option: ${value}. ${usage}`);
+        }
+        else {
+            positionals.push(value);
+        }
+    }
+    if (positionals.length !== 1)
+        throw usageError(usage);
+    const project = requireProject(store, positionals[0]);
+    const entries = project.knowledgeProposals
+        .filter((entry) => status === undefined || entry.status === status)
+        .slice()
+        .sort((a, b) => a.id.localeCompare(b.id));
+    if (entries.length === 0) {
+        return {
+            output: "No knowledge proposals found.\n",
+            projectId: project.id,
+            proposals: []
+        };
+    }
+    return {
+        output: `${renderTable(`Knowledge proposals: ${project.name}`, [
+            { header: "Proposal", minWidth: 9, maxWidth: 24 },
+            { header: "Title", minWidth: 8, maxWidth: 48 },
+            { header: "Status", minWidth: 7, maxWidth: 10 },
+            { header: "Source", minWidth: 8, maxWidth: 32 },
+            { header: "Knowledge", minWidth: 9, maxWidth: 24 }
+        ], entries.map((entry) => [
+            entry.id,
+            entry.title,
+            entry.status,
+            `${entry.source.taskId}`
+                + `${entry.source.decisionId === undefined ? "" : `/${entry.source.decisionId}`}`
+                + `${entry.source.milestoneId === undefined ? "" : `/${entry.source.milestoneId}`}`,
+            entry.knowledgeId ?? "-"
+        ]), defaultTableWidth())}\n`,
+        projectId: project.id,
+        proposals: entries
+    };
+}
+function showKnowledgeProposal(args, store) {
+    const usage = "Project knowledge proposals show usage: yui project knowledge proposals show <project> <proposal>.";
+    if (args.length !== 2)
+        throw usageError(usage);
+    const project = requireProject(store, args[0]);
+    const proposal = findKnowledgeProposal(project, args[1]);
+    if (proposal === null) {
+        throw usageError(`Knowledge proposal not found: ${args[1]}.`);
+    }
+    const lines = [
+        `Proposal: ${proposal.id}`,
+        `Project: ${project.id}`,
+        `Title: ${proposal.title}`,
+        `Status: ${proposal.status}`,
+        `Source: ${proposal.source.taskId}`
+            + `${proposal.source.decisionId === undefined ? "" : `/${proposal.source.decisionId}`}`
+            + `${proposal.source.milestoneId === undefined ? "" : `/${proposal.source.milestoneId}`}`
+            + `${proposal.source.commitSha === undefined ? "" : `@${proposal.source.commitSha}`}`,
+        `Proposed by: ${proposal.proposedBy} at ${proposal.proposedAt}`,
+        ...(proposal.scope === undefined ? [] : [`Scope: ${proposal.scope}`]),
+        ...(proposal.expiresWhen === undefined ? [] : [`Expires when: ${proposal.expiresWhen}`]),
+        ...(proposal.supersedesKnowledgeId === undefined
+            ? []
+            : [`Supersedes: ${proposal.supersedesKnowledgeId}`]),
+        ...(proposal.evidenceDigest === undefined ? [] : [`Evidence digest: ${proposal.evidenceDigest}`]),
+        ...(proposal.decidedBy === undefined ? [] : [`Decided by: ${proposal.decidedBy} at ${proposal.decidedAt ?? "?"}`]),
+        ...(proposal.decisionReason === undefined ? [] : [`Decision reason: ${proposal.decisionReason}`]),
+        ...(proposal.knowledgeId === undefined ? [] : [`Knowledge: ${proposal.knowledgeId}`]),
+        "",
+        proposal.body
+    ];
+    return {
+        output: `${lines.join("\n")}\n`,
+        projectId: project.id,
+        proposalId: proposal.id,
+        proposals: [proposal]
+    };
+}
+/**
+ * Operator acceptance. The pure {@link planKnowledgeAcceptance} policy decides
+ * create/update/duplicate/conflict; a conflict fails closed so a candidate can
+ * never silently overwrite an existing conclusion. The accepted Knowledge
+ * entry carries the source provenance and fingerprint, and the proposal record
+ * retains the decision for history.
+ */
+function acceptKnowledgeProposal(args, store, options) {
+    const usage = "Project knowledge accept usage: yui project knowledge accept <project> <proposal>"
+        + " [--update <knowledge-id>].";
+    const parsed = parseAcceptArguments(args, usage);
+    assertKnowledgeOperator(options, "accept");
+    const actor = projectActor(options.environment);
+    const decidedBy = actor === "operator" ? "operator" : "user";
+    const now = (options.now ?? (() => new Date()))();
+    const accepted = store.transaction((tx) => {
+        const project = requireProject(tx, parsed.project);
+        const proposal = findKnowledgeProposal(project, parsed.proposal);
+        if (proposal === null) {
+            throw usageError(`Knowledge proposal not found: ${parsed.proposal}.`);
+        }
+        if (proposal.status !== "pending") {
+            throw usageError(`Knowledge proposal is already ${proposal.status}: ${proposal.id}.`);
+        }
+        let next = project;
+        let knowledgeId;
+        let duplicate = false;
+        if (parsed.update !== undefined) {
+            const target = next.knowledge.find((entry) => entry.id === parsed.update);
+            if (target === undefined) {
+                throw usageError(`Knowledge not found: ${parsed.update}.`);
+            }
+            if (target.status !== "active") {
+                throw usageError(`Knowledge is not active: ${target.id}.`);
+            }
+            knowledgeId = target.id;
+            next = updateProjectKnowledge(next, knowledgeId, {
+                title: proposal.title,
+                body: proposal.body
+            }, now);
+            next = withKnowledgeProvenance(next, knowledgeId, {
+                ...provenanceFromProposal(proposal),
+                proposalId: proposal.id,
+                promotedBy: decidedBy,
+                promotedAt: now.toISOString()
+            }, now);
+        }
+        else {
+            const plan = planKnowledgeAcceptance(next, proposal);
+            if (plan.kind === "duplicate") {
+                knowledgeId = plan.knowledgeId;
+                duplicate = true;
+            }
+            else {
+                if (plan.kind === "create" && plan.supersedesKnowledgeId !== undefined) {
+                    next = retireProjectKnowledge(next, plan.supersedesKnowledgeId, now);
+                }
+                knowledgeId = nextKnowledgeId(next);
+                next = addProjectKnowledge(next, knowledgeId, proposal.title, proposal.body, now, {
+                    ...provenanceFromProposal(proposal),
+                    proposalId: proposal.id,
+                    promotedBy: decidedBy,
+                    promotedAt: now.toISOString()
+                });
+            }
+        }
+        next = decideKnowledgeProposal(next, proposal.id, {
+            by: decidedBy,
+            knowledgeId
+        }, now);
+        tx.saveProject(next);
+        return { projectId: next.id, proposalId: proposal.id, knowledgeId, duplicate };
+    });
+    return {
+        output: `${accepted.duplicate
+            ? `Knowledge proposal ${accepted.proposalId} was already promoted as ${accepted.knowledgeId}`
+            : `Accepted knowledge proposal ${accepted.proposalId} as ${accepted.knowledgeId}`} in ${accepted.projectId}\n`,
+        projectId: accepted.projectId,
+        proposalId: accepted.proposalId,
+        knowledgeId: accepted.knowledgeId
+    };
+}
+function rejectKnowledgeProposal(args, store, options) {
+    const usage = "Project knowledge reject usage: yui project knowledge reject <project> <proposal>"
+        + " --reason <text>.";
+    const parsed = parseSingleOption(args, "--reason", usage);
+    if (parsed.positionals.length !== 2)
+        throw usageError(usage);
+    assertKnowledgeOperator(options, "reject");
+    const actor = projectActor(options.environment);
+    const decidedBy = actor === "operator" ? "operator" : "user";
+    const rejected = store.transaction((tx) => {
+        const project = requireProject(tx, parsed.positionals[0]);
+        const proposal = findKnowledgeProposal(project, parsed.positionals[1]);
+        if (proposal === null) {
+            throw usageError(`Knowledge proposal not found: ${parsed.positionals[1]}.`);
+        }
+        if (proposal.status !== "pending") {
+            throw usageError(`Knowledge proposal is already ${proposal.status}: ${proposal.id}.`);
+        }
+        const next = decideKnowledgeProposal(project, proposal.id, {
+            by: decidedBy,
+            reason: parsed.value
+        }, (options.now ?? (() => new Date()))());
+        tx.saveProject(next);
+        return { projectId: next.id, proposalId: proposal.id };
+    });
+    return {
+        output: `Rejected knowledge proposal ${rejected.proposalId} in ${rejected.projectId}\n`,
+        projectId: rejected.projectId,
+        proposalId: rejected.proposalId
+    };
+}
+function provenanceFromProposal(proposal) {
+    return {
+        taskId: proposal.source.taskId,
+        ...(proposal.source.decisionId === undefined ? {} : { decisionId: proposal.source.decisionId }),
+        ...(proposal.source.milestoneId === undefined ? {} : { milestoneId: proposal.source.milestoneId }),
+        ...(proposal.source.commitSha === undefined ? {} : { commitSha: proposal.source.commitSha }),
+        ...(proposal.evidenceDigest === undefined ? {} : { evidenceDigest: proposal.evidenceDigest }),
+        fingerprint: proposal.fingerprint
+    };
+}
+/** Replace a Knowledge entry's provenance (used by accept --update). */
+function withKnowledgeProvenance(project, knowledgeId, provenance, now) {
+    const timestamp = now.toISOString();
+    const knowledge = project.knowledge.map((entry) => (entry.id === knowledgeId
+        ? { ...entry, provenance, updatedAt: timestamp }
+        : entry));
+    return validateProject({ ...project, knowledge, updatedAt: timestamp });
+}
+function parseAcceptArguments(args, usage) {
+    const positionals = [];
+    let update;
+    for (let index = 0; index < args.length; index += 1) {
+        const value = args[index];
+        if (value === "--update") {
+            if (update !== undefined)
+                throw usageError(`--update may only be provided once. ${usage}`);
+            const next = args[index + 1];
+            if (next === undefined || next.startsWith("--"))
+                throw usageError(`--update is required. ${usage}`);
+            update = requireText(next, "--update");
+            index += 1;
+        }
+        else if (value.startsWith("--")) {
+            throw usageError(`Unknown option: ${value}. ${usage}`);
+        }
+        else {
+            positionals.push(value);
+        }
+    }
+    if (positionals.length !== 2)
+        throw usageError(usage);
+    return { project: positionals[0], proposal: positionals[1], ...(update === undefined ? {} : { update }) };
+}
 function parseAddArguments(args, usage) {
     const positionals = [];
     const aliases = [];