iranti 0.3.0 → 0.3.2

package/dist/src/attendant/AttendantInstance.js

@@ -5,6 +5,7 @@ exports.normalizeExplicitTask = normalizeExplicitTask;
 exports.formatOperatingRulesText = formatOperatingRulesText;
 exports.readPersistedSessionState = readPersistedSessionState;
 exports.summarizeSessionState = summarizeSessionState;
+const crypto_1 = require("crypto");
 const router_1 = require("../lib/router");
 const staffEventRegistry_1 = require("../lib/staffEventRegistry");
 const queries_1 = require("../library/queries");
@@ -19,6 +20,7 @@ const autoRemember_1 = require("../lib/autoRemember");
 const semanticFactTags_1 = require("../lib/semanticFactTags");
 const sessionLedger_1 = require("../lib/sessionLedger");
 const sharedStateInvalidation_1 = require("../lib/sharedStateInvalidation");
+const hostMemoryFormatting_1 = require("../lib/hostMemoryFormatting");
 // ─── Constants ───────────────────────────────────────────────────────────────
 const ATTENDANT_RULES_QUERY = {
     entityType: 'system',
@@ -55,6 +57,11 @@ const ENTITY_DETECTION_WINDOW_CHARS = 1500;
 const MIN_ENTITY_CONFIDENCE = 0.75;
 const MEMORY_DECISION_CONTEXT_WINDOW_CHARS = 2000;
 const LEDGER_WORKING_MEMORY_PREFIX = 'system/session_ledger/recent_learning_';
+const LEGACY_CONTINUITY_KEY_MAP = {
+    checkpoint_current_step: 'current_step',
+    checkpoint_next_step: 'next_step',
+    checkpoint_open_risks: 'open_risks',
+};
 const ATTEND_EXPECTED_CALL_SEQUENCE = [
     'Call iranti_handshake at session start and again after context compaction.',
     "Call iranti_attend(phase='pre-response') before replying to the user.",
@@ -67,6 +74,20 @@ const ATTEND_EXPECTED_CALL_SEQUENCE = [
 ];
 const ATTEND_USAGE_REMINDER = 'Iranti is a hive mind. iranti_attend is mandatory before each reply and around knowledge discovery, and knowledge-changing actions must leave breadcrumbs through iranti_write and/or iranti_checkpoint so later sessions do not have to rediscover context.';
 const OBSERVE_USAGE_NOTE = 'observe() is retrieval-only. It surfaces candidate facts for context and warm-up, but it does not persist memory, replace iranti_attend, or count as a checkpoint/write.';
+function normalizeContinuityKey(key) {
+    return LEGACY_CONTINUITY_KEY_MAP[key] ?? key;
+}
+function expandContinuityPriorityKeys(keys) {
+    const expanded = new Set();
+    for (const rawKey of keys) {
+        const key = rawKey.trim();
+        if (!key)
+            continue;
+        expanded.add(key);
+        expanded.add(normalizeContinuityKey(key));
+    }
+    return Array.from(expanded);
+}
 const MEMORY_NEED_POSITIVE_PATTERNS = [
     /\bwhat(?:'s| is| was)?\s+my\b/i,
     /\bdo you remember\b/i,
@@ -213,6 +234,83 @@ function mergeWorkingMemoryWithLedger(entries, learnings) {
         ? [...retained, ...toLedgerWorkingMemoryEntries(learnings)]
         : retained;
 }
+function normalizeProjectPolicyRuleLines(value, fallbackSummary) {
+    const rules = [];
+    if (typeof value === 'string' && value.trim()) {
+        rules.push(value.trim());
+    }
+    else if (value && typeof value === 'object') {
+        const record = value;
+        if (typeof record.rule === 'string' && record.rule.trim()) {
+            rules.push(record.rule.trim());
+        }
+        if (typeof record.text === 'string' && record.text.trim()) {
+            rules.push(record.text.trim());
+        }
+        if (typeof record.instruction === 'string' && record.instruction.trim()) {
+            rules.push(record.instruction.trim());
+        }
+        if (Array.isArray(record.rules)) {
+            for (const rule of record.rules) {
+                if (typeof rule === 'string' && rule.trim()) {
+                    rules.push(rule.trim());
+                }
+            }
+        }
+        if (Array.isArray(record.preferences)) {
+            for (const preference of record.preferences) {
+                if (typeof preference === 'string' && preference.trim()) {
+                    rules.push(preference.trim());
+                }
+            }
+        }
+    }
+    if (rules.length === 0 && fallbackSummary?.trim()) {
+        rules.push(fallbackSummary.trim());
+    }
+    return Array.from(new Set(rules.map((rule) => rule.trim()).filter(Boolean)));
+}
+function isProjectPolicyKey(key) {
+    return /(?:^agent_(?:operating_)?(?:rule|rules|preference|preferences)$|(?:_rule|_rules|_preference|_preferences)$)/i.test(key.trim());
+}
+function isProjectPolicyEntry(entry) {
+    if (isProjectPolicyKey(entry.key))
+        return true;
+    const durableClass = typeof entry.properties?.durableClass === 'string'
+        ? entry.properties.durableClass.trim().toLowerCase()
+        : '';
+    const semanticIntent = typeof entry.properties?.semanticIntent === 'string'
+        ? entry.properties.semanticIntent.trim().toLowerCase()
+        : '';
+    return durableClass === 'preference' || semanticIntent === 'preference_capture';
+}
+function toProjectPolicyWorkingMemoryEntries(entries) {
+    return entries.map((entry) => ({
+        entityKey: entry.entityKey,
+        summary: `Project policy: ${entry.summary}`,
+        confidence: 100,
+        source: entry.source,
+        lastUpdated: entry.lastUpdated,
+    }));
+}
+function mergeWorkingMemoryWithProjectPolicies(entries, policies) {
+    const retained = entries.filter((entry) => !policies.some((policy) => policy.entityKey === entry.entityKey));
+    return policies.length > 0
+        ? [...toProjectPolicyWorkingMemoryEntries(policies), ...retained]
+        : retained;
+}
+function applyProjectPolicyOperatingRules(operatingRules, projectPolicies) {
+    let nextRules = operatingRules;
+    for (const policy of projectPolicies) {
+        for (const rule of policy.rules) {
+            const renderedRule = `PROJECT POLICY (${policy.key}): ${rule}`;
+            if (!nextRules.includes(renderedRule)) {
+                nextRules = `${nextRules}\n- ${renderedRule}`;
+            }
+        }
+    }
+    return nextRules;
+}
 function formatMissingWriteCategories(categories) {
     const labelMap = {
         findings: 'what you found',
@@ -489,6 +587,18 @@ function buildSessionComplianceState(input) {
             requiredAction: 'Persist durable findings with iranti_write or iranti_checkpoint before the next turn if new knowledge, validation, or file changes occurred.',
         });
     }
+    if (input.consecutiveUnusedMemoryInjections > 0) {
+        const severity = input.consecutiveUnusedMemoryInjections >= 2 ? 'error' : 'warn';
+        issues.push({
+            code: 'ignored_injected_memory',
+            severity,
+            count: input.consecutiveUnusedMemoryInjections,
+            message: input.consecutiveUnusedMemoryInjections >= 2
+                ? `Injected memory has been surfaced and then ignored across ${input.consecutiveUnusedMemoryInjections} consecutive turns.`
+                : 'Injected memory was surfaced but the response did not use it in the previous turn.',
+            requiredAction: 'On the next turn, either answer from the injected facts directly or persist why the injected memory was insufficient before rediscovering the same state manually.',
+        });
+    }
     let status = 'healthy';
     if (issues.some((issue) => issue.severity === 'error')) {
         status = 'non_compliant';
@@ -501,10 +611,14 @@ function buildSessionComplianceState(input) {
             ? 'Lifecycle is currently in progress and waiting for a post-response attend.'
             : 'Lifecycle is currently compliant.'
         : status === 'degraded'
-            ? 'Lifecycle is degraded: persistence breadcrumbs are lagging.'
+            ? input.consecutiveUnusedMemoryInjections > 0
+                ? 'Lifecycle is degraded: injected memory was surfaced but not used.'
+                : 'Lifecycle is degraded: persistence breadcrumbs are lagging.'
             : input.consecutivePreResponseWithoutPost > 0
                 ? 'Lifecycle is non-compliant: the previous turn is still missing a post-response attend.'
-                : 'Lifecycle is non-compliant: accountability breadcrumbs are missing.';
+                : input.consecutiveUnusedMemoryInjections > 0
+                    ? 'Lifecycle is non-compliant: injected memory is being ignored instead of used or explicitly challenged.'
+                    : 'Lifecycle is non-compliant: accountability breadcrumbs are missing.';
     return {
         status,
         summary,
@@ -513,6 +627,7 @@ function buildSessionComplianceState(input) {
         counters: {
             attendsWithoutPersist: input.attendsWithoutPersist,
             consecutivePreResponseWithoutPost: input.consecutivePreResponseWithoutPost,
+            consecutiveUnusedMemoryInjections: input.consecutiveUnusedMemoryInjections,
             pendingPostResponse,
             lastAttendPhase: input.lastAttendPhase ?? null,
         },
@@ -970,13 +1085,13 @@ async function persistSharedCheckpointBreadcrumbs(params) {
         if (checkpoint.currentStep) {
             await (0, librarian_1.librarianWrite)({
                 ...common,
-                key: 'checkpoint_current_step',
+                key: 'current_step',
                 valueRaw: { text: checkpoint.currentStep },
-                valueSummary: truncate(`checkpoint current step is ${checkpoint.currentStep}`, 220),
+                valueSummary: truncate(`current step is ${checkpoint.currentStep}`, 220),
                 properties: {
                     ...checkpointBaseProperties,
                     durableClass: 'current_step',
-                    canonicalKey: 'checkpoint_current_step',
+                    canonicalKey: 'current_step',
                     mergeStrategy: 'replace',
                     ...(0, semanticFactTags_1.buildSemanticFactTags)({
                         memoryScope: 'project',
@@ -989,19 +1104,32 @@ async function persistSharedCheckpointBreadcrumbs(params) {
             expectedKeys.push({
                 entityType: resolved.entityType,
                 entityId: resolved.entityId,
-                key: 'checkpoint_current_step',
+                key: 'current_step',
             });
         }
         if (checkpoint.nextStep) {
+            const existingNextStep = await (0, queries_2.findEntry)({
+                entityType: resolved.entityType,
+                entityId: resolved.entityId,
+                key: 'next_step',
+            });
+            const priorInstruction = existingNextStep?.valueRaw && typeof existingNextStep.valueRaw === 'object'
+                ? existingNextStep.valueRaw.instruction
+                : null;
+            const mergedNextStep = typeof priorInstruction === 'string'
+                && priorInstruction.trim().length > 0
+                && priorInstruction.trim() !== checkpoint.nextStep.trim()
+                ? `${checkpoint.nextStep}. Prior task step: ${priorInstruction.trim()}`
+                : checkpoint.nextStep;
             await (0, librarian_1.librarianWrite)({
                 ...common,
-                key: 'checkpoint_next_step',
-                valueRaw: { instruction: checkpoint.nextStep },
-                valueSummary: truncate(`checkpoint next step is ${checkpoint.nextStep}`, 220),
+                key: 'next_step',
+                valueRaw: { instruction: mergedNextStep },
+                valueSummary: truncate(`next step is ${mergedNextStep}`, 220),
                 properties: {
                     ...checkpointBaseProperties,
                     durableClass: 'next_step',
-                    canonicalKey: 'checkpoint_next_step',
+                    canonicalKey: 'next_step',
                     mergeStrategy: 'replace',
                     ...(0, semanticFactTags_1.buildSemanticFactTags)({
                         memoryScope: 'project',
@@ -1014,7 +1142,7 @@ async function persistSharedCheckpointBreadcrumbs(params) {
             expectedKeys.push({
                 entityType: resolved.entityType,
                 entityId: resolved.entityId,
-                key: 'checkpoint_next_step',
+                key: 'next_step',
             });
         }
         if (Array.isArray(checkpoint.fileChanges) && checkpoint.fileChanges.length > 0) {
@@ -1082,13 +1210,13 @@ async function persistSharedCheckpointBreadcrumbs(params) {
         if (checkpoint.openRisks && checkpoint.openRisks.length > 0) {
             await (0, librarian_1.librarianWrite)({
                 ...common,
-                key: 'checkpoint_open_risks',
+                key: 'open_risks',
                 valueRaw: { items: checkpoint.openRisks },
-                valueSummary: truncate(`checkpoint open risks include ${checkpoint.openRisks.join('; ')}`, 220),
+                valueSummary: truncate(`open risks include ${checkpoint.openRisks.join('; ')}`, 220),
                 properties: {
                     ...checkpointBaseProperties,
                     durableClass: 'open_risks',
-                    canonicalKey: 'checkpoint_open_risks',
+                    canonicalKey: 'open_risks',
                     mergeStrategy: 'replace',
                     ...(0, semanticFactTags_1.buildSemanticFactTags)({
                         memoryScope: 'project',
@@ -1101,7 +1229,7 @@ async function persistSharedCheckpointBreadcrumbs(params) {
             expectedKeys.push({
                 entityType: resolved.entityType,
                 entityId: resolved.entityId,
-                key: 'checkpoint_open_risks',
+                key: 'open_risks',
             });
         }
     }
@@ -1200,6 +1328,7 @@ class AttendantInstance {
         this.contextCallCount = 0;
         this.attendsWithoutPersist = 0;
         this.consecutivePreResponseWithoutPost = 0;
+        this.consecutiveUnusedMemoryInjections = 0;
         this.lastAttendPhase = undefined;
         this.complianceUpdatedAt = new Date().toISOString();
         this.sessionStarted = new Date().toISOString();
@@ -1208,6 +1337,7 @@ class AttendantInstance {
         this.eventHost = null;
         this.sharedStateObservedAt = null;
         this.pendingSharedStateInvalidations = new Map();
+        this.pendingMemoryAttributions = [];
         this.agentId = agentId;
         (0, sharedStateInvalidation_1.registerSharedStateInvalidationObserver)(agentId, this);
     }
@@ -1232,6 +1362,156 @@ class AttendantInstance {
             ...(this.eventHost ? { host: this.eventHost } : {}),
         };
     }
+    updateBriefPendingMemoryAttributions() {
+        if (!this.brief)
+            return;
+        this.brief = {
+            ...this.brief,
+            pendingMemoryAttributions: this.pendingMemoryAttributions.map((entry) => ({ ...entry })),
+        };
+    }
+    addPendingMemoryAttribution(input) {
+        const attribution = {
+            injectionId: (0, crypto_1.randomUUID)(),
+            surfaced: true,
+            used: false,
+            helpful: false,
+            status: 'pending',
+            phase: input.phase,
+            surfacedAt: new Date().toISOString(),
+            reason: 'awaiting_post_response_evaluation',
+            injectedKeys: [...input.injectedKeys],
+            injectedEntryIds: [...input.injectedEntryIds],
+            evidenceKinds: [],
+        };
+        this.pendingMemoryAttributions.push(attribution);
+        this.updateBriefPendingMemoryAttributions();
+        return attribution;
+    }
+    recordMemoryEvidence(kind) {
+        if (this.pendingMemoryAttributions.length === 0) {
+            return;
+        }
+        for (const attribution of this.pendingMemoryAttributions) {
+            if (attribution.status !== 'pending')
+                continue;
+            if (!attribution.evidenceKinds.includes(kind)) {
+                attribution.evidenceKinds = [...attribution.evidenceKinds, kind];
+            }
+            (0, staffEventRegistry_1.getStaffEventEmitter)().emit({
+                staffComponent: 'Attendant',
+                actionType: 'memory_evidence_observed',
+                agentId: this.agentId,
+                source: this.eventSource,
+                reason: kind,
+                level: 'audit',
+                metadata: this.buildEventMetadata({
+                    injectionId: attribution.injectionId,
+                    injectedKeys: attribution.injectedKeys,
+                    injectedEntryIds: attribution.injectedEntryIds,
+                    evidenceKind: kind,
+                }),
+            });
+        }
+        this.updateBriefPendingMemoryAttributions();
+    }
+    responseMentionsInjectedMemory(response, attribution) {
+        const responseTokens = new Set(tokenize(response));
+        if (responseTokens.size === 0)
+            return false;
+        for (const entityKey of attribution.injectedKeys) {
+            const key = entityKey.split('/').slice(2).join('/');
+            for (const token of tokenize(key.replace(/[_/.-]+/g, ' '))) {
+                if (responseTokens.has(token)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    responseShowsRecoveryValue(response, attribution) {
+        const normalized = normalizeText(response);
+        if (!normalized)
+            return false;
+        return attribution.injectedKeys.some((entityKey) => {
+            const key = entityKey.split('/').slice(2).join('/');
+            return (/\b(next step|current step|blocker|blockers|risk|risks|status|progress|file|files|changed|handoff|resume|recovery)\b/.test(normalized)
+                && /\b(next_step|current_step|open_risks|status|checkpoint_summary|recent_file_changes|recent_actions|implementation_status|blockers?)\b/i.test(key));
+        });
+    }
+    scorePendingMemoryAttributions(response) {
+        if (this.pendingMemoryAttributions.length === 0) {
+            return [];
+        }
+        const scoredAt = new Date().toISOString();
+        const scored = this.pendingMemoryAttributions.map((entry) => {
+            const evidenceKinds = [...entry.evidenceKinds];
+            const rediscoveredManually = evidenceKinds.includes('rediscovery');
+            if (!rediscoveredManually && this.responseMentionsInjectedMemory(response, entry) && !evidenceKinds.includes('response_reference')) {
+                evidenceKinds.push('response_reference');
+            }
+            if (!rediscoveredManually && this.responseShowsRecoveryValue(response, entry) && !evidenceKinds.includes('response_recovery')) {
+                evidenceKinds.push('response_recovery');
+            }
+            const used = evidenceKinds.includes('write')
+                || evidenceKinds.includes('checkpoint')
+                || evidenceKinds.includes('response_reference')
+                || evidenceKinds.includes('response_recovery');
+            const helpful = evidenceKinds.includes('checkpoint')
+                || evidenceKinds.includes('write')
+                || evidenceKinds.includes('response_recovery');
+            const reason = helpful
+                ? 'response_or_action_confirmed_memory_helpfulness'
+                : used
+                    ? 'response_referenced_injected_memory'
+                    : 'memory_was_only_surfaced';
+            const scoredEntry = {
+                ...entry,
+                used,
+                helpful,
+                status: 'scored',
+                scoredAt,
+                reason,
+                evidenceKinds,
+            };
+            (0, staffEventRegistry_1.getStaffEventEmitter)().emit({
+                staffComponent: 'Attendant',
+                actionType: 'memory_injection_scored',
+                agentId: this.agentId,
+                source: this.eventSource,
+                reason,
+                level: 'audit',
+                metadata: this.buildEventMetadata({
+                    injectionId: scoredEntry.injectionId,
+                    surfaced: true,
+                    used,
+                    helpful,
+                    phase: scoredEntry.phase,
+                    injectedKeys: scoredEntry.injectedKeys,
+                    injectedEntryIds: scoredEntry.injectedEntryIds,
+                    evidenceKinds,
+                    scoredAt,
+                }),
+            });
+            return scoredEntry;
+        });
+        if (scored.some((entry) => entry.used)) {
+            this.consecutiveUnusedMemoryInjections = 0;
+        }
+        else if (scored.some((entry) => entry.surfaced)) {
+            this.consecutiveUnusedMemoryInjections += 1;
+        }
+        this.pendingMemoryAttributions = [];
+        this.updateBriefPendingMemoryAttributions();
+        return scored;
+    }
+    async noteDiscoveryOccurred() {
+        if (this.pendingMemoryAttributions.length === 0) {
+            return;
+        }
+        this.recordMemoryEvidence('rediscovery');
+        await this.persistState();
+    }
     async loadSessionLedgerSignals(taskType) {
         try {
             const source = this.eventSource === 'internal' ? undefined : this.eventSource;
@@ -1260,6 +1540,33 @@ class AttendantInstance {
             return { learnings: [], profile: null };
         }
     }
+    async loadProjectPolicies() {
+        const configured = (0, autoRemember_1.getProjectMemoryEntity)();
+        if (!configured)
+            return [];
+        const parsed = (0, entity_resolution_1.parseEntityString)(configured);
+        const entries = await (0, queries_1.findEntriesByEntity)(parsed.entityType, parsed.entityId);
+        const policies = entries
+            .filter((entry) => isProjectPolicyEntry({
+            key: entry.key,
+            properties: entry.properties ?? null,
+        }))
+            .map((entry) => {
+            const rules = normalizeProjectPolicyRuleLines(entry.valueRaw, entry.valueSummary);
+            if (rules.length === 0)
+                return null;
+            return {
+                entityKey: `${entry.entityType}/${entry.entityId}/${entry.key}`,
+                summary: rules.join(' '),
+                key: entry.key,
+                source: entry.source,
+                lastUpdated: entry.updatedAt.toISOString(),
+                rules,
+            };
+        })
+            .filter((entry) => Boolean(entry));
+        return policies;
+    }
     // ── Handshake ────────────────────────────────────────────────────────────
     async handshake(context) {
         const t0 = (0, metrics_1.timeStart)();
@@ -1271,13 +1578,15 @@ class AttendantInstance {
         // Infer task type
         const inferredTaskType = await this.inferTask(context);
         // Load knowledge — agent entries + related entities
-        const [workingMemory, ledgerSignals] = await Promise.all([
+        const [workingMemory, ledgerSignals, projectPolicies] = await Promise.all([
             this.buildWorkingMemory(inferredTaskType),
             this.loadSessionLedgerSignals(inferredTaskType),
+            this.loadProjectPolicies(),
         ]);
         const sessionLedgerLearnings = ledgerSignals.learnings;
         this.advisoryLearningProfile = ledgerSignals.profile;
-        const workingMemoryWithLedger = mergeWorkingMemoryWithLedger(workingMemory, sessionLedgerLearnings);
+        const workingMemoryWithPolicies = mergeWorkingMemoryWithProjectPolicies(workingMemory, projectPolicies);
+        const workingMemoryWithLedger = mergeWorkingMemoryWithLedger(workingMemoryWithPolicies, sessionLedgerLearnings);
         const recoveryResult = persisted?.sessionCheckpoint
             ? this.buildRecovery(context, persisted.sessionCheckpoint)
             : { interrupted: false, recovery: null };
@@ -1294,9 +1603,10 @@ class AttendantInstance {
         }
         this.brief = {
             agentId: this.agentId,
-            operatingRules: applyAdvisoryOperatingRules(operatingRules, this.advisoryLearningProfile),
+            operatingRules: applyAdvisoryOperatingRules(applyProjectPolicyOperatingRules(operatingRules, projectPolicies), this.advisoryLearningProfile),
             inferredTaskType,
             workingMemory: workingMemoryWithLedger,
+            projectPolicies,
             sessionStarted: persisted?.sessionStarted ?? this.sessionStarted,
             briefGeneratedAt: new Date().toISOString(),
             contextCallCount: this.contextCallCount,
@@ -1323,6 +1633,7 @@ class AttendantInstance {
             metadata: this.buildEventMetadata({
                 briefSize: this.brief?.workingMemory.length ?? 0,
                 ledgerLearningCount: sessionLedgerLearnings.length,
+                projectPolicyCount: projectPolicies.length,
                 advisoryScopes: this.advisoryLearningProfile?.scopesUsed ?? [],
                 taskSummary: context.task.slice(0, 120),
             }),
@@ -1340,7 +1651,10 @@ class AttendantInstance {
             return result;
         }
         const newTaskType = await this.inferTask(context);
-        const ledgerSignals = await this.loadSessionLedgerSignals(newTaskType);
+        const [ledgerSignals, projectPolicies] = await Promise.all([
+            this.loadSessionLedgerSignals(newTaskType),
+            this.loadProjectPolicies(),
+        ]);
         this.advisoryLearningProfile = ledgerSignals.profile;
         // Task hasn't shifted — update timestamp only
         if (newTaskType.toLowerCase() === this.brief.inferredTaskType.toLowerCase()) {
@@ -1354,8 +1668,9 @@ class AttendantInstance {
             }
             this.brief = {
                 ...this.brief,
-                operatingRules: applyAdvisoryOperatingRules(this.brief.operatingRules, this.advisoryLearningProfile),
-                workingMemory: mergeWorkingMemoryWithLedger(this.brief.workingMemory, ledgerSignals.learnings),
+                operatingRules: applyAdvisoryOperatingRules(applyProjectPolicyOperatingRules(await this.loadOperatingRules(), projectPolicies), this.advisoryLearningProfile),
+                workingMemory: mergeWorkingMemoryWithLedger(mergeWorkingMemoryWithProjectPolicies(this.brief.workingMemory, projectPolicies), ledgerSignals.learnings),
+                projectPolicies,
                 briefGeneratedAt: new Date().toISOString(),
                 contextCallCount: this.contextCallCount,
                 sessionLedgerLearnings: ledgerSignals.learnings,
@@ -1375,6 +1690,7 @@ class AttendantInstance {
                 metadata: this.buildEventMetadata({
                     briefSize: this.brief?.workingMemory.length ?? 0,
                     contextCallCount: this.contextCallCount,
+                    projectPolicyCount: projectPolicies.length,
                     advisoryScopes: this.advisoryLearningProfile?.scopesUsed ?? [],
                 }),
             });
@@ -1385,9 +1701,10 @@ class AttendantInstance {
         const workingMemory = await this.buildWorkingMemory(newTaskType);
         this.brief = {
             ...this.brief,
-            operatingRules: applyAdvisoryOperatingRules(this.brief.operatingRules, this.advisoryLearningProfile),
+            operatingRules: applyAdvisoryOperatingRules(applyProjectPolicyOperatingRules(await this.loadOperatingRules(), projectPolicies), this.advisoryLearningProfile),
             inferredTaskType: newTaskType,
-            workingMemory: mergeWorkingMemoryWithLedger(workingMemory, ledgerSignals.learnings),
+            workingMemory: mergeWorkingMemoryWithLedger(mergeWorkingMemoryWithProjectPolicies(workingMemory, projectPolicies), ledgerSignals.learnings),
+            projectPolicies,
             briefGeneratedAt: new Date().toISOString(),
             contextCallCount: this.contextCallCount,
             sessionLedgerLearnings: ledgerSignals.learnings,
@@ -1407,6 +1724,7 @@ class AttendantInstance {
             metadata: this.buildEventMetadata({
                 briefSize: this.brief?.workingMemory.length ?? 0,
                 contextCallCount: this.contextCallCount,
+                projectPolicyCount: projectPolicies.length,
                 advisoryScopes: this.advisoryLearningProfile?.scopesUsed ?? [],
             }),
         });
@@ -1434,8 +1752,10 @@ class AttendantInstance {
         const operatingRules = rulesResult.found && rulesResult.entry
             ? formatOperatingRulesText(rulesResult.entry.valueRaw, rulesResult.entry.valueSummary)
             : formatOperatingRulesText(null, 'Attendant operating rules:');
+        const projectPolicies = this.brief?.projectPolicies ?? await this.loadProjectPolicies();
         if (this.brief) {
-            this.brief.operatingRules = operatingRules;
+            this.brief.operatingRules = applyAdvisoryOperatingRules(applyProjectPolicyOperatingRules(operatingRules, projectPolicies), this.advisoryLearningProfile);
+            this.brief.projectPolicies = projectPolicies;
             this.brief.contextCallCount = 0;
         }
         this.contextCallCount = 0;
@@ -1473,6 +1793,7 @@ class AttendantInstance {
         return buildSessionComplianceState({
             attendsWithoutPersist: this.attendsWithoutPersist,
             consecutivePreResponseWithoutPost: this.consecutivePreResponseWithoutPost,
+            consecutiveUnusedMemoryInjections: this.consecutiveUnusedMemoryInjections,
             lastAttendPhase: this.lastAttendPhase,
             lastUpdated: lastUpdated ?? this.complianceUpdatedAt,
         });
@@ -1482,6 +1803,7 @@ class AttendantInstance {
         this.lastAttendPhase = undefined;
         this.consecutivePreResponseWithoutPost = 0;
         this.complianceUpdatedAt = new Date().toISOString();
+        this.recordMemoryEvidence('write');
         if (!this.brief) {
             return;
         }
@@ -1497,6 +1819,7 @@ class AttendantInstance {
         this.lastAttendPhase = undefined;
         this.consecutivePreResponseWithoutPost = 0;
         this.complianceUpdatedAt = new Date().toISOString();
+        this.recordMemoryEvidence('checkpoint');
         this.setLedgerContext(input.ledgerContext);
         const now = new Date().toISOString();
         if (!this.brief) {
@@ -1730,6 +2053,7 @@ class AttendantInstance {
         this.attendsWithoutPersist++;
         const phase = input.phase;
         let complianceWarning;
+        const ignoredMemoryWarning = 'COMPLIANCE: injected memory was surfaced but not used. On the next turn, either answer from injected facts directly or persist why the injected memory was insufficient before rediscovering the same state manually.';
         if (phase === 'post-response') {
             // Correct post-response call — reset counters
             this.attendsWithoutPersist = 0;
@@ -1753,7 +2077,10 @@ class AttendantInstance {
             }
         }
         this.complianceUpdatedAt = new Date().toISOString();
-        const compliance = this.buildComplianceState(this.complianceUpdatedAt);
+        let compliance = this.buildComplianceState(this.complianceUpdatedAt);
+        if (!complianceWarning && compliance.issues.some((issue) => issue.code === 'ignored_injected_memory')) {
+            complianceWarning = ignoredMemoryWarning;
+        }
         if (!this.brief) {
             const bootstrapTask = buildAttendBootstrapTask(latestMessage, currentContext);
             const bootstrapBrief = await this.handshake({
@@ -1788,6 +2115,52 @@ class AttendantInstance {
                 }),
             });
         }
+        if (phase === 'post-response') {
+            const memoryAttributions = this.scorePendingMemoryAttributions(latestMessage || currentContext);
+            compliance = this.buildComplianceState(this.complianceUpdatedAt);
+            if (memoryAttributions.some((entry) => !entry.used)) {
+                complianceWarning = ignoredMemoryWarning;
+            }
+            if (this.brief) {
+                this.brief = {
+                    ...this.brief,
+                    compliance,
+                    briefGeneratedAt: this.complianceUpdatedAt,
+                };
+                await this.persistState();
+            }
+            (0, metrics_1.timeEnd)('attendant.attend_ms', t0);
+            return {
+                shouldInject: false,
+                reason: 'memory_not_needed',
+                decision: {
+                    needed: false,
+                    confidence: 1,
+                    method: 'heuristic',
+                    explanation: 'post_response_closeout',
+                },
+                bootstrap,
+                complianceWarning,
+                compliance,
+                memoryAttributions,
+                usageGuidance: buildUsageGuidance('attend'),
+                facts: [],
+                entitiesDetected: [],
+                alreadyPresent: 0,
+                totalFound: 0,
+                entitiesResolved: [],
+                debug: {
+                    skipped: 'empty_context',
+                    contextLength: currentContext.length,
+                    detectionWindowChars: Math.min(currentContext.length, ENTITY_DETECTION_WINDOW_CHARS),
+                    detectedCandidates: 0,
+                    keptCandidates: 0,
+                    hintsProvided: effectiveEntityHints.length,
+                    hintsResolved: 0,
+                    dropped: [{ name: latestMessage || '(none)', reason: 'post_response_closeout' }],
+                },
+            };
+        }
         let decision = await this.decideMemoryNeed({
             currentContext,
             latestMessage,
@@ -1847,6 +2220,7 @@ class AttendantInstance {
                 bootstrap,
                 complianceWarning,
                 compliance,
+                memoryAttributions: [],
                 usageGuidance: buildUsageGuidance('attend'),
                 facts: [],
                 entitiesDetected: [],
@@ -1870,11 +2244,11 @@ class AttendantInstance {
             currentContext: observationContext,
             maxFacts: input.maxFacts,
             entityHints: observeEntityHints,
-            priorityKeys: Array.from(new Set([
+            priorityKeys: expandContinuityPriorityKeys(Array.from(new Set([
                 ...(mandatoryRecall.key ? [mandatoryRecall.key] : []),
                 ...(this.advisoryLearningProfile?.priorityKeys ?? []),
                 ...freshState.priorityKeys,
-            ])),
+            ]))),
             skipContextFilter: forceInject,
             ledgerContext: input.ledgerContext,
         });
@@ -1891,10 +2265,11 @@ class AttendantInstance {
             const remainder = slashIdx2 === -1 ? '' : fact.entityKey.slice(slashIdx2);
             return { ...fact, entityKey: `${canonicalPersonalType}/${canonicalPersonalId}${remainder}` };
         });
+        const structuredFacts = (0, hostMemoryFormatting_1.assignStructuredFactIds)(remappedFacts);
         watchedEntitiesChanged = this.updateWatchedEntities(observed.entitiesResolved?.map((entry) => entry.canonicalEntity) ?? []) || watchedEntitiesChanged;
         this.markSharedStateObserved(observeEntityHints.length > 0 ? observeEntityHints : freshState.entities);
         let reason = 'memory_needed_injected';
-        const shouldInject = remappedFacts.length > 0;
+        const shouldInject = structuredFacts.length > 0;
         let searchSuggestion;
         if (!shouldInject) {
             const allAlreadyInContext = observed.totalFound > 0 && observed.alreadyPresent >= observed.totalFound;
@@ -1916,16 +2291,28 @@ class AttendantInstance {
         else if (forceInject) {
             reason = 'forced';
         }
+        const memoryAttributions = shouldInject
+            ? [
+                this.addPendingMemoryAttribution({
+                    phase: phase === 'mid-turn' ? 'mid-turn' : 'pre-response',
+                    injectedKeys: structuredFacts.map((fact) => fact.entityKey),
+                    injectedEntryIds: structuredFacts
+                        .map((fact) => fact.knowledgeEntryId)
+                        .filter((value) => typeof value === 'number'),
+                }),
+            ]
+            : [];
         const attendResult = {
             ...observed,
-            facts: remappedFacts,
-            shouldInject,
+            facts: structuredFacts,
+            shouldInject: structuredFacts.length > 0,
             reason,
             decision,
             bootstrap,
             searchSuggestion,
             complianceWarning,
             compliance,
+            memoryAttributions,
             usageGuidance: buildUsageGuidance('attend'),
         };
         if (input.suppressEvents !== true) {
@@ -1940,6 +2327,7 @@ class AttendantInstance {
                     contextCallCount: this.contextCallCount,
                     shouldInject,
                     attendReason: reason,
+                    injectionId: memoryAttributions[0]?.injectionId ?? null,
                     advisoryDecisionMethod: decision.method,
                     advisoryScopes: this.advisoryLearningProfile?.scopesUsed ?? [],
                     freshStateEntities: freshState.entities,
@@ -1956,7 +2344,11 @@ class AttendantInstance {
                 metadata: this.buildEventMetadata({
                     shouldInject,
                     factCount: observed.facts.length,
+                    injectionId: memoryAttributions[0]?.injectionId ?? null,
                     injectedKeys: observed.facts.map((fact) => fact.entityKey),
+                    injectedEntryIds: observed.facts
+                        .map((fact) => fact.knowledgeEntryId)
+                        .filter((value) => typeof value === 'number'),
                     entitiesResolved: observed.entitiesResolved?.map((entry) => entry.canonicalEntity) ?? [],
                     alreadyPresent: observed.alreadyPresent,
                     totalFound: observed.totalFound,
@@ -1973,7 +2365,7 @@ class AttendantInstance {
                 briefGeneratedAt: this.complianceUpdatedAt,
             };
         }
-        if (watchedEntitiesChanged || this.brief?.compliance !== compliance) {
+        if (watchedEntitiesChanged || this.brief?.compliance !== compliance || memoryAttributions.length > 0) {
             await this.persistState();
         }
         (0, metrics_1.timeEnd)('attendant.attend_ms', t0);
@@ -2034,29 +2426,29 @@ class AttendantInstance {
             const entityResponse = await (0, router_1.route)('extraction', [
                 {
                     role: 'user',
-                    content: `Extract explicitly named entities from the text.
-An entity can be a person, organization, project, technology, or named concept.
-
-Return ONLY valid JSON as an array of objects in this exact shape:
-[
-  {
-    "type": "project",
-    "name": "Project Atlas",
-    "id_guess": "project_atlas",
-    "confidence": 0.92,
-    "evidence": "Project Atlas",
-    "start": 123,
-    "end": 136
-  }
-]
-
-Rules:
-- Only include entities explicitly named in the provided text.
-- Do not infer or carry over entities not present in the text.
-- If uncertain, omit.
-- If none are present, return [].
-
-Text:
+                    content: `Extract explicitly named entities from the text.
+An entity can be a person, organization, project, technology, or named concept.
+
+Return ONLY valid JSON as an array of objects in this exact shape:
+[
+  {
+    "type": "project",
+    "name": "Project Atlas",
+    "id_guess": "project_atlas",
+    "confidence": 0.92,
+    "evidence": "Project Atlas",
+    "start": 123,
+    "end": 136
+  }
+]
+
+Rules:
+- Only include entities explicitly named in the provided text.
+- Do not infer or carry over entities not present in the text.
+- If uncertain, omit.
+- If none are present, return [].
+
+Text:
 ${detectionWindow}`,
                 },
             ], 512);
@@ -2253,7 +2645,7 @@ ${detectionWindow}`,
             const allEntries = await (0, queries_1.findEntriesByEntity)(resolvedInfo.entityType, resolvedInfo.entityId);
             // Priority keys first
             const policyPriorityKeys = policy.observeKeyPriority?.[resolvedInfo.entityType] ?? [];
-            const priorityKeys = new Set([...policyPriorityKeys, ...requestedPriorityKeys]);
+            const priorityKeys = new Set(expandContinuityPriorityKeys([...policyPriorityKeys, ...requestedPriorityKeys]));
             const priorityEntries = allEntries.filter((e) => priorityKeys.has(e.key));
             const remainingEntries = allEntries
                 .filter((e) => !priorityKeys.has(e.key))
@@ -2264,13 +2656,20 @@ ${detectionWindow}`,
                     || a.key.localeCompare(b.key));
             });
             const selectedEntries = [...priorityEntries, ...remainingEntries].slice(0, maxKeysPerEntity);
+            const freshestEntry = allEntries
+                .slice()
+                .sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime() || b.confidence - a.confidence)[0];
+            if (freshestEntry && !selectedEntries.some((entry) => entry.id === freshestEntry.id)) {
+                selectedEntries[selectedEntries.length - 1] = freshestEntry;
+            }
             for (const entry of selectedEntries) {
                 allFacts.push({
-                    entityKey: `${resolvedInfo.entityType}/${resolvedInfo.entityId}/${entry.key}`,
+                    entityKey: `${resolvedInfo.entityType}/${resolvedInfo.entityId}/${normalizeContinuityKey(entry.key)}`,
                     summary: entry.valueSummary,
                     value: entry.valueRaw,
                     confidence: entry.confidence,
                     source: entry.source,
+                    lastUpdated: entry.updatedAt.toISOString(),
                     entryId: entry.id,
                 });
             }
@@ -2312,13 +2711,15 @@ ${detectionWindow}`,
         });
         (0, metrics_1.timeEnd)('attendant.observe_ms', t0);
         return {
-            facts: topFacts.map(({ entityKey, summary, value, confidence, source }) => ({
+            facts: (0, hostMemoryFormatting_1.assignStructuredFactIds)(topFacts.map(({ entityKey, summary, value, confidence, source, lastUpdated, entryId }) => ({
+                knowledgeEntryId: entryId,
                 entityKey,
                 summary,
                 value,
                 confidence,
                 source,
-            })),
+                lastUpdated,
+            }))),
             entitiesDetected: Array.from(entitiesDetected),
             alreadyPresent,
             totalFound: allFacts.length,
@@ -2381,21 +2782,21 @@ ${detectionWindow}`,
         const response = await (0, router_1.route)('classification', [
             {
                 role: 'user',
-                content: `Decide whether this assistant should fetch persistent memory before replying.
-
-Latest user message:
-${input.latestMessage || '(none)'}
-
-Recent context excerpt:
-${contextWindow || '(empty)'}
-
-Return ONLY valid JSON with this exact shape:
-{"needsMemory":true,"confidence":0.81,"reason":"short_reason"}
-
-Rules:
-- needsMemory=true when the message involves project context, technical decisions, code state, prior work, open tasks, bugs, architecture, preferences, or anything session- or project-specific.
-- needsMemory=true when in doubt — false positives are cheap, false negatives lose context.
-- needsMemory=false ONLY for clear one-word acks, simple greetings, or purely generic factual questions with no project relevance.
+                content: `Decide whether this assistant should fetch persistent memory before replying.
+
+Latest user message:
+${input.latestMessage || '(none)'}
+
+Recent context excerpt:
+${contextWindow || '(empty)'}
+
+Return ONLY valid JSON with this exact shape:
+{"needsMemory":true,"confidence":0.81,"reason":"short_reason"}
+
+Rules:
+- needsMemory=true when the message involves project context, technical decisions, code state, prior work, open tasks, bugs, architecture, preferences, or anything session- or project-specific.
+- needsMemory=true when in doubt — false positives are cheap, false negatives lose context.
+- needsMemory=false ONLY for clear one-word acks, simple greetings, or purely generic factual questions with no project relevance.
 - confidence is a float from 0 to 1.`,
             },
         ], 128);
@@ -2758,14 +3159,14 @@ Rules:
         const response = await (0, router_1.route)('task_inference', [
             {
                 role: 'user',
-                content: `You are analyzing what an AI agent is currently working on.
-
-Agent ID: ${this.agentId}
-Task description: ${context.task}
-Recent messages:
-${context.recentMessages.map((m, i) => `${i + 1}. ${m}`).join('\n')}
-
-In one short sentence, describe the specific type of task this agent is currently performing.
+                content: `You are analyzing what an AI agent is currently working on.
+
+Agent ID: ${this.agentId}
+Task description: ${context.task}
+Recent messages:
+${context.recentMessages.map((m, i) => `${i + 1}. ${m}`).join('\n')}
+
+In one short sentence, describe the specific type of task this agent is currently performing.
 Be specific and concrete.`,
             },
         ], 256);
@@ -2798,15 +3199,15 @@ Be specific and concrete.`,
         const response = await (0, router_1.route)('relevance_filtering', [
             {
                 role: 'user',
-                content: `You are deciding what knowledge an AI agent needs for its current task.
-
-Agent task: ${taskType}
-
-Available knowledge entries:
-${entryInputs.map((e, i) => `${i + 1}. [${e.key}] ${e.valueSummary} (confidence: ${e.confidence})`).join('\n')}
-
-Return only the numbers of entries that are directly relevant to the current task.
-Format: comma-separated numbers only. Example: 1,3,5
+                content: `You are deciding what knowledge an AI agent needs for its current task.
+
+Agent task: ${taskType}
+
+Available knowledge entries:
+${entryInputs.map((e, i) => `${i + 1}. [${e.key}] ${e.valueSummary} (confidence: ${e.confidence})`).join('\n')}
+
+Return only the numbers of entries that are directly relevant to the current task.
+Format: comma-separated numbers only. Example: 1,3,5
 If nothing is relevant, return: none`,
             },
         ], 128);
@@ -2832,6 +3233,7 @@ If nothing is relevant, return: none`,
         this.brief = {
             ...this.brief,
             compliance: this.buildComplianceState(),
+            pendingMemoryAttributions: this.pendingMemoryAttributions.map((entry) => ({ ...entry })),
         };
         await (0, client_1.getDb)().knowledgeEntry.upsert({
             where: {
@@ -2871,8 +3273,12 @@ If nothing is relevant, return: none`,
         this.sharedStateObservedAt = state.briefGeneratedAt;
         this.attendsWithoutPersist = state.compliance?.counters.attendsWithoutPersist ?? 0;
         this.consecutivePreResponseWithoutPost = state.compliance?.counters.consecutivePreResponseWithoutPost ?? 0;
+        this.consecutiveUnusedMemoryInjections = state.compliance?.counters.consecutiveUnusedMemoryInjections ?? 0;
         this.lastAttendPhase = state.compliance?.counters.lastAttendPhase ?? undefined;
         this.complianceUpdatedAt = state.compliance?.lastUpdated ?? state.briefGeneratedAt;
+        this.pendingMemoryAttributions = Array.isArray(state.pendingMemoryAttributions)
+            ? state.pendingMemoryAttributions.map((entry) => ({ ...entry }))
+            : [];
         this.brief = state;
         return state;
     }