const postCompactionGuard = createPostCompactionLoopGuard(

params.config?.tools?.loopDetection?.postCompactionGuard,

);

let lastObservedToolCallHistoryIndex = (() => {

// Monotonic outcome seq (incremented by recordToolCallOutcome on each

// observable push). We use a delta on this counter instead of an

// absolute index into state.toolCallHistory, which is trimmed at

// historySize and would silently shift records out from under an

// index cursor in long-running sessions.

let lastObservedToolOutcomeSeq = (() => {

if (!params.sessionKey && !params.sessionId) {

return 0;

}

const state = getDiagnosticSessionState({

...(params.sessionKey ? { sessionKey: params.sessionKey } : {}),

...(params.sessionId ? { sessionId: params.sessionId } : {}),

});

return state.toolCallHistory?.length ?? 0;

return state.toolOutcomeSeq ?? 0;

})();

let lastRetryFailoverReason: FailoverReason | null = null;

let planningOnlyRetryInstruction: string | null = null;

// records that completed during this attempt (populated by the

// before-tool-call hook's recordToolCallOutcome) and feeds them

// into the guard. Disarms automatically once the window expires.

//

// Cursor scheme: rather than index into state.toolCallHistory

// (which trims at historySize and silently drops records on busy

// sessions), we read state.toolOutcomeSeq, a monotonic counter

// that recordToolCallOutcome increments on every observable push.

// The delta currentSeq - lastObservedSeq tells us how many new

// records have appeared globally; we then scan that many entries

// from the tail of toolCallHistory. The tail-slice is trim-safe:

// even if the buffer was full, the most recent N records are the

// ones that survive.

if (postCompactionGuard.snapshot().armed) {

const guardSessionState =

params.sessionKey || params.sessionId

})

: undefined;

const history = guardSessionState?.toolCallHistory ?? [];

for (let i = lastObservedToolCallHistoryIndex; i < history.length; i += 1) {

const record = history[i];

if (!record || !record.resultHash) {

continue;

}

if (params.runId && record.runId && record.runId !== params.runId) {

continue;

}

const verdict = postCompactionGuard.observe({

toolName: record.toolName,

argsHash: record.argsHash,

resultHash: record.resultHash,

});

if (verdict.shouldAbort) {

throw PostCompactionLoopPersistedError.fromVerdict(verdict);

}

if (!postCompactionGuard.snapshot().armed) {

break;

const currentSeq = guardSessionState?.toolOutcomeSeq ?? 0;

const newRecordCount = Math.max(0, currentSeq - lastObservedToolOutcomeSeq);

if (newRecordCount > 0) {

const startIndex = Math.max(0, history.length - newRecordCount);

for (let i = startIndex; i < history.length; i += 1) {

const record = history[i];

if (!record || typeof record.resultHash !== "string") {

continue;

}

if (params.runId && record.runId && record.runId !== params.runId) {

continue;

}

const verdict = postCompactionGuard.observe({

toolName: record.toolName,

argsHash: record.argsHash,

resultHash: record.resultHash,

});

if (verdict.shouldAbort) {

throw PostCompactionLoopPersistedError.fromVerdict(verdict);

}

if (!postCompactionGuard.snapshot().armed) {

break;

}

}

}

lastObservedToolCallHistoryIndex = history.length;

lastObservedToolOutcomeSeq = currentSeq;

} else {

// Keep index aligned with current history length so freshly armed

// windows only see records from the post-compaction-retry attempt.

// Keep cursor aligned with the current global outcome seq so a

// freshly-armed window only sees records pushed AFTER arming.

const guardSessionState =

params.sessionKey || params.sessionId

? getDiagnosticSessionState({

...(params.sessionKey ? { sessionKey: params.sessionKey } : {}),

...(params.sessionId ? { sessionId: params.sessionId } : {}),

})

: undefined;

lastObservedToolCallHistoryIndex = guardSessionState?.toolCallHistory?.length ?? 0;

lastObservedToolOutcomeSeq = guardSessionState?.toolOutcomeSeq ?? 0;

}

const {