akm-cli 0.9.26-alpha.1 → 0.9.26

package/dist/commands/improve/preparation.js

@@ -34,6 +34,7 @@ import { runSchemaRepairPass } from "../sources/schema-repair.js";
 import { isAutonomyLaneAllowed } from "./autonomy-gate.js";
 import { akmConsolidate, inspectConsolidationPool, loadExistingKnowledgeBodyHashes, makeConsolidateResult, } from "./consolidate.js";
 import { computeSafeChunkSize, DEFAULT_CONTEXT_LENGTH_TOKENS } from "./consolidate/chunking.js";
+import { contentHash } from "./content-hash.js";
 import { assetTypeOf, buildUtilityMap, dedupeRefs, findAssetFilePath, isDistillCandidateRef, isLessonCandidate, resolveImproveScope, withIndexDb, } from "./eligibility.js";
 import { akmExtract, countNewExtractCandidates } from "./extract.js";
 import { computeValenceScore } from "./feedback-valence.js";
@@ -545,6 +546,51 @@ function isSignalEvent(metadata) {
     const meta = metadata;
     return meta !== undefined && (typeof meta.signal === "string" || typeof meta.note === "string");
 }
+/**
+ * Whether `candidate` was flagged wrong and not edited since. A negative
+ * feedback inside the signal window that recorded the hash of the body it
+ * judged flags it exactly when the body still has that hash, so a later write
+ * that leaves the text alone (an inference stamp, a frontmatter repair) does not
+ * lift the flag. One without a hash flags it when it is newer than the file's
+ * last write: its mtime, the one the retrieval scope reads for new material. A
+ * candidate with no readable file is not flagged.
+ */
+export function isFlaggedSinceLastEdit(candidate, eventsCtx) {
+    if (!candidate.filePath)
+        return false;
+    let editedAtMs;
+    let bodyHash;
+    try {
+        editedAtMs = fs.statSync(candidate.filePath).mtimeMs;
+        bodyHash = contentHash(fs.readFileSync(candidate.filePath, "utf8"), "body");
+    }
+    catch {
+        return false;
+    }
+    const since = new Date(Date.now() - daysToMs(FEEDBACK_SIGNAL_WINDOW_DAYS)).toISOString();
+    return readEvents({ type: "feedback", ref: keyOf(candidate), since }, eventsCtx).events.some((e) => {
+        const meta = e.metadata;
+        if (meta?.signal !== "negative")
+            return false;
+        return typeof meta.contentHash === "string" ? meta.contentHash === bodyHash : Date.parse(e.ts) > editedAtMs;
+    });
+}
+/**
+ * Whether the only feedback `candidate` has inside the signal window is positive and says nothing: no reason, no
+ * note. A bare `--positive` only records that a note helped, which gives the writer nothing to distil, so it restates
+ * the memory: 10 of the 11 lessons distilled from a memory with nothing more were rejected (the 2026-10-05 review).
+ * A candidate with no feedback in the window is not matched.
+ */
+export function hasOnlyBarePositiveFeedback(candidate, eventsCtx) {
+    const since = new Date(Date.now() - daysToMs(FEEDBACK_SIGNAL_WINDOW_DAYS)).toISOString();
+    const signals = readEvents({ type: "feedback", ref: keyOf(candidate), since }, eventsCtx).events.filter((e) => isSignalEvent(e.metadata));
+    const hasText = (value) => typeof value === "string" && value.trim() !== "";
+    return (signals.length > 0 &&
+        signals.every((e) => {
+            const meta = e.metadata;
+            return meta.signal === "positive" && !hasText(meta.reason) && !hasText(meta.note);
+        }));
+}
 /** One read of the feedback events and the ledger's reflect/distill rows. */
 export function buildSnapshotManifest(args) {
     const { eventsCtx, stashDir } = args;

package/dist/commands/improve/reflect.js

@@ -38,6 +38,7 @@ import { isJsonSchemaKnownUnsupported, LlmCallError } from "../../llm/client.js"
 import { baseFailureFields, enoentHintMessage, isEnoentFailure } from "../agent/agent-support.js";
 import { isValidDescription } from "../proposal/validators/proposal-quality-validators.js";
 import { CHARS_PER_TOKEN, DEFAULT_CONTEXT_LENGTH_TOKENS } from "./consolidate/chunking.js";
+import { contentHash } from "./content-hash.js";
 import { findAssetFilePath } from "./eligibility.js";
 import { resolveImproveExecution } from "./execution.js";
 import { recordLedgerAttempt } from "./ledger.js";
@@ -46,19 +47,29 @@ import { loadRetrievalQueries, runRetrievalRegressionGate } from "./retrieval-ga
 import { callStageOnce, errMessage, mintProposal, noticeSet, rejectedProposalContext, resolveQualityGateJudge, runReflectQualityJudge, } from "./stage.js";
 const MAX_FEEDBACK_LINES = 10;
 const MAX_GLOBAL_FEEDBACK_LINES = 20;
+/** Ends a feedback line whose event judged text the asset no longer has. */
+const EARLIER_TEXT_MARK = " (given on an earlier version of the text)";
 function readOnlyEventsContext(ctx) {
     return ctx?.db ? ctx : { ...(ctx ?? {}), readOnly: true };
 }
-/** Recent `feedback` lines for `ref` (or across all assets without one). Best-effort. */
-function readRecentFeedback(ref, eventsCtx) {
+/**
+ * Recent `feedback` lines for `ref` (or across all assets without one). Given the
+ * asset's current content, a line whose event recorded the hash of a different
+ * body is marked. Best-effort.
+ */
+function readRecentFeedback(ref, eventsCtx, assetContent) {
     try {
         const events = readEvents({ type: "feedback", ...(ref ? { ref } : {}) }, readOnlyEventsContext(eventsCtx)).events;
+        const bodyHash = assetContent === undefined ? undefined : contentHash(assetContent, "body");
         return events.slice(-(ref ? MAX_FEEDBACK_LINES : MAX_GLOBAL_FEEDBACK_LINES)).map((event) => {
             const md = event.metadata ?? {};
             const signal = typeof md.signal === "string" ? md.signal : "?";
             const note = typeof md.reason === "string" ? md.reason : typeof md.note === "string" ? md.note : "";
             const details = note ? `[${signal}] ${note}` : `[${signal}]`;
-            return !ref && event.ref ? `${event.ref} ${details}` : details;
+            const line = !ref && event.ref ? `${event.ref} ${details}` : details;
+            return bodyHash !== undefined && typeof md.contentHash === "string" && md.contentHash !== bodyHash
+                ? `${line}${EARLIER_TEXT_MARK}`
+                : line;
         });
     }
     catch {
@@ -636,7 +647,7 @@ function computeReflectContentBudgetChars(promptInput, runnerSpec) {
 /** Every read-only prompt input, shared by dispatch and `--show-prompt`. */
 function gatherReflectPromptSources(options, stash, parsedRef, assetContent) {
     return {
-        feedback: readRecentFeedback(options.ref ? (options.itemRef ?? options.ref) : undefined, options.eventsCtx),
+        feedback: readRecentFeedback(options.ref ? (options.itemRef ?? options.ref) : undefined, options.eventsCtx, assetContent),
         schemaHints: buildSchemaHints(parsedRef?.type ?? "", assetContent),
         rejectedProposals: rejectedProposalContext(stash, options.ref, options.ctx, options.eventsCtx),
         standardsContext: resolveStandardsContext(options.ref, stash),

package/dist/commands/proposal/repository.js

@@ -13,12 +13,13 @@ import { randomUUID } from "node:crypto";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { isDeepStrictEqual } from "node:util";
 import { parse as parseYaml } from "yaml";
 import { ensureAkmMarkdownType } from "../../core/asset/akm-markdown.js";
 import { assetPathForName, placementTypes, stashDirFor } from "../../core/asset/asset-placement.js";
 import { isBundleSlug, parseBundleRef } from "../../core/asset/asset-ref.js";
 import { assembleAsset, serializeFrontmatter } from "../../core/asset/asset-serialize.js";
-import { carryForwardBookkeepingFrontmatter, parseFrontmatter } from "../../core/asset/frontmatter.js";
+import { carryForwardBookkeepingFrontmatter, parseFrontmatter, replaceFrontmatterBlocks, } from "../../core/asset/frontmatter.js";
 import { conceptIdFromTypeName, parseRefInput } from "../../core/asset/resolve-ref.js";
 import { loadConfig } from "../../core/config/config.js";
 import { ConfigError, NotFoundError, rethrowIfTestIsolationError, UsageError } from "../../core/errors.js";
@@ -287,6 +288,7 @@ export function createProposal(stashDir, input, ctx) {
             ...(input.eligibilitySource !== undefined ? { eligibilitySource: input.eligibilitySource } : {}),
             ...(input.promotionSource !== undefined ? { promotionSource: input.promotionSource } : {}),
             ...(input.promotionSourceHash !== undefined ? { promotionSourceHash: input.promotionSourceHash } : {}),
+            ...(input.feedback !== undefined ? { feedback: input.feedback } : {}),
         };
         upsertProposal(db, proposal, stashDir);
         for (const ref of input.attemptedRefs ?? [normalizedRef]) {
@@ -882,8 +884,17 @@ function isPlainRecord(value) {
  * Stamp provenance onto a promoted asset's frontmatter: bare top-level
  * `generated` and `verified` (as OKF v0.2 spells them; `verified` accumulates),
  * and `sources` under `provenance:`, since a bare `sources:` is the wiki
- * citation-string convention. An existing frontmatter block keeps its raw body
- * bytes.
+ * citation-string convention.
+ *
+ * Source preservation: an existing frontmatter block is edited as text and not
+ * written out again through the YAML serializer, which rewraps long values,
+ * requotes and drops comments in lines the stamp never touched. The blocks of
+ * the keys the stamp sets (`generated`, `verified`, `provenance`) are removed
+ * wherever they were and written again, serialized, as the last lines of the
+ * frontmatter; every other byte, the body included, stays as written. The
+ * edited text is parsed back to confirm it holds exactly the intended mapping;
+ * when it does not (an indented `---` inside a block scalar), the frontmatter is
+ * written out again instead, as it always used to be.
  */
 function stampProposalProvenance(content, proposal, gateDecision, ctx, nowIsoStr) {
     const parsed = parseFrontmatter(content);
@@ -916,9 +927,15 @@ function stampProposalProvenance(content, proposal, gateDecision, ctx, nowIsoStr
         fm.provenance = provenance;
     else
         delete fm.provenance;
-    return parsed.frontmatter !== null
-        ? `---\n${serializeFrontmatter(fm)}\n---\n${parsed.content}`
-        : assembleAsset(fm, parsed.content);
+    if (parsed.frontmatter === null)
+        return assembleAsset(fm, parsed.content);
+    const stamped = { generated: fm.generated, verified: fm.verified };
+    if (fm.provenance !== undefined)
+        stamped.provenance = fm.provenance;
+    const edited = replaceFrontmatterBlocks(content, ["generated", "verified", "provenance"], serializeFrontmatter(stamped).split("\n"));
+    if (edited !== null && isDeepStrictEqual(parseFrontmatter(edited).data, fm))
+        return edited;
+    return `---\n${serializeFrontmatter(fm)}\n---\n${parsed.content}`;
 }
 /**
  * Validate, stamp and write an accepted proposal into its bound target, then

package/dist/core/asset/akm-markdown.js

@@ -1,11 +1,12 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
+import { isDeepStrictEqual } from "node:util";
 import { parse as parseYaml } from "yaml";
 import { localDateStamp } from "../common.js";
 import { UsageError } from "../errors.js";
 import { serializeFrontmatter } from "./asset-serialize.js";
-import { parseFrontmatterBlock, spliceFrontmatterLine } from "./frontmatter.js";
+import { parseFrontmatterBlock, replaceFrontmatterLine, spliceFrontmatterLine } from "./frontmatter.js";
 /**
  * Ensure an AKM-authored Markdown concept is also a conformant OKF concept.
  *
@@ -20,12 +21,18 @@ import { parseFrontmatterBlock, spliceFrontmatterLine } from "./frontmatter.js";
  * re-stamp on every write (which would churn timestamps and manufacture
  * needless diffs in git-backed bundles).
  *
- * Source preservation: when the type already matches and the ONLY change is
- * adding `updated`, the line is spliced into the original block textually —
- * round-tripping through the YAML serializer would drop user-authored
- * comments and normalize formatting just to contribute one field. Only a
- * document whose `type` must actually be corrected takes the re-serialize
- * path (as it always has).
+ * Source preservation: whenever the frontmatter block parses, it is edited as
+ * text and never round-tripped through the YAML serializer, which rewraps long
+ * values, reorders keys and drops comments — changes nobody made, shown to the
+ * reviewer of what may be a one-line correction. A missing `type` and a
+ * missing `updated` are each added as one line before the closing `---`, in
+ * that order; a wrong `type` is replaced on its own line. Every other byte —
+ * comments, wrapping, quoting, key order, line endings, the body — is kept as
+ * written. The edited text is parsed back to confirm it holds exactly the
+ * intended mapping; when it does not (a `type` value that spans several lines,
+ * a flow-style `{…}` block), the document is re-serialized instead, as it
+ * always used to be. A document with no frontmatter block gets a new one;
+ * malformed YAML throws.
  */
 export function ensureAkmMarkdownType(content, type, now = new Date()) {
     const block = parseFrontmatterBlock(content);
@@ -45,19 +52,36 @@ export function ensureAkmMarkdownType(content, type, now = new Date()) {
         throw new UsageError("AKM Markdown frontmatter must be a YAML mapping.", "INVALID_FLAG_VALUE");
     }
     const data = parsed;
+    const updated = localDateStamp(now);
     const needsUpdated = !("updated" in data);
-    if (data.type === type) {
-        if (!needsUpdated)
-            return content;
-        const spliced = spliceFrontmatterLine(content, `updated: ${localDateStamp(now)}`);
-        if (spliced !== null)
-            return spliced;
-        // Unreachable in practice (parseFrontmatterBlock succeeded above), but a
-        // re-serialized document beats a non-conformant one.
+    if (data.type === type && !needsUpdated)
+        return content;
+    let edited = content;
+    if (data.type !== type) {
+        edited =
+            "type" in data
+                ? replaceFrontmatterLine(edited, "type", `type: ${type}`)
+                : spliceFrontmatterLine(edited, `type: ${type}`);
     }
+    if (edited !== null && needsUpdated)
+        edited = spliceFrontmatterLine(edited, `updated: ${updated}`);
+    const intended = needsUpdated ? { ...data, type, updated } : { ...data, type };
+    if (edited !== null && parsesTo(edited, intended))
+        return edited;
+    // The text edit could not be done safely, but a re-serialized document
+    // beats a non-conformant one.
     const { type: _priorType, ...rest } = data;
     const next = { type, ...rest };
     if (needsUpdated)
-        next.updated = localDateStamp(now);
+        next.updated = updated;
     return `---\n${serializeFrontmatter(next)}\n---\n${block.content}`;
 }
+/** True when the frontmatter of `text` parses to exactly `intended`. */
+function parsesTo(text, intended) {
+    try {
+        return isDeepStrictEqual(parseYaml(parseFrontmatterBlock(text)?.frontmatter ?? ""), intended);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/core/asset/frontmatter.js

@@ -196,17 +196,77 @@ function countLines(text) {
  * frontmatter: round-tripping the mapping through the YAML serializer drops
  * comments and normalizes formatting, which is unacceptable for a write that
  * only needs to contribute one line. Shared by `ensureAkmMarkdownType`
- * (stamping `updated:` on write) and lint's `--fix` for `missing-updated`.
+ * (adding `type:` and `updated:` on write) and lint's `--fix` for
+ * `missing-updated`. The new line takes the block's own line ending.
  */
 export function spliceFrontmatterLine(raw, line) {
-    const lines = raw.split(/\r?\n/);
-    if (lines[0]?.trim() !== "---")
+    // Alternating [line, eol, line, eol, …, line]: joining the parts back
+    // reproduces `raw` byte for byte, CRLF and all.
+    const parts = raw.split(/(\r?\n)/);
+    if (parts[0]?.trim() !== "---")
         return null;
-    const closeIdx = lines.findIndex((l, i) => i > 0 && l.trim() === "---");
-    if (closeIdx === -1)
+    const closeAt = parts.findIndex((part, i) => i > 0 && part.trim() === "---");
+    if (closeAt === -1)
+        return null;
+    parts.splice(closeAt, 0, line, parts[1]);
+    return parts.join("");
+}
+/**
+ * Replace the top-level `key:` line of an existing frontmatter block with
+ * `line`, leaving every other byte untouched — the counterpart to
+ * {@link spliceFrontmatterLine} for correcting a field's value in place.
+ *
+ * Only that one physical line is replaced, so a value that continues onto
+ * further lines (a block sequence, a folded scalar) would be left dangling:
+ * the caller must check that the result still parses to what it meant. Returns
+ * null when `raw` has no well-formed block or no such line.
+ */
+export function replaceFrontmatterLine(raw, key, line) {
+    const parts = raw.split(/(\r?\n)/);
+    if (parts[0]?.trim() !== "---")
+        return null;
+    const closeAt = parts.findIndex((part, i) => i > 0 && part.trim() === "---");
+    if (closeAt === -1)
         return null;
-    lines.splice(closeIdx, 0, line);
-    return lines.join("\n");
+    const at = parts.findIndex((part, i) => i > 0 && i < closeAt && part.match(/^(\w[\w-]*):(?:[ \t]|$)/)?.[1] === key);
+    if (at === -1)
+        return null;
+    parts[at] = line;
+    return parts.join("");
+}
+/**
+ * Replace the top-level blocks of `keys` in an existing frontmatter block with
+ * `lines`, leaving every other byte untouched — the counterpart to
+ * {@link spliceFrontmatterLine} for a write that owns whole keys, such as the
+ * provenance stamp's `generated`, `verified` and `provenance`.
+ *
+ * A key's block is its `key:` line and the lines directly under it that
+ * continue it: indented lines and `- ` items. Every such block is removed
+ * wherever it sits, and `lines` are added just before the closing `---`, in the
+ * block's own line ending. A block with a blank line or a comment inside it is
+ * not removed whole, so the caller must check that the result still parses to
+ * what it meant. Returns null when `raw` has no well-formed block.
+ */
+export function replaceFrontmatterBlocks(raw, keys, lines) {
+    const parts = raw.split(/(\r?\n)/);
+    if (parts[0]?.trim() !== "---")
+        return null;
+    const closeAt = parts.findIndex((part, i) => i > 0 && part.trim() === "---");
+    if (closeAt === -1)
+        return null;
+    const kept = [];
+    for (let i = 2; i < closeAt; i += 2) {
+        const key = parts[i].match(/^(\w[\w-]*):(?:[ \t]|$)/)?.[1];
+        if (key === undefined || !keys.includes(key)) {
+            kept.push(parts[i], parts[i + 1]);
+            continue;
+        }
+        // One of the keys: drop its line and the lines that continue it.
+        while (i + 2 < closeAt && /^(?:[ \t]|-(?:[ \t]|$))/.test(parts[i + 2]))
+            i += 2;
+    }
+    const added = lines.flatMap((line) => [line, parts[1]]);
+    return [parts[0], parts[1], ...kept, ...added, ...parts.slice(closeAt)].join("");
 }
 /**
  * Strip one layer of matching quotes — frontmatter list items are often quoted

package/dist/core/config/config-schema.js

@@ -59,7 +59,7 @@ import { WorkflowConfigSchema } from "./schema/workflow.js";
 export { EmbeddingConnectionConfigSchema } from "./schema/embedding.js";
 export { EngineConfigSchema, EnginesSchema, LlmConnectionConfigSchema, LlmProfileConfigSchema } from "./schema/engines.js";
 export { ExperimentalConfigSchema } from "./schema/experimental.js";
-export { FEEDBACK_FAILURE_MODES, FeedbackConfigSchema } from "./schema/feedback.js";
+export { FeedbackConfigSchema } from "./schema/feedback.js";
 export { ImproveConfigSchema } from "./schema/improve.js";
 export { ConsolidateProcessConfigSchema, DistillProcessConfigSchema, ExtractProcessConfigSchema, ImproveProcessConfigSchema, ImproveProfileConfigSchema, MemoryInferenceProcessConfigSchema, ProactiveMaintenanceProcessConfigSchema, ReflectProcessConfigSchema, TriageProcessConfigSchema, ValidationProcessConfigSchema, } from "./schema/improve-processes.js";
 export { IndexConfigSchema, IndexPassConfigSchema } from "./schema/index-config.js";

package/dist/core/config/config.js

@@ -23,10 +23,6 @@ import { getConfigPath } from "../paths.js";
 import { warn, warnOnce } from "../warn.js";
 // Canonical harness-id source of truth (#565) — runtime value re-export.
 export { VALID_HARNESS_IDS } from "./config-types.js";
-// ── Feedback failure-mode constants (F-3 / #384) ────────────────────────────
-// Canonical taxonomy lives in the schema/validator layer; re-exported here so
-// existing `../core/config/config` import sites keep working.
-export { FEEDBACK_FAILURE_MODES } from "./config-schema.js";
 // ── Defaults ────────────────────────────────────────────────────────────────
 export const DEFAULT_CONFIG = {
     configVersion: "0.9.0",

package/dist/core/config/schema/feedback.js

@@ -2,30 +2,13 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 /**
- * Feedback taxonomy + `feedback` config section. Extracted verbatim from the
- * former `config-schema.ts` monolith — no behavior change.
+ * `feedback` config section. The retired `allowedFailureModes` key (it went
+ * with `akm feedback --failure-mode`) is tolerated as an unknown key.
  */
 import { z } from "zod";
-import { nonEmptyString } from "./primitives.js";
-// ── Feedback failure modes (F-3 / #384) ─────────────────────────────────────
-/**
- * Curated taxonomy of failure modes for negative feedback.
- *
- * Structured failure modes enable aggregation across feedback events so the
- * distill pipeline can detect that "5 assets failed for the same reason" and
- * act on it — free-text strings about the same issue are not aggregatable.
- */
-export const FEEDBACK_FAILURE_MODES = [
-    "incorrect", // Factually wrong or logically flawed content
-    "outdated", // Correct at some point but now stale
-    "dangerous", // Could cause harm if followed (security, safety)
-    "incomplete", // Missing key steps, context, or caveats
-    "redundant", // Duplicates another asset without adding value
-];
 // ── Feedback ────────────────────────────────────────────────────────────────
 export const FeedbackConfigSchema = z
     .object({
     requireReason: z.boolean().optional(),
-    allowedFailureModes: z.array(nonEmptyString).optional(),
 })
     .passthrough();

package/dist/output/shapes/helpers.js

@@ -85,6 +85,7 @@ export function shapeProposalEntry(entry, detail) {
             "updatedAt",
             "confidence",
             "gateDecision",
+            "feedback",
             "review",
             "reviewHistory",
             "retirement",
@@ -101,6 +102,7 @@ export function shapeProposalEntry(entry, detail) {
         "updatedAt",
         "confidence",
         "gateDecision",
+        "feedback",
         "payload",
         "review",
         "reviewHistory",

package/dist/output/text/proposal-format.js

@@ -183,6 +183,11 @@ export function formatProposalShowPlain(r) {
         if (gate.decidedAt)
             lines.push(`gate.decidedAt: ${String(gate.decidedAt)}`);
     }
+    const fix = p.feedback;
+    if (fix) {
+        lines.push(`feedback.reason: ${String(fix.reason)}`);
+        lines.push(`feedback.source: ${String(fix.source)}`);
+    }
     const review = p.review;
     if (review) {
         lines.push(`review.outcome: ${String(review.outcome ?? "?")}`);

package/dist/scripts/akm-migrate-node.js

@@ -28539,6 +28539,7 @@ function shapeProposalEntry(entry, detail) {
       "updatedAt",
       "confidence",
       "gateDecision",
+      "feedback",
       "review",
       "reviewHistory",
       "retirement"
@@ -28554,6 +28555,7 @@ function shapeProposalEntry(entry, detail) {
     "updatedAt",
     "confidence",
     "gateDecision",
+    "feedback",
     "payload",
     "review",
     "reviewHistory",
@@ -30491,6 +30493,11 @@ function formatProposalShowPlain(r) {
     if (gate.decidedAt)
       lines.push(`gate.decidedAt: ${String(gate.decidedAt)}`);
   }
+  const fix = p.feedback;
+  if (fix) {
+    lines.push(`feedback.reason: ${String(fix.reason)}`);
+    lines.push(`feedback.source: ${String(fix.source)}`);
+  }
   const review = p.review;
   if (review) {
     lines.push(`review.outcome: ${String(review.outcome ?? "?")}`);
@@ -35838,8 +35845,7 @@ var ExperimentalConfigSchema = exports_external.object({
 
 // src/core/config/schema/feedback.ts
 var FeedbackConfigSchema = exports_external.object({
-  requireReason: exports_external.boolean().optional(),
-  allowedFailureModes: exports_external.array(nonEmptyString).optional()
+  requireReason: exports_external.boolean().optional()
 }).passthrough();
 
 // src/core/config/schema/improve-processes.ts

package/dist/scripts/akm-migrate.js

@@ -27867,6 +27867,7 @@ function shapeProposalEntry(entry, detail) {
       "updatedAt",
       "confidence",
       "gateDecision",
+      "feedback",
       "review",
       "reviewHistory",
       "retirement"
@@ -27882,6 +27883,7 @@ function shapeProposalEntry(entry, detail) {
     "updatedAt",
     "confidence",
     "gateDecision",
+    "feedback",
     "payload",
     "review",
     "reviewHistory",
@@ -29819,6 +29821,11 @@ function formatProposalShowPlain(r) {
     if (gate.decidedAt)
       lines.push(`gate.decidedAt: ${String(gate.decidedAt)}`);
   }
+  const fix = p.feedback;
+  if (fix) {
+    lines.push(`feedback.reason: ${String(fix.reason)}`);
+    lines.push(`feedback.source: ${String(fix.source)}`);
+  }
   const review = p.review;
   if (review) {
     lines.push(`review.outcome: ${String(review.outcome ?? "?")}`);
@@ -35166,8 +35173,7 @@ var ExperimentalConfigSchema = exports_external.object({
 
 // src/core/config/schema/feedback.ts
 var FeedbackConfigSchema = exports_external.object({
-  requireReason: exports_external.boolean().optional(),
-  allowedFailureModes: exports_external.array(nonEmptyString).optional()
+  requireReason: exports_external.boolean().optional()
 }).passthrough();
 
 // src/core/config/schema/improve-processes.ts

package/dist/storage/repositories/proposals-repository.js

@@ -171,6 +171,12 @@ function validatePresentMetadata(meta) {
             }
         }
     }
+    if (Object.hasOwn(meta, "feedback")) {
+        const fix = meta.feedback;
+        if (!isRecord(fix) || typeof fix.reason !== "string" || typeof fix.source !== "string") {
+            invalidPresentField("feedback");
+        }
+    }
     if (Object.hasOwn(meta, "acceptedTarget")) {
         const target = meta.acceptedTarget;
         if (typeof target !== "object" ||
@@ -293,6 +299,7 @@ export function proposalRowToProposal(row) {
         ...(meta.reviewHistory !== undefined ? { reviewHistory: meta.reviewHistory } : {}),
         ...(typeof meta.confidence === "number" ? { confidence: meta.confidence } : {}),
         ...(meta.gateDecision !== undefined ? { gateDecision: meta.gateDecision } : {}),
+        ...(meta.feedback !== undefined ? { feedback: meta.feedback } : {}),
         ...(typeof meta.backupContent === "string" ? { backupContent: meta.backupContent } : {}),
         ...(meta.acceptedTarget !== undefined ? { acceptedTarget: meta.acceptedTarget } : {}),
         ...(typeof meta.eligibilitySource === "string"
@@ -359,6 +366,8 @@ export function proposalToRowValues(proposal, stashDir) {
         metaObj.confidence = proposal.confidence;
     if (proposal.gateDecision !== undefined)
         metaObj.gateDecision = proposal.gateDecision;
+    if (proposal.feedback !== undefined)
+        metaObj.feedback = proposal.feedback;
     if (proposal.backupContent !== undefined)
         metaObj.backupContent = proposal.backupContent;
     if (proposal.acceptedTarget !== undefined)