fraim 2.0.346 → 2.0.348

package/dist/registry/scripts/learning/completion-state.js

@@ -4,10 +4,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.COMPLETION_END = exports.COMPLETION_START = exports.UnsupportedRunHistoryError = exports.sourcePathKey = void 0;
+exports.validateDeferredAttempt = validateDeferredAttempt;
+exports.validateDeferredWork = validateDeferredWork;
 exports.cycleRetrospectivePath = cycleRetrospectivePath;
 exports.validateProcessedSources = validateProcessedSources;
 exports.canonicalJournal = canonicalJournal;
 exports.readRunJournal = readRunJournal;
+exports.readRunReservations = readRunReservations;
 exports.readSourceReservations = readSourceReservations;
 exports.normalizeSourceParticipants = normalizeSourceParticipants;
 exports.sourceAuthorAllowed = sourceAuthorAllowed;
@@ -17,6 +20,33 @@ const node_fs_1 = __importDefault(require("node:fs"));
 const node_crypto_1 = require("node:crypto");
 const artifact_paths_1 = require("../artifact-paths");
 const corpus_audit_1 = require("./corpus-audit");
+const outcome_types_1 = require("./outcome-types");
+function validateDeferredAttempt(value) {
+    if (!keys(value, ['at', 'evidenceHash', 'deferred', 'reason']) || !text(value.at) || !Number.isFinite(Date.parse(value.at)) || !hash(value.evidenceHash))
+        throw new Error('invalid-deferred-attempt');
+    // Older journals embedded the checkpoint snapshot; keep accepting those exact records.
+    if (value.deferred !== undefined && value.reason === undefined)
+        validateDeferredWork(value.deferred);
+    else if (value.deferred !== undefined || !text(value.reason))
+        throw new Error('invalid-deferred-attempt');
+}
+function validateDeferredWork(value) {
+    if (!keys(value, ['actions', 'sources', 'corpusComplete', 'corpusErrors']) || value.corpusComplete !== false || !Array.isArray(value.actions) || !Array.isArray(value.sources))
+        throw new Error('invalid-deferred-work');
+    if (value.corpusErrors !== undefined && (!Array.isArray(value.corpusErrors) || value.corpusErrors.some(item => !keys(item, ['path', 'reason']) || !text(item.path) || !node_path_1.default.isAbsolute(item.path) || !text(item.reason))))
+        throw new Error('invalid-deferred-work');
+    const actions = new Set(), sources = new Set();
+    for (const item of value.actions) {
+        if (!keys(item, ['actionId', 'revision', 'digest', 'reason']) || !text(item.actionId) || !Number.isInteger(item.revision) || item.revision < 1 || !hash(item.digest) || !text(item.reason) || actions.has(item.actionId))
+            throw new Error('invalid-deferred-work');
+        actions.add(item.actionId);
+    }
+    for (const item of value.sources) {
+        if (!keys(item, ['path', 'owner', 'reason', 'sha256']) || !text(item.path) || !node_path_1.default.isAbsolute(item.path) || /[\x00-\x1f]/.test(item.path) || !ownerValid(item.owner) || !text(item.reason) || (item.sha256 !== undefined && !hash(item.sha256)) || sources.has((0, exports.sourcePathKey)(item.path)))
+            throw new Error('invalid-deferred-work');
+        sources.add((0, exports.sourcePathKey)(item.path));
+    }
+}
 const sourcePathKey = (file) => {
     const value = node_path_1.default.resolve(file).replace(/\\/g, '/');
     return process.platform === 'win32' ? value.toLowerCase() : value;
@@ -145,9 +175,10 @@ function readRunJournal(file) {
     }
     return { events, lastHash, format: 'current' };
 }
-/** Only exact, hash-chain-verified current archive plans reserve files. Older plans are outside this lifecycle. */
-function readSourceReservations(runDirectories, excludingRunFile) {
+/** Current archive plans and prepared assessments share one verified reservation inventory. */
+function readRunReservations(runDirectories, excludingRunFile) {
     const reserved = new Set();
+    const assessmentKeys = new Set();
     for (const directory of new Set(runDirectories.map(dir => node_path_1.default.resolve(dir)))) {
         let names;
         try {
@@ -168,6 +199,23 @@ function readSourceReservations(runDirectories, excludingRunFile) {
                 const journal = readRunJournal(file);
                 if (journal.format === 'historical')
                     continue;
+                const assessmentSources = new Map();
+                for (const event of journal.events) {
+                    if (event.payload.type === 'assessment-prepared') {
+                        const { record, sourcePaths } = event.payload.data;
+                        (0, outcome_types_1.validateOutcomeAssessmentRecord)(record);
+                        if (!Array.isArray(sourcePaths) || sourcePaths.length !== record.sourceRefs.length || sourcePaths.some(file => typeof file !== 'string' || !node_path_1.default.isAbsolute(file)))
+                            throw new Error('invalid-assessment-sources');
+                        assessmentSources.set(record.digest, { paths: sourcePaths, key: (0, outcome_types_1.assessmentKey)(record) });
+                    }
+                    else if (event.payload.type === 'assessment-committed')
+                        assessmentSources.delete(event.payload.data.digest);
+                }
+                for (const reservation of assessmentSources.values()) {
+                    assessmentKeys.add(reservation.key);
+                    for (const source of reservation.paths)
+                        reserved.add((0, exports.sourcePathKey)(source));
+                }
                 for (const event of journal.events)
                     if (event.payload.type === 'source-completion') {
                         for (const source of event.payload.data) {
@@ -183,7 +231,10 @@ function readSourceReservations(runDirectories, excludingRunFile) {
             }
         }
     }
-    return [...reserved].sort();
+    return { sources: [...reserved].sort(), assessmentKeys: [...assessmentKeys].sort() };
+}
+function readSourceReservations(runDirectories, excludingRunFile) {
+    return readRunReservations(runDirectories, excludingRunFile).sources;
 }
 exports.COMPLETION_START = '<!-- fraim-sleep-decisions:v1 -->';
 exports.COMPLETION_END = '<!-- /fraim-sleep-decisions -->';
@@ -234,7 +285,7 @@ function decodeCompletion(markdown, expected = {}) {
     catch {
         fail();
     }
-    if (!keys(state, ['schemaVersion', 'runId', 'owner', 'finalizationState', 'decisions', 'sourceDispositions', 'cleanup', 'reconciliations', 'retrospective', 'processedSources', 'sourceParticipants', 'corpusAudit', 'reconciliationHistory']) || state.schemaVersion !== 1 || !text(state.runId) || !/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(state.runId) || !ownerValid(state.owner)
+    if (!keys(state, ['schemaVersion', 'runId', 'owner', 'finalizationState', 'decisions', 'sourceDispositions', 'cleanup', 'reconciliations', 'retrospective', 'processedSources', 'sourceParticipants', 'corpusAudit', 'reconciliationHistory', 'deferred', 'deferredHistory', 'deferredAttempts', 'outcomeAssessments']) || state.schemaVersion !== 1 || !text(state.runId) || !/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(state.runId) || !ownerValid(state.owner)
         || !['pending', 'complete'].includes(state.finalizationState) || !Array.isArray(state.decisions) || !Array.isArray(state.sourceDispositions) || !Array.isArray(state.cleanup))
         fail();
     if ((expected.runId && expected.runId !== state.runId) || (expected.owner && !sameOwner(expected.owner, state.owner)))
@@ -249,8 +300,31 @@ function decodeCompletion(markdown, expected = {}) {
         fail();
     if (state.processedSources !== undefined)
         validateProcessedSources(state.processedSources);
+    if (state.outcomeAssessments !== undefined) {
+        if (!Array.isArray(state.outcomeAssessments))
+            fail();
+        const digests = new Set();
+        for (const assessment of state.outcomeAssessments) {
+            (0, outcome_types_1.validateOutcomeAssessmentRecord)(assessment);
+            if (assessment.runId !== state.runId || digests.has(assessment.digest))
+                fail();
+            digests.add(assessment.digest);
+        }
+    }
     if (state.sourceParticipants !== undefined)
         normalizeSourceParticipants(state.sourceParticipants, state.owner);
+    if (state.deferred !== undefined)
+        validateDeferredWork(state.deferred);
+    if (state.deferredHistory !== undefined) {
+        if (!Array.isArray(state.deferredHistory))
+            fail();
+        state.deferredHistory.forEach(validateDeferredWork);
+    }
+    if (state.deferredAttempts !== undefined) {
+        if (!Array.isArray(state.deferredAttempts))
+            fail();
+        state.deferredAttempts.forEach(validateDeferredAttempt);
+    }
     const ids = new Set();
     for (const item of state.decisions) {
         if (!keys(item, ['actionId', 'revision', 'digest', 'owner', 'claimKey', 'evidenceFingerprint', 'sourceRefs', 'decision', 'publicationRef', 'target', 'dependencies']) || !text(item.actionId) || ids.has(item.actionId) || !Number.isInteger(item.revision) || item.revision < 1 || !hash(item.digest) || !ownerValid(item.owner)
@@ -282,6 +356,8 @@ function decodeCompletion(markdown, expected = {}) {
             fail();
     }
     const decisions = new Map(state.decisions.map((item) => [item.actionId, item]));
+    if (state.deferred?.actions.some((item) => decisions.has(item.actionId)))
+        fail();
     if (state.corpusAudit !== undefined) {
         try {
             (0, corpus_audit_1.validateCorpusAudit)(state.corpusAudit);

package/dist/registry/scripts/learning/corpus-audit.js

@@ -10,7 +10,7 @@ const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const node_crypto_1 = require("node:crypto");
 const owner_identity_1 = require("./owner-identity");
-const { learningEntryBlocks } = require('./entry-format');
+const { learningEntryBlocks, learningEntryIdentity, isLearningEntryId } = require('./entry-format');
 const stable = (value) => JSON.stringify(value, (_key, item) => item && typeof item === 'object' && !Array.isArray(item)
     ? Object.fromEntries(Object.keys(item).sort().map(key => [key, item[key]])) : item);
 const hash = (value) => (0, node_crypto_1.createHash)('sha256').update(value).digest('hex');
@@ -63,9 +63,8 @@ function collectLearningCorpus(homes, subjects, readerRoots = []) {
                         for (const block of blocks) {
                             // Match the runtime reader's handwritten identity contract.
                             // Approved mutations still use the author's narrower generated-ID schema.
-                            const declarations = block.text.split(/\r?\n/).map(line => line.trim()).filter(line => /^\*\*Id\*\*:/i.test(line));
-                            const id = declarations[0]?.match(/^\*\*Id\*\*:\s*(L-[0-9A-Za-z]{6,24})\s*$/)?.[1] ?? null;
-                            if ((declarations.length && (!id || declarations.length !== 1)) || (id && ids.has(id))
+                            const { id, ambiguous } = learningEntryIdentity(block.text);
+                            if (ambiguous || (id && ids.has(id))
                                 || !/^#{2,6}\s+\[P-(CRITICAL|HIGH|MED|LOW)\]\s+\S/.test(block.text)) {
                                 errors.push({ path: file.replace(/\\/g, '/'), reason: 'ambiguous-corpus-entry' });
                                 continue;
@@ -157,8 +156,9 @@ function collectLearningCorpus(homes, subjects, readerRoots = []) {
 /** Shared by journal replay and the strict compact receipt decoder. No filesystem access. */
 function validateCorpusAudit(audit, reviewer) {
     const fail = () => { throw new Error('invalid-corpus-audit'); };
-    if (!keys(audit, ['snapshot', 'reviewer', 'dispositions']) || typeof audit.reviewer !== 'string' || !audit.reviewer.trim() || (reviewer && audit.reviewer !== reviewer)
-        || !keys(audit.snapshot, ['schemaVersion', 'homes', 'entries', 'duplicates', 'fingerprint', 'complete', 'errors']) || audit.snapshot.schemaVersion !== 1 || audit.snapshot.complete !== true || !Array.isArray(audit.snapshot.errors) || audit.snapshot.errors.length
+    if (!keys(audit, ['snapshot', 'reviewer', 'dispositions', 'partial']) || typeof audit.reviewer !== 'string' || !audit.reviewer.trim() || (reviewer && audit.reviewer !== reviewer) || (audit.partial !== undefined && audit.partial !== true)
+        || !keys(audit.snapshot, ['schemaVersion', 'homes', 'entries', 'duplicates', 'fingerprint', 'complete', 'errors']) || audit.snapshot.schemaVersion !== 1 || typeof audit.snapshot.complete !== 'boolean' || (!audit.partial && !audit.snapshot.complete) || !Array.isArray(audit.snapshot.errors) || (!audit.partial && audit.snapshot.errors.length)
+        || audit.snapshot.errors.some(item => !keys(item, ['path', 'reason']) || typeof item.path !== 'string' || !node_path_1.default.isAbsolute(item.path) || typeof item.reason !== 'string' || !item.reason.trim())
         || !Array.isArray(audit.snapshot.homes) || !Array.isArray(audit.snapshot.entries) || !Array.isArray(audit.dispositions))
         fail();
     const snapshot = audit.snapshot;
@@ -172,7 +172,7 @@ function validateCorpusAudit(audit, reviewer) {
             fail();
         (0, owner_identity_1.validateOwner)(entry.ref?.owner);
         if (!snapshot.homes.some(owner => (0, owner_identity_1.ownerKey)(owner) === (0, owner_identity_1.ownerKey)(entry.ref.owner))
-            || (entry.ref.entryId === undefined ? !Number.isSafeInteger(entry.occurrence) || entry.occurrence < 0 : !/^L-[0-9A-Za-z]{6,24}$/.test(entry.ref.entryId) || entry.occurrence !== undefined)
+            || (entry.ref.entryId === undefined ? !Number.isSafeInteger(entry.occurrence) || entry.occurrence < 0 : !isLearningEntryId(entry.ref.entryId) || entry.occurrence !== undefined)
             || !/^learnings\//.test(entry.ref.relativePath) || /[\\:]/.test(entry.ref.relativePath) || entry.ref.relativePath.split('/').some(part => !part || part === '.' || part === '..')
             || !/^[a-f0-9]{64}$/.test(entry.sha256) || entries.has(corpusEntryKey(entry)))
             fail();

package/dist/registry/scripts/learning/entry-authoring.js

@@ -0,0 +1,181 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveDomain = deriveDomain;
+exports.readerWordCount = readerWordCount;
+exports.validateEntry = validateEntry;
+exports.renderEntry = renderEntry;
+exports.isLearningScaffolding = isLearningScaffolding;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+// Relative to the shipped helper, never to the job's working directory.
+const map = JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(__dirname, 'learning-domains.json'), 'utf8'));
+function deriveDomain(origins) {
+    const unknown = (reason) => ({ status: 'needs-domain', value: null, reason, mapVersion: map.mapVersion });
+    if (!origins.length)
+        return unknown('No originating job recorded');
+    const decisions = [];
+    for (const origin of origins) {
+        let declaration;
+        const frontmatter = origin.content?.match(/^\uFEFF?---\r?\n([\s\S]*?)\r?\n---/);
+        if (frontmatter) {
+            try {
+                declaration = JSON.parse(frontmatter[1]).domain;
+            }
+            catch {
+                declaration = frontmatter[1].match(/^domain:\s*["']?([\w-]+)/m)?.[1];
+            }
+        }
+        if (declaration !== undefined) {
+            if (declaration !== 'global' && !map.domains.includes(String(declaration)))
+                return unknown(`Invalid domain declaration for ${origin.name}`);
+            decisions.push({ value: String(declaration), basis: 'job-declaration' });
+            continue;
+        }
+        const clean = origin.registryPath?.replace(/\\/g, '/').replace(/^\/?registry\//, '');
+        const category = clean?.match(/^jobs\/(?:ai-employee\/|ai-manager\/|personalized-employee\/)?([^/]+)\/[^/]+\.md$/)?.[1];
+        if (!category)
+            return unknown(`No mapped job path for ${origin.name}`);
+        const value = map.jobDomainMap[category] || (map.globalJobCategories.includes(category) ? 'global' : null);
+        if (!value)
+            return unknown(`Unmapped category for ${origin.name}`);
+        decisions.push({ value, basis: 'category' });
+    }
+    if (new Set(decisions.map(d => d.value)).size !== 1)
+        return unknown('Originating jobs span multiple domains');
+    return { status: 'resolved', ...decisions[0], mapVersion: map.mapVersion };
+}
+function readerText(entry) {
+    return [entry.title, entry.takeaway, entry.why, entry.example, entry.next].join(' ');
+}
+function readerWordCount(entry) {
+    const plain = readerText(entry).replace(/!?\[([^\]]*)\]\([^)]*\)/g, '$1').replace(/[*_`~#]/g, '').trim();
+    return plain ? plain.split(/\s+/u).length : 0;
+}
+function validateEntry(entry) {
+    if (!entry || !['P-CRITICAL', 'P-HIGH', 'P-MED', 'P-LOW'].includes(entry.severity))
+        throw new Error('invalid-entry: severity');
+    for (const field of ['title', 'takeaway', 'why', 'example', 'next']) {
+        if (typeof entry[field] !== 'string' || !entry[field].trim() || /[\r\n\0]/.test(entry[field]))
+            throw new Error(`invalid-entry: ${field}`);
+    }
+    if (readerWordCount(entry) > 80)
+        throw new Error('invalid-entry: 80-word budget exceeded');
+    // Domain wording and whether an identifier is essential require semantic
+    // authoring review/evals; a vocabulary regex rejects legitimate lessons.
+    if (!entry.domain || !Number.isInteger(entry.domain.mapVersion))
+        throw new Error('invalid-entry: domain');
+    if (entry.domain.status === 'resolved') {
+        if (!['global', ...map.domains].includes(entry.domain.value) || !['category', 'job-declaration', 'manager'].includes(entry.domain.basis))
+            throw new Error('invalid-entry: domain');
+    }
+    else if (entry.domain.status !== 'needs-domain' || entry.domain.value !== null || !entry.domain.reason)
+        throw new Error('invalid-entry: domain');
+    const trace = entry.trace;
+    if (!trace || !Number.isFinite(trace.score) || !Number.isInteger(trace.recurrences) || trace.recurrences < 1 || !Array.isArray(trace.originatingJobs) || !Array.isArray(trace.sources))
+        throw new Error('invalid-entry: trace');
+    for (const date of [trace.lastSeen, trace.firstRecorded, ...(trace.firstSynthesized ? [trace.firstSynthesized] : [])]) {
+        if (typeof date !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(date) || new Date(date).toISOString().slice(0, 10) !== date)
+            throw new Error('invalid-entry: date');
+    }
+    if (trace.firstRecorded > trace.lastSeen)
+        throw new Error('invalid-entry: source dates');
+    if (!trace.originatingJobs.every(job => typeof job.name === 'string' && job.name.length > 0 && (job.registryPath === null || typeof job.registryPath === 'string')))
+        throw new Error('invalid-entry: origins');
+    if (!trace.sources.every(source => typeof source === 'string'))
+        throw new Error('invalid-entry: sources');
+}
+function renderEntry(entryId, entry) {
+    validateEntry(entry);
+    if (!/^L-[a-f0-9]{10}$/.test(entryId))
+        throw new Error('invalid-entry: Id');
+    if (entry.domain.status !== 'resolved')
+        throw new Error('needs-domain');
+    const trace = entry.trace;
+    const line = (value) => value.replace(/[\r\n\0]+/g, ' ');
+    // Metadata stays on standalone lines for existing learning readers.
+    return [
+        `### [${entry.severity}] ${entry.title}`, '',
+        `**Takeaway**: ${entry.takeaway}`, `**Why this matters**: ${entry.why}`,
+        `**Example**: ${entry.example}`, `**What to do next**: ${entry.next}`, '**Technical trace**:',
+        `**Id**: ${entryId}`, `**Domain**: ${entry.domain.value}`,
+        `**Originating job**: ${line(trace.originatingJobs.map(job => job.registryPath || job.name).join('; '))}`,
+        `**Domain basis**: ${entry.domain.basis}; map ${entry.domain.mapVersion}`,
+        `**Score**: ${trace.score}`, `**Last seen**: ${trace.lastSeen}`,
+        `**Recurrences**: ${trace.recurrences}`, `**First recorded**: ${trace.firstRecorded}`,
+        ...(trace.firstSynthesized ? [`**First synthesized**: ${trace.firstSynthesized}`] : []),
+        `**Sources**: ${line(trace.sources.join('; '))}`,
+        // Investigation detail stays in evidence; active guidance retains only provenance metadata.
+        '',
+    ].join('\n');
+}
+/** Recognize only known generated family preambles; unknown prose remains user content. */
+function isLearningScaffolding(body, familyPath) {
+    const name = node_path_1.default.basename(familyPath);
+    const match = name.match(/-(preferences|mistake-patterns|validated-patterns|manager-coaching)(\.cold)?\.md$/);
+    if (!match)
+        return false;
+    const family = match[1];
+    const title = family.replace(/-/g, ' ');
+    const cold = !!match[2];
+    const descriptions = {
+        preferences: ['This file captures durable communication and interaction preferences observed across sessions.', 'This file captures working preferences common across multiple users. Run `organizational-learning-synthesis` to populate it.'],
+        'mistake-patterns': ['This file is an execution playbook for future agents. Keep it focused on durable behavior and decision quality.', 'This file captures recurring failure modes observed across multiple users in the org. Run `organizational-learning-synthesis` to populate it.'],
+        'validated-patterns': ['This file captures validated decisions, near-misses that were caught, and moments where past learnings successfully fired. These are behaviors to reinforce.'],
+        'manager-coaching': ['This file captures coaching and reflections about your management of AI agents - patterns you have developed (or been coached on) that make you a more effective practitioner. The audience is **you**, not the AI agent.', 'This file captures coaching patterns shared across managers in the org - guidance that managers have received or developed about how to work effectively with AI agents. The audience is the human manager, not the AI agent. Run `organizational-learning-synthesis` to populate it.'],
+    };
+    const heading = (value) => {
+        if (['# Learnings', '# Synthesized Learnings'].includes(value) || (family === 'mistake-patterns' && value === '# Prioritized Learnings'))
+            return true;
+        if (!value.startsWith('# '))
+            return false;
+        let text = value.slice(2);
+        const author = text.match(/ [\-\u2014] ([a-zA-Z0-9@._+-]+)$/);
+        if (author) {
+            if (!name.startsWith(author[1] + '-'))
+                return false;
+            text = text.slice(0, -author[0].length);
+        }
+        if (/^Cold-Tier /i.test(text)) {
+            if (!cold)
+                return false;
+            text = text.slice(10);
+        }
+        if (/^Org /i.test(text)) {
+            if (!name.startsWith('org-'))
+                return false;
+            text = text.slice(4);
+        }
+        const domain = text.match(/ \(([a-zA-Z][a-zA-Z -]*)\)$/);
+        if (domain) {
+            if (!name.toLowerCase().endsWith('-' + domain[1].toLowerCase().replace(/ /g, '-') + '-' + family + (cold ? '.cold' : '') + '.md'))
+                return false;
+            text = text.slice(0, -domain[0].length);
+        }
+        text = text.toLowerCase().replace(/-/g, ' ');
+        if (text === title)
+            return true;
+        const prefix = text.endsWith(' ' + title) ? text.slice(0, -title.length - 1).replace(/ /g, '-') : '';
+        return !!prefix && name.toLowerCase().endsWith('-' + prefix + '-' + family + (cold ? '.cold' : '') + '.md');
+    };
+    return body.split(/\r?\n/).every(line => {
+        const value = line.trim();
+        if (!value || value === '---' || heading(value) || descriptions[family].includes(value) || /^Last (?:synthesized|updated): \d{4}-\d{2}-\d{2}$/.test(value))
+            return true;
+        if (cold && (value === 'Entries whose effective score has fallen below the injection threshold. They stay readable and return to the active file the first time their problem recurs.'
+            || /^Entries below the active-tier score threshold \(\d+(?:\.\d+)?\)\. Preserved for re-activation if recurrence rises\.$/.test(value)))
+            return true;
+        const sections = {
+            'mistake-patterns': ['## Severity Definitions', '## Critical Priorities', '- Critical: recurring across 3+ users, causes customer impact or significant rework.', '- Important: recurring across 2+ users, degrades quality or velocity.', '- Monitor: emerging pattern, not yet widespread but worth tracking.', '- Critical: recurring failure mode that causes rework, trust loss, or architectural mistakes.', '- Important: meaningful quality risk that frequently degrades output.', '- Monitor: lower-frequency risk to track and prevent from growing.'],
+            'validated-patterns': ['## Severity Definitions', '## Patterns to Reinforce', '- HIGH: validated decision that prevented major rework or unblocked a high-stakes path (reusable across many future contexts).', '- MED: validated context-specific judgment call (reusable when same context recurs).', '- LOW: validated micro-correctness (useful but narrow).'],
+        };
+        if (sections[family]?.includes(value))
+            return true;
+        const domain = value.match(/^([A-Za-z][A-Za-z-]*)-domain (manager coaching|validated patterns)\. (.+)$/);
+        const detail = family === 'manager-coaching' ? 'Feedback for how the manager should continue or improve managing AI on ' + domain?.[1].toLowerCase() + ' work.' : 'Durable judgment calls and successful unusual-but-correct decisions worth reproducing.';
+        return !!domain && domain[2] === title && name.toLowerCase().endsWith('-' + domain[1].toLowerCase() + '-' + family + '.md')
+            && domain[3] === detail + ' These load only when an ' + domain[1].toLowerCase() + '-domain job runs.';
+    });
+}

package/dist/registry/scripts/learning/entry-format.js

@@ -1,5 +1,14 @@
 'use strict';
 
+const LEARNING_ENTRY_ID_LINE = /^\*\*Id\*\*:\s*(L-[0-9A-Za-z]{6,24})\s*$/;
+function isLearningEntryId(value) { return typeof value === 'string' && /^L-[0-9A-Za-z]{6,24}$/.test(value); }
+/** Reader/corpus identity accepts stable handwritten IDs; approved mutation IDs remain narrower below. */
+function learningEntryIdentity(content) {
+    const declarations = content.split(/\r?\n/).map(line => line.trim()).filter(line => /^\*\*Id\*\*:/i.test(line));
+    const id = declarations[0]?.match(LEARNING_ENTRY_ID_LINE)?.[1] ?? null;
+    return { id: declarations.length === 1 ? id : null, ambiguous: declarations.length > 0 && (!id || declarations.length !== 1) };
+}
+
 // Read the shared author's current entry format for identity and update guards.
 function learningEntryBlocks(body) {
     const headings = [...body.matchAll(/^#{2,6}\s+\[P-[A-Z]+\].*$/gm)];
@@ -24,4 +33,4 @@ function learningEntryMetadata(content) {
     return metadata;
 }
 
-module.exports = { learningEntryMetadata, learningEntryBlocks };
+module.exports = { learningEntryMetadata, learningEntryBlocks, learningEntryIdentity, isLearningEntryId, LEARNING_ENTRY_ID_LINE };

package/dist/registry/scripts/learning/outcome-assessment.js

@@ -0,0 +1,162 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.summarizeLearningOutcomes = void 0;
+exports.recordOutcomeAssessment = recordOutcomeAssessment;
+exports.readOutcomeAssessments = readOutcomeAssessments;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const learning_usage_store_1 = require("../../../src/local-mcp-server/learning-usage-store");
+const owner_identity_1 = require("./owner-identity");
+const proposal_queue_1 = require("./proposal-queue");
+const completion_state_1 = require("./completion-state");
+const artifact_paths_1 = require("../artifact-paths");
+const learning_source_record_1 = require("../learning-usage/learning-source-record");
+const corpus_audit_1 = require("./corpus-audit");
+const outcome_types_1 = require("./outcome-types");
+var outcome_types_2 = require("./outcome-types");
+Object.defineProperty(exports, "summarizeLearningOutcomes", { enumerable: true, get: function () { return outcome_types_2.summarizeLearningOutcomes; } });
+const { learningEntryBlocks, learningEntryMetadata, learningEntryIdentity } = require('./entry-format');
+function resolveAssessmentHomes(run, input, options) {
+    const homes = new Map();
+    for (const owner of [run.owner, input.learning.owner, ...input.sourceRefs.map(source => source.owner)]) {
+        const home = options.resolveHome(owner);
+        (0, owner_identity_1.assertSameOwner)(owner, home.owner);
+        homes.set((0, owner_identity_1.ownerKey)(owner), home);
+    }
+    return homes;
+}
+function resolveAssessmentSources(input, homes) {
+    return input.sourceRefs.map(ref => {
+        const home = homes.get((0, owner_identity_1.ownerKey)(ref.owner));
+        const originalFile = (0, owner_identity_1.configuredArtifactPath)(home, node_path_1.default.join((0, owner_identity_1.ownerArtifactRoot)(home), ref.relativePath));
+        let file = originalFile;
+        if (!node_fs_1.default.existsSync(file)) {
+            const paths = (0, artifact_paths_1.resolveArtifactPaths)((0, owner_identity_1.ownerArtifactRoot)(home), home.contentRoot);
+            const archive = (0, completion_state_1.sourcePathKey)(node_path_1.default.dirname(file)) === (0, completion_state_1.sourcePathKey)(paths.raw) ? paths.archiveRaw
+                : (0, completion_state_1.sourcePathKey)(node_path_1.default.dirname(file)) === (0, completion_state_1.sourcePathKey)(paths.retrospectives) ? paths.archiveRetrospectives : undefined;
+            if (archive)
+                file = (0, owner_identity_1.configuredArtifactPath)(home, node_path_1.default.join(archive, node_path_1.default.basename(file)));
+        }
+        return { ref, home, file, archived: file !== originalFile };
+    });
+}
+function verifyAssessmentLearning(input, home, target) {
+    if (!node_fs_1.default.existsSync(target) || node_fs_1.default.lstatSync(target).isSymbolicLink())
+        throw new Error('assessment-learning-missing');
+    const entries = learningEntryBlocks(node_fs_1.default.readFileSync(target, 'utf8')).map(block => ({ ...block, ...learningEntryIdentity(block.text) }));
+    if (entries.some(block => block.ambiguous))
+        throw new Error('assessment-learning-missing-or-ambiguous');
+    const blocks = entries.filter(block => block.id === input.learning.entryId);
+    if (blocks.length !== 1)
+        throw new Error('assessment-learning-missing-or-ambiguous');
+    const domain = blocks[0].text.match(/^\*\*Domain\*\*:\s*([^\r\n]+)$/m)?.[1].trim();
+    (0, owner_identity_1.assertLearningTargetPath)(input.learning, domain);
+    const occurrences = (0, corpus_audit_1.collectLearningCorpus)([home], [input.learning.learningSubject]).entries.filter(entry => {
+        if (entry.ref.entryId !== input.learning.entryId)
+            return false;
+        try {
+            (0, owner_identity_1.assertLearningTargetPath)({ ...entry.ref, learningSubject: input.learning.learningSubject });
+            return true;
+        }
+        catch {
+            return false;
+        } // Shared org guidance is a distinct subject in a Project home.
+    });
+    if (occurrences.length !== 1)
+        throw new Error('assessment-learning-identity-ambiguous');
+    const metadata = learningEntryMetadata(blocks[0].text);
+    const introduced = metadata['First synthesized'] || metadata['First recorded'];
+    if (!introduced || !Number.isFinite(Date.parse(introduced)))
+        throw new Error('guidance-date-unavailable');
+    if (Date.parse(introduced) > Date.parse(input.observedAt) || Date.parse(introduced) > Date.parse(input.guidanceExistedAt))
+        throw new Error('guidance-after-incident');
+}
+function verifyAssessmentSources(sources, state) {
+    for (const source of sources) {
+        if (!node_fs_1.default.existsSync(source.file) || node_fs_1.default.lstatSync(source.file).isSymbolicLink())
+            throw new Error('assessment-source-unavailable');
+        const body = node_fs_1.default.readFileSync(source.file, 'utf8');
+        // Normal archival only fills this existing frontmatter field; source identity and all evidence bytes remain bound.
+        const originalBody = source.archived ? body.replace(/^(synthesized:)[^\r\n]*/m, '$1') : body;
+        if ((0, proposal_queue_1.hashContent)(body) !== source.ref.sha256 && (0, proposal_queue_1.hashContent)(originalBody) !== source.ref.sha256)
+            throw new Error('assessment-source-hash-conflict');
+        const parsed = (0, learning_source_record_1.parseLearningSourceRecord)(body, source.file, (0, owner_identity_1.ownerArtifactRoot)(source.home), source.home.contentRoot);
+        if (parsed.status !== 'valid')
+            throw new Error(`invalid-assessment-source: ${parsed.reason}`);
+        if (parsed.record.sourceId !== source.ref.sourceId
+            || !(0, completion_state_1.sourceAuthorAllowed)(state, parsed.record.author, source.home.owner))
+            throw new Error('invalid-assessment-source');
+    }
+}
+function replayAssessment(run, state, pending, prior) {
+    if (pending?.digest === prior.digest)
+        run.commitOutcomeAssessment(prior.digest, state.sequence);
+    return prior;
+}
+function commitAssessment(transaction) {
+    const { run, input, state, pending, options, home, target, sources } = transaction;
+    // File locks also coordinate callers with different Manager coordination paths.
+    // Refresh after acquiring them, before recording any recoverable intent.
+    const prior = (0, learning_usage_store_1.readAssessedOutcomes)(undefined, { key: (0, outcome_types_1.assessmentKey)(input) })[0];
+    if (prior && (0, outcome_types_1.assessmentContent)(prior) === (0, outcome_types_1.assessmentContent)(input))
+        return replayAssessment(run, state, pending, prior);
+    const reservations = (0, completion_state_1.readRunReservations)([run.directory, ...options.runDirectories], run.file);
+    if (reservations.assessmentKeys.includes((0, outcome_types_1.assessmentKey)(input)))
+        throw new Error('assessment-reserved-by-pending-run');
+    if ((prior?.digest ?? null) !== input.expectedPriorDigest)
+        throw new Error('stale-assessment-conflict');
+    verifyAssessmentLearning(input, home, target);
+    verifyAssessmentSources(sources, state);
+    const record = pending ?? { ...structuredClone(input), revision: (prior?.revision ?? 0) + 1,
+        assessedAt: new Date().toISOString(), reviewer: state.reviewer, runId: state.runId, digest: '' };
+    record.digest = (0, outcome_types_1.outcomeAssessmentDigest)(record);
+    if (!pending)
+        run.prepareOutcomeAssessment(record, state.sequence, sources.map(source => source.file));
+    options.afterStage?.('assessment-prepared');
+    const persisted = (0, learning_usage_store_1.recordAssessedOutcome)(record);
+    options.afterStage?.('assessment-stored');
+    run.commitOutcomeAssessment(record.digest, run.read().sequence);
+    options.afterStage?.('assessment-committed');
+    return persisted;
+}
+function withAssessmentFileLocks(transaction) {
+    const files = [...new Set([transaction.target, ...transaction.sources.map(source => source.file)])].sort();
+    const locked = (index) => index < files.length
+        ? (0, proposal_queue_1.withFileLock)(files[index], () => locked(index + 1)) : commitAssessment(transaction);
+    return locked(0);
+}
+/** Commit semantic judgments supplied by Sleep; no prose, title or retrospective-ID matching. */
+function recordOutcomeAssessment(run, input, expectedSequence, options) {
+    (0, outcome_types_1.validateOutcomeAssessmentInput)(input);
+    (0, owner_identity_1.assertLearningTargetPath)(input.learning);
+    return (0, proposal_queue_1.withFileLock)(options.coordinationFile || node_path_1.default.join(run.directory, 'owner-application'), () => {
+        const state = run.read();
+        if (!Number.isInteger(expectedSequence) || state.sequence !== expectedSequence)
+            throw new Error('stale-sequence');
+        if (state.finalization || state.checkpoint?.receipt.finalizationState === 'pending')
+            throw new Error('finalization-started');
+        const homes = resolveAssessmentHomes(run, input, options);
+        if (!(0, completion_state_1.sourceAuthorAllowed)(state, input.learning.learningSubject, input.learning.owner))
+            throw new Error('assessment-subject-conflict');
+        const prior = (0, learning_usage_store_1.readAssessedOutcomes)(undefined, { key: (0, outcome_types_1.assessmentKey)(input) })[0];
+        const pending = state.pendingOutcomeAssessments?.find(record => (0, outcome_types_1.assessmentKey)(record) === (0, outcome_types_1.assessmentKey)(input));
+        if (pending && (0, outcome_types_1.assessmentContent)(pending) !== (0, outcome_types_1.assessmentContent)(input))
+            throw new Error('pending-assessment-conflict');
+        // Exact replay remains valid after sources have archived and detailed evidence expires.
+        if (prior && (0, outcome_types_1.assessmentContent)(prior) === (0, outcome_types_1.assessmentContent)(input))
+            return replayAssessment(run, state, pending, prior);
+        if ((prior?.digest ?? null) !== input.expectedPriorDigest)
+            throw new Error('stale-assessment-conflict');
+        const home = homes.get((0, owner_identity_1.ownerKey)(input.learning.owner));
+        const target = (0, owner_identity_1.ownerArtifactPath)(home, input.learning.relativePath);
+        const sources = resolveAssessmentSources(input, homes);
+        return withAssessmentFileLocks({ run, input, state, pending, options, home, target, sources });
+    });
+}
+/** Durable usage history outlives transient run journals, receipts and original source retention. */
+function readOutcomeAssessments(homes, principal) {
+    return (0, learning_usage_store_1.readAssessedOutcomes)(undefined, { owners: homes.map(home => home.owner), principal });
+}