iranti 0.3.0 → 0.3.3

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.",
@@ -65,8 +72,22 @@ const ATTEND_EXPECTED_CALL_SEQUENCE = [
     "Call iranti_attend(phase='post-response') after every response without exception — even short replies may contain durable findings. Omitting this call is a compliance violation.",
     'Call iranti_attend again when the new knowledge should change what is loaded next.',
 ];
-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 ATTEND_USAGE_REMINDER = 'Iranti is a hive mind. MANDATORY: call iranti_attend before every reply and around knowledge discovery. MANDATORY: call iranti_write after every file edit, confirmed finding, environment state change, and subagent completion — write what changed, why, and what it means. Skipping writes means the next session starts blind and must rediscover everything from scratch.';
 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',
@@ -254,10 +352,20 @@ function advisoryTaskTokens(taskType) {
         .map((token) => token.trim())
         .filter((token) => token.length >= 4)));
 }
-function buildUsageGuidance(tool) {
+function buildUsageGuidance(tool, turnsWithoutWrite = 0) {
+    let reminder = ATTEND_USAGE_REMINDER;
+    if (turnsWithoutWrite >= 3) {
+        reminder += ` NON-COMPLIANT: ${turnsWithoutWrite} turns have completed without a single iranti_write call. You are losing knowledge. Call iranti_write NOW for any findings, file changes, or decisions from recent turns.`;
+    }
+    else if (turnsWithoutWrite >= 2) {
+        reminder += ` WARNING: ${turnsWithoutWrite} turns without an iranti_write call. If you discovered, changed, or confirmed anything, write it now before it is lost.`;
+    }
+    else if (turnsWithoutWrite === 1) {
+        reminder += ' Reminder: if the previous turn produced durable findings, call iranti_write before continuing.';
+    }
     return {
         tool,
-        reminder: ATTEND_USAGE_REMINDER,
+        reminder,
         expectedCallSequence: ATTEND_EXPECTED_CALL_SEQUENCE,
         note: tool === 'observe'
             ? OBSERVE_USAGE_NOTE
@@ -489,6 +597,28 @@ 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.turnsWithoutWrite >= 2) {
+        const severity = input.turnsWithoutWrite >= 3 ? 'error' : 'warn';
+        issues.push({
+            code: 'missing_writes_across_turns',
+            severity,
+            count: input.turnsWithoutWrite,
+            message: `${input.turnsWithoutWrite} completed turns without a single iranti_write or iranti_checkpoint call. Knowledge discovered during these turns is not being persisted.`,
+            requiredAction: 'Call iranti_write for each durable finding — file edits, confirmed facts, environment state, subagent results. Every turn that discovers something should write it.',
+        });
+    }
+    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 +631,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: iranti_write has not been called after recent knowledge-changing actions.'
             : 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: iranti_write calls are missing — durable findings are not being persisted.';
     return {
         status,
         summary,
@@ -512,7 +646,9 @@ function buildSessionComplianceState(input) {
         lastUpdated: input.lastUpdated ?? new Date().toISOString(),
         counters: {
             attendsWithoutPersist: input.attendsWithoutPersist,
+            turnsWithoutWrite: input.turnsWithoutWrite,
             consecutivePreResponseWithoutPost: input.consecutivePreResponseWithoutPost,
+            consecutiveUnusedMemoryInjections: input.consecutiveUnusedMemoryInjections,
             pendingPostResponse,
             lastAttendPhase: input.lastAttendPhase ?? null,
         },
@@ -970,13 +1106,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 +1125,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 +1163,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 +1231,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 +1250,7 @@ async function persistSharedCheckpointBreadcrumbs(params) {
             expectedKeys.push({
                 entityType: resolved.entityType,
                 entityId: resolved.entityId,
-                key: 'checkpoint_open_risks',
+                key: 'open_risks',
             });
         }
     }
@@ -1199,7 +1348,9 @@ class AttendantInstance {
         this.advisoryLearningProfile = null;
         this.contextCallCount = 0;
         this.attendsWithoutPersist = 0;
+        this.turnsWithoutWrite = 0;
         this.consecutivePreResponseWithoutPost = 0;
+        this.consecutiveUnusedMemoryInjections = 0;
         this.lastAttendPhase = undefined;
         this.complianceUpdatedAt = new Date().toISOString();
         this.sessionStarted = new Date().toISOString();
@@ -1208,6 +1359,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 +1384,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 +1562,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 +1600,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 +1625,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 +1655,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 +1673,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 +1690,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 +1712,7 @@ class AttendantInstance {
                 metadata: this.buildEventMetadata({
                     briefSize: this.brief?.workingMemory.length ?? 0,
                     contextCallCount: this.contextCallCount,
+                    projectPolicyCount: projectPolicies.length,
                     advisoryScopes: this.advisoryLearningProfile?.scopesUsed ?? [],
                 }),
             });
@@ -1385,9 +1723,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 +1746,7 @@ class AttendantInstance {
             metadata: this.buildEventMetadata({
                 briefSize: this.brief?.workingMemory.length ?? 0,
                 contextCallCount: this.contextCallCount,
+                projectPolicyCount: projectPolicies.length,
                 advisoryScopes: this.advisoryLearningProfile?.scopesUsed ?? [],
             }),
         });
@@ -1434,8 +1774,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;
@@ -1472,16 +1814,20 @@ class AttendantInstance {
     buildComplianceState(lastUpdated) {
         return buildSessionComplianceState({
             attendsWithoutPersist: this.attendsWithoutPersist,
+            turnsWithoutWrite: this.turnsWithoutWrite,
             consecutivePreResponseWithoutPost: this.consecutivePreResponseWithoutPost,
+            consecutiveUnusedMemoryInjections: this.consecutiveUnusedMemoryInjections,
             lastAttendPhase: this.lastAttendPhase,
             lastUpdated: lastUpdated ?? this.complianceUpdatedAt,
         });
     }
     async notifyWriteOccurred() {
         this.attendsWithoutPersist = 0;
+        this.turnsWithoutWrite = 0;
         this.lastAttendPhase = undefined;
         this.consecutivePreResponseWithoutPost = 0;
         this.complianceUpdatedAt = new Date().toISOString();
+        this.recordMemoryEvidence('write');
         if (!this.brief) {
             return;
         }
@@ -1494,9 +1840,11 @@ class AttendantInstance {
     }
     async checkpoint(input) {
         this.attendsWithoutPersist = 0;
+        this.turnsWithoutWrite = 0;
         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,9 +2078,12 @@ 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
+            // Correct post-response call — reset attend counters but NOT turnsWithoutWrite
+            // turnsWithoutWrite only resets on actual writes/checkpoints
             this.attendsWithoutPersist = 0;
+            this.turnsWithoutWrite++;
             this.lastAttendPhase = 'post-response';
             this.consecutivePreResponseWithoutPost = 0;
         }
@@ -1753,7 +2104,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 +2142,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', this.turnsWithoutWrite),
+                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,7 +2247,8 @@ class AttendantInstance {
                 bootstrap,
                 complianceWarning,
                 compliance,
-                usageGuidance: buildUsageGuidance('attend'),
+                memoryAttributions: [],
+                usageGuidance: buildUsageGuidance('attend', this.turnsWithoutWrite),
                 facts: [],
                 entitiesDetected: [],
                 alreadyPresent: 0,
@@ -1870,11 +2271,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 +2292,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,17 +2318,29 @@ 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,
-            usageGuidance: buildUsageGuidance('attend'),
+            memoryAttributions,
+            usageGuidance: buildUsageGuidance('attend', this.turnsWithoutWrite),
         };
         if (input.suppressEvents !== true) {
             (0, staffEventRegistry_1.getStaffEventEmitter)().emit({
@@ -1940,6 +2354,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 +2371,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 +2392,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);
@@ -2253,7 +2672,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 +2683,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 +2738,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,
@@ -2832,6 +3260,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: {
@@ -2870,9 +3299,14 @@ If nothing is relevant, return: none`,
         this.advisoryLearningProfile = null;
         this.sharedStateObservedAt = state.briefGeneratedAt;
         this.attendsWithoutPersist = state.compliance?.counters.attendsWithoutPersist ?? 0;
+        this.turnsWithoutWrite = state.compliance?.counters.turnsWithoutWrite ?? 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;
     }