iranti 0.3.30 → 0.3.32

package/dist/src/attendant/AttendantInstance.js

@@ -7,6 +7,7 @@ exports.extractRuleTriggers = extractRuleTriggers;
 exports.matchesRuleTriggers = matchesRuleTriggers;
 exports.formatMatchedUserRules = formatMatchedUserRules;
 exports.extractFilePathEntityHints = extractFilePathEntityHints;
+exports.detectFileAction = detectFileAction;
 exports.resolveAutowriteTargetEntity = resolveAutowriteTargetEntity;
 exports.parseAutowriteEntity = parseAutowriteEntity;
 exports.buildToolResultContextLabel = buildToolResultContextLabel;
@@ -40,6 +41,7 @@ const sessionLedger_1 = require("../lib/sessionLedger");
 const sharedStateInvalidation_1 = require("../lib/sharedStateInvalidation");
 const hostMemoryFormatting_1 = require("../lib/hostMemoryFormatting");
 const council_1 = require("../staff/council");
+const subTurnLoop_1 = require("../staff/subTurnLoop");
 // ─── Constants ───────────────────────────────────────────────────────────────
 const ATTENDANT_RULES_QUERY = {
     entityType: 'system',
@@ -96,6 +98,10 @@ const TOOL_COST_WRITE_NUDGE_THRESHOLD = 5;
 // concrete draft facts instead of a vague "write something" reminder.
 const RECENT_AUTOWRITE_BUFFER_LIMIT = 12;
 const AUTOWRITE_SOURCE_TAG = 'attendant_autowrite';
+// M7: response file-change autowrite — constants governing the scan pass
+// that runs at post-response to extract file paths from the agent's reply.
+const RESPONSE_FILE_CAPTURE_MIN_CHARS = 50;
+const RESPONSE_FILE_CAPTURE_MAX_FILES = 20;
 const MIN_ENTITY_CONFIDENCE = 0.75;
 const MEMORY_DECISION_CONTEXT_WINDOW_CHARS = 2000;
 const LEDGER_WORKING_MEMORY_PREFIX = 'system/session_ledger/recent_learning_';
@@ -527,6 +533,18 @@ function scanStringForPathEntities(text, projectId, seen, hints) {
         deriveFileEntityFromPath(match[1], projectId, seen, hints);
     }
 }
+// M7: infer whether a file path mention in the agent's response represents
+// an edit, a creation, or a read. Scans the ±150-char context window for
+// action-bearing keywords. Defaults to 'read' when the signal is ambiguous.
+// Exported for direct unit testing.
+function detectFileAction(contextWindow) {
+    const ctx = contextWindow.toLowerCase();
+    if (/\bcreat\w*\b|\bnew file\b|\badded new\b|\bwrote new\b/.test(ctx))
+        return 'created';
+    if (/\bedit\w*\b|\bupdat\w*\b|\bmodif\w*\b|\bchanged\b|\bwrote\b|\brewrote\b|\brefactor\w*\b/.test(ctx))
+        return 'edited';
+    return 'read';
+}
 function extractBasenameFromGlobPattern(pattern) {
     // A glob like "src/**/*.ts" has no meaningful basename; one like
     // "tests/attendant/run_mid_turn_attend_tests.ts" does. We only derive a
@@ -3280,6 +3298,149 @@ If no durable facts can be extracted, return an empty array: [].`,
         }
         return baseOutcome;
     }
+    // M7: scan the agent's post-response text for file path mentions, infer
+    // the most likely action (edited / created / read) from surrounding context,
+    // and write one durable fact per file-scoped entity. This populates the
+    // project/{id}/file/{basename} entity namespace so demand-driven recall
+    // (extractFilePathEntityHints + observe) can surface the facts in future
+    // sessions without any host-side collection effort.
+    //
+    // Isolation policy: extraction failures (regex errors, downstream write
+    // errors) MUST NOT abort the attend call. This method swallows its own
+    // errors and reports them via the skipped array.
+    async runResponseFileCapture(responseText, batchId) {
+        const t0 = Date.now();
+        const skipped = [];
+        const baseResult = {
+            autowriteBatchId: batchId,
+            filesDetected: 0,
+            factsWritten: 0,
+            entities: [],
+            skipped,
+            durationMs: 0,
+        };
+        if (!responseText || responseText.trim().length < RESPONSE_FILE_CAPTURE_MIN_CHARS) {
+            skipped.push({ reason: 'response_too_short' });
+            baseResult.durationMs = Date.now() - t0;
+            return baseResult;
+        }
+        const projectEntity = (0, autoRemember_1.getProjectMemoryEntity)() ?? null;
+        if (!projectEntity) {
+            skipped.push({ reason: 'no_project_entity' });
+            baseResult.durationMs = Date.now() - t0;
+            return baseResult;
+        }
+        const projectId = (0, entity_resolution_1.parseEntityString)(projectEntity).entityId;
+        // Scan the response text for file path occurrences. One fact per
+        // distinct basename — first occurrence wins if the same file appears
+        // multiple times in the same response.
+        const seenEntities = new Set();
+        const fileOccurrences = [];
+        FILE_PATH_PATTERN.lastIndex = 0;
+        let match;
+        while ((match = FILE_PATH_PATTERN.exec(responseText)) !== null) {
+            const filePath = match[1].trim();
+            const basename = filePath.replace(/\\/g, '/').split('/').pop() ?? '';
+            const stripped = basename.split(/[,:()]/)[0] ?? basename;
+            const nameWithoutExt = stripped
+                .replace(/\.\w+$/, '')
+                .replace(/[^a-zA-Z0-9]/g, '_')
+                .toLowerCase();
+            if (!nameWithoutExt || nameWithoutExt.length < 2)
+                continue;
+            const entity = `project/${projectId}/file/${nameWithoutExt}`;
+            if (seenEntities.has(entity))
+                continue;
+            seenEntities.add(entity);
+            // Grab a context window around the match for action detection.
+            const matchStart = match.index;
+            const contextStart = Math.max(0, matchStart - 150);
+            const contextEnd = Math.min(responseText.length, matchStart + filePath.length + 150);
+            const contextWindow = responseText.slice(contextStart, contextEnd);
+            fileOccurrences.push({ path: filePath, entity, contextWindow });
+            if (fileOccurrences.length >= RESPONSE_FILE_CAPTURE_MAX_FILES)
+                break;
+        }
+        baseResult.filesDetected = fileOccurrences.length;
+        if (fileOccurrences.length === 0) {
+            baseResult.durationMs = Date.now() - t0;
+            return baseResult;
+        }
+        const writtenEntities = [];
+        for (const { path, entity, contextWindow } of fileOccurrences) {
+            const action = detectFileAction(contextWindow);
+            const key = (action === 'edited' || action === 'created') ? 'last_edit' : 'last_access';
+            const confidence = (action === 'edited' || action === 'created') ? 85 : 70;
+            const parsedEntity = parseAutowriteEntity(entity);
+            const displayName = path.replace(/\\/g, '/').split('/').pop() ?? path;
+            const value = {
+                action,
+                path,
+                capturedAt: new Date().toISOString(),
+            };
+            const summary = `${displayName} was ${action} — captured from agent response at post-response.`;
+            try {
+                await (0, librarian_1.librarianWrite)({
+                    entityType: parsedEntity.entityType,
+                    entityId: parsedEntity.entityId,
+                    key,
+                    valueRaw: value,
+                    valueSummary: summary.slice(0, 500),
+                    confidence,
+                    source: AUTOWRITE_SOURCE_TAG,
+                    createdBy: `attendant:${this.agentId}`,
+                    properties: {
+                        memoryScope: 'project',
+                        capturePhase: 'response_file_change_autowrite',
+                        autowriteBatchId: batchId,
+                        fileAction: action,
+                        autowriteOccurredAt: new Date().toISOString(),
+                        ...(0, semanticFactTags_1.buildSemanticFactTags)({
+                            memoryScope: 'project',
+                            durableClass: 'file_change',
+                            mergeStrategy: 'replace',
+                            extraTags: ['autowrite', 'response_capture', `action:${action}`],
+                        }),
+                    },
+                });
+                writtenEntities.push(entity);
+            }
+            catch (err) {
+                skipped.push({
+                    reason: 'librarian_write_failed',
+                    detail: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+        baseResult.factsWritten = writtenEntities.length;
+        baseResult.entities = writtenEntities;
+        baseResult.durationMs = Date.now() - t0;
+        if (writtenEntities.length > 0) {
+            // Autowriting file-change facts counts as durable persistence —
+            // reset pressure counters and notify compliance tracking.
+            this.attendsWithoutPersist = 0;
+            this.turnsWithoutWrite = 0;
+            this.writeOccurredThisTurn = true;
+            this.recordMemoryEvidence('write');
+            if (this.eventSource) {
+                (0, staffEventRegistry_1.getStaffEventEmitter)().emit({
+                    staffComponent: 'Attendant',
+                    actionType: 'attendant_autowrite',
+                    agentId: this.agentId,
+                    source: this.eventSource,
+                    reason: 'response_file_change_autowrite',
+                    level: 'audit',
+                    metadata: this.buildEventMetadata({
+                        autowriteBatchId: batchId,
+                        filesDetected: baseResult.filesDetected,
+                        factsWritten: baseResult.factsWritten,
+                        entities: writtenEntities,
+                    }),
+                });
+            }
+        }
+        return baseResult;
+    }
     // M3: build a forced write-nudge payload when tool-cost pressure crosses
     // TOOL_COST_WRITE_NUDGE_THRESHOLD and the nudge has not already been
     // emitted this turn. Returns null when no nudge should fire. The nudge
@@ -3741,6 +3902,10 @@ If no durable facts can be extracted, return an empty array: [].`,
         }
         if (phase === 'post-response') {
             const memoryAttributions = this.scorePendingMemoryAttributions(latestMessage || currentContext);
+            // M7: scan the agent's response for file path mentions and write file-scoped facts.
+            // Must run BEFORE buildComplianceState so that any writes here reset the
+            // pressure counters and are reflected in the compliance snapshot.
+            const responseFileCapture = await this.runResponseFileCapture(latestMessage, `rfca_${Date.now()}`);
             compliance = this.buildComplianceState(this.complianceUpdatedAt);
             if (memoryAttributions.some((entry) => !entry.used)) {
                 complianceWarning = ignoredMemoryWarning;
@@ -3827,6 +3992,23 @@ If no durable facts can be extracted, return an empty array: [].`,
                     outcome: 'no_context',
                     budgetMax: 0,
                 },
+                // B8 M6: sub-turn reasoning loop is gated off on post-response.
+                // Field echoed as a declined shell for destructure parity.
+                subTurnLoopPlan: {
+                    outcome: 'declined_post_response',
+                    attempted: false,
+                    partialResponseLength: 0,
+                    initialFactCount: 0,
+                    addedFactCount: 0,
+                    rescoreTokens: [],
+                    proposedHints: [],
+                    budgetMax: 0,
+                    reason: 'post_response_closeout',
+                    note: 'Sub-turn loop is gated off on post-response attends.',
+                },
+                // M7: response file-change autowrite — populated at post-response.
+                // Contains the outcome of the scan pass over the agent's reply.
+                responseFileCapture,
             };
         }
         let decision = await this.decideMemoryNeed({
@@ -4005,6 +4187,17 @@ If no durable facts can be extracted, return an empty array: [].`,
                         lowConfidenceCount: 0,
                     },
                 }),
+                // B8 M6: sub-turn loop plan populated even on the not-needed
+                // path — the helper will decline cleanly because no retrieval
+                // ran (initialFactCount=0) and, on non-mid-turn phases, the
+                // phase gate fires first. Pure helper so no latency concern.
+                subTurnLoopPlan: (0, subTurnLoop_1.planSubTurnLoop)({
+                    phase,
+                    partialResponse: input.partialResponse,
+                    latestMessage,
+                    originalEntityHints: effectiveEntityHints,
+                    initialFactCount: 0,
+                }),
             };
         }
         // Post-compaction recovery: re-surface facts that were recently injected (likely in context
@@ -4137,6 +4330,85 @@ If no durable facts can be extracted, return an empty array: [].`,
                 note: 'No refinement pass required.',
             };
         }
+        // B8 M6: sub-turn reasoning loop. When the caller passed a partial
+        // assistant response on a mid-turn attend, re-score that partial
+        // against the baseline retrieval and decide whether to fire ONE
+        // bounded extra observe() call with broadened hints harvested from
+        // the partial text. This is A3's refinement pattern re-applied on
+        // response progress rather than initial-pass emptiness. Pure plan
+        // + at most one retry; same union-of-original+proposed hint fix as
+        // B6's refinement retry above. Gates ensure it only fires on
+        // mid-turn with a non-trivial partial response carrying novel
+        // tokens or type/id patterns beyond the baseline.
+        const subTurnInitialCount = augmentedObservedFacts.length;
+        let subTurnLoopPlan = (0, subTurnLoop_1.planSubTurnLoop)({
+            phase,
+            partialResponse: input.partialResponse,
+            latestMessage,
+            originalEntityHints: allObserveEntityHints,
+            initialFactCount: subTurnInitialCount,
+        });
+        if (subTurnLoopPlan.attempted && subTurnLoopPlan.proposedHints.length > 0) {
+            // Retry uses the UNION of allObserveEntityHints and the
+            // sub-turn proposed hints — same preservation fix as B6 so a
+            // specific host-supplied hint is not dropped when the sub-turn
+            // widens with patterns harvested from the partial response.
+            const subTurnRetryHints = Array.from(new Set([
+                ...allObserveEntityHints,
+                ...subTurnLoopPlan.proposedHints,
+            ]));
+            try {
+                const subTurnObserved = await this.observe({
+                    currentContext: observationContext,
+                    maxFacts: effectiveMaxFacts,
+                    entityHints: subTurnRetryHints,
+                    priorityKeys: expandContinuityPriorityKeys(Array.from(new Set([
+                        ...(mandatoryRecall.key ? [mandatoryRecall.key] : []),
+                        ...(this.advisoryLearningProfile?.priorityKeys ?? []),
+                        ...freshState.priorityKeys,
+                    ]))),
+                    skipContextFilter: forceInject,
+                    recoveryKeys: postCompactionRecoveryKeys.length > 0 ? postCompactionRecoveryKeys : undefined,
+                    ledgerContext: input.ledgerContext,
+                });
+                // Merge new facts that weren't already in augmentedObservedFacts.
+                // Uses entityKey as the dedup key, same as the mid-turn
+                // filter below. A net-new fact count of 0 means the retry
+                // resolved the same facts we already had — treat as empty.
+                const existingKeys = new Set(augmentedObservedFacts.map((f) => f.entityKey));
+                const netNewFacts = subTurnObserved.facts.filter((f) => !existingKeys.has(f.entityKey));
+                if (netNewFacts.length > 0) {
+                    augmentedObservedFacts = [...augmentedObservedFacts, ...netNewFacts];
+                    augmentedObservedTotalFound = augmentedObservedTotalFound + netNewFacts.length;
+                    subTurnLoopPlan = {
+                        ...subTurnLoopPlan,
+                        outcome: 'attempted_added',
+                        addedFactCount: netNewFacts.length,
+                        note: `Sub-turn loop added ${netNewFacts.length} fact(s) via proposed hints (${subTurnLoopPlan.proposedHints.join(', ')}).`,
+                    };
+                }
+                else {
+                    subTurnLoopPlan = {
+                        ...subTurnLoopPlan,
+                        outcome: 'attempted_empty',
+                        addedFactCount: 0,
+                        note: `Sub-turn loop with proposed hints (${subTurnLoopPlan.proposedHints.join(', ')}) returned no net-new facts.`,
+                    };
+                }
+            }
+            catch (err) {
+                // Sub-turn loop must never crash attend. Record a declined
+                // outcome with the error and continue.
+                subTurnLoopPlan = {
+                    ...subTurnLoopPlan,
+                    outcome: 'attempted_empty',
+                    attempted: false,
+                    addedFactCount: 0,
+                    reason: `sub_turn_retry_threw: ${err instanceof Error ? err.message : String(err)}`,
+                    note: 'Sub-turn loop aborted due to retry error; baseline retrieval stands.',
+                };
+            }
+        }
         // A5: tool-using Attendant (planned). Derive the proposed follow-up
         // tool calls from current brief state + retrieval outcome + drift.
         // Pure and deterministic — the Attendant does not execute them.
@@ -4368,6 +4640,13 @@ If no durable facts can be extracted, return an empty array: [].`,
             // the Attendant would consult if council mode were live.
             // Pure, deterministic, never executed here.
             councilConsultationPlan,
+            // B8 M6: sub-turn reasoning loop plan — when a mid-turn attend
+            // carries a partial assistant response, the Attendant re-scores
+            // that partial against baseline retrieval and fires at most one
+            // extra observe() call with broadened hints harvested from the
+            // partial text. attempted=false / decline outcomes are echoed
+            // on non-mid-turn phases so hosts can safely destructure.
+            subTurnLoopPlan,
         };
         if (input.suppressEvents !== true) {
             (0, staffEventRegistry_1.getStaffEventEmitter)().emit({